Spla

Classes
class	spla::Descriptor
	Descriptor object used to parametrize execution of particular scheduled tasks. More...
class	spla::MtxLoader
	Loader for matrix data stored in matrix-market (.mtx) format. More...
class	spla::Library
	Library global state automatically instantiated on lib init. More...
class	spla::Matrix
	Generalized M x N dimensional matrix object. More...
class	spla::Object
	Base class for any library primitive. More...
class	spla::Op
	An callable operation to parametrize execution of math computations. More...
class	spla::OpUnary
	Unary operation with 1-arity. More...
class	spla::OpBinary
	Binary operation with 2-arity. More...
class	spla::OpSelect
	Select operation with 1-arity and bool return type. More...
class	spla::RefCnt
	Base class for object with built-in reference counting mechanism. More...
class	spla::ref_ptr< T >
	Automates reference counting and behaves as shared smart pointer. More...
class	spla::Scalar
	Box for a single typed scalar value. More...
class	spla::ScheduleTask
	Represent single smallest evaluation tasks which can scheduled. More...
class	spla::Schedule
	Object with sequence of steps with tasks forming schedule for execution. More...
class	spla::Timer
	Simple timer to measure intervals of time on CPU-side. More...
class	spla::Type
	Type representation for parametrisation of containers stored values. More...
class	spla::Vector
	Generalized N dimensional vector object. More...
class	Status
	Status of library operation execution. More...
class	AcceleratorType
	Types of supported accelerators for computations. More...
class	FormatMatrix
	Named storage format for library matrix data objects. More...
class	FormatVector
	Named storage format for library vector data objects. More...
class	MessageCallback
	Callback function called on library message event. More...
class	ScheduleCallback
	Callback function which can be scheduled in schedule. More...

Typedefs
using	spla::uint = std::uint32_t
	Library index and size type.
using	spla::MessageCallback
using	spla::ScheduleCallback = std::function<void()>
using	spla::T_BOOL = bool
using	spla::T_INT = std::int32_t
using	spla::T_UINT = std::uint32_t
using	spla::T_FLOAT = float

Enumerations
enum class	spla::Status : uint {   spla::Status::Ok = 0 , spla::Status::Error = 1 , spla::Status::NoAcceleration = 2 , spla::Status::PlatformNotFound = 3 ,   spla::Status::DeviceNotFound = 4 , spla::Status::InvalidState = 5 , spla::Status::InvalidArgument = 6 , spla::Status::NoValue = 7 ,   spla::Status::CompilationError = 8 , spla::Status::NotImplemented = 1024 }
enum class	spla::AcceleratorType : uint { spla::AcceleratorType::None = 0 , spla::AcceleratorType::OpenCL = 1 }
enum class	spla::FormatMatrix : uint {   spla::FormatMatrix::CpuLil = 0 , spla::FormatMatrix::CpuDok = 1 , spla::FormatMatrix::CpuCoo = 2 , spla::FormatMatrix::CpuCsr = 3 ,   spla::FormatMatrix::CpuCsc = 4 , spla::FormatMatrix::AccCoo = 5 , spla::FormatMatrix::AccCsr = 6 , spla::FormatMatrix::AccCsc = 7 ,   spla::FormatMatrix::Count = 8 }
enum class	spla::FormatVector : uint {   spla::FormatVector::CpuDok = 0 , spla::FormatVector::CpuDense = 1 , spla::FormatVector::CpuCoo = 2 , spla::FormatVector::AccDense = 3 ,   spla::FormatVector::AccCoo = 4 , spla::FormatVector::Count = 5 }

Functions
Status	spla::bfs (const ref_ptr< Vector > &v, const ref_ptr< Matrix > &A, uint s, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	Breadth-first search algorithm.
Status	spla::bfs_naive (std::vector< int > &v, std::vector< std::vector< spla::uint > > &A, uint s, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	Naive breadth-first search algorithm (reference cpu implementation)
Status	spla::sssp (const ref_ptr< Vector > &v, const ref_ptr< Matrix > &A, uint s, const ref_ptr< Descriptor > &descriptor=ref_ptr< Descriptor >())
	Single-source shortest path algorithm.
Status	spla::sssp_naive (std::vector< float > &v, std::vector< std::vector< uint > > &Ai, std::vector< std::vector< float > > &Ax, uint s, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	Naive single-source shortest path algorithm (reference cpu implementation)
Status	spla::pr (ref_ptr< Vector > &p, const ref_ptr< Matrix > &A, float alpha=0.85, float eps=1e-6, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	PageRank algorithm.
Status	spla::pr_naive (std::vector< float > &p, std::vector< std::vector< uint > > &Ai, std::vector< std::vector< float > > &Ax, float alpha=0.85, float eps=1e-6, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	Naive PageRank algorithm (reference cpu implementation)
Status	spla::tc (int &ntrins, const ref_ptr< Matrix > &A, const ref_ptr< Matrix > &B, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	Triangles counting algorithm.
Status	spla::tc_naive (int &ntrins, std::vector< std::vector< spla::uint > > &Ai, const ref_ptr< Descriptor > &descriptor=spla::Descriptor::make())
	Naive triangles counting algorithm (reference cpu implementation)
template<typename T , typename... TArgs>
ref_ptr< T >	spla::make_ref (TArgs &&... args)
ref_ptr< Schedule >	spla::make_schedule ()
	Makes new schedule for making execution schedule.

Variables
ref_ptr< OpUnary >	spla::IDENTITY_INT
ref_ptr< OpUnary >	spla::IDENTITY_UINT
ref_ptr< OpUnary >	spla::IDENTITY_FLOAT
ref_ptr< OpUnary >	spla::AINV_INT
ref_ptr< OpUnary >	spla::AINV_UINT
ref_ptr< OpUnary >	spla::AINV_FLOAT
ref_ptr< OpUnary >	spla::MINV_INT
ref_ptr< OpUnary >	spla::MINV_UINT
ref_ptr< OpUnary >	spla::MINV_FLOAT
ref_ptr< OpUnary >	spla::LNOT_INT
ref_ptr< OpUnary >	spla::LNOT_UINT
ref_ptr< OpUnary >	spla::LNOT_FLOAT
ref_ptr< OpUnary >	spla::UONE_INT
ref_ptr< OpUnary >	spla::UONE_UINT
ref_ptr< OpUnary >	spla::UONE_FLOAT
ref_ptr< OpUnary >	spla::ABS_INT
ref_ptr< OpUnary >	spla::ABS_UINT
ref_ptr< OpUnary >	spla::ABS_FLOAT
ref_ptr< OpUnary >	spla::BNOT_INT
ref_ptr< OpUnary >	spla::BNOT_UINT
ref_ptr< OpUnary >	spla::SQRT_FLOAT
ref_ptr< OpUnary >	spla::LOG_FLOAT
ref_ptr< OpUnary >	spla::EXP_FLOAT
ref_ptr< OpUnary >	spla::SIN_FLOAT
ref_ptr< OpUnary >	spla::COS_FLOAT
ref_ptr< OpUnary >	spla::TAN_FLOAT
ref_ptr< OpUnary >	spla::ASIN_FLOAT
ref_ptr< OpUnary >	spla::ACOS_FLOAT
ref_ptr< OpUnary >	spla::ATAN_FLOAT
ref_ptr< OpUnary >	spla::CEIL_FLOAT
ref_ptr< OpUnary >	spla::FLOOR_FLOAT
ref_ptr< OpUnary >	spla::ROUND_FLOAT
ref_ptr< OpUnary >	spla::TRUNC_FLOAT
ref_ptr< OpBinary >	spla::PLUS_INT
ref_ptr< OpBinary >	spla::PLUS_UINT
ref_ptr< OpBinary >	spla::PLUS_FLOAT
ref_ptr< OpBinary >	spla::MINUS_INT
ref_ptr< OpBinary >	spla::MINUS_UINT
ref_ptr< OpBinary >	spla::MINUS_FLOAT
ref_ptr< OpBinary >	spla::MULT_INT
ref_ptr< OpBinary >	spla::MULT_UINT
ref_ptr< OpBinary >	spla::MULT_FLOAT
ref_ptr< OpBinary >	spla::DIV_INT
ref_ptr< OpBinary >	spla::DIV_UINT
ref_ptr< OpBinary >	spla::DIV_FLOAT
ref_ptr< OpBinary >	spla::MINUS_POW2_INT
ref_ptr< OpBinary >	spla::MINUS_POW2_UINT
ref_ptr< OpBinary >	spla::MINUS_POW2_FLOAT
ref_ptr< OpBinary >	spla::FIRST_INT
ref_ptr< OpBinary >	spla::FIRST_UINT
ref_ptr< OpBinary >	spla::FIRST_FLOAT
ref_ptr< OpBinary >	spla::SECOND_INT
ref_ptr< OpBinary >	spla::SECOND_UINT
ref_ptr< OpBinary >	spla::SECOND_FLOAT
ref_ptr< OpBinary >	spla::BONE_INT
ref_ptr< OpBinary >	spla::BONE_UINT
ref_ptr< OpBinary >	spla::BONE_FLOAT
ref_ptr< OpBinary >	spla::MIN_INT
ref_ptr< OpBinary >	spla::MIN_UINT
ref_ptr< OpBinary >	spla::MIN_FLOAT
ref_ptr< OpBinary >	spla::MAX_INT
ref_ptr< OpBinary >	spla::MAX_UINT
ref_ptr< OpBinary >	spla::MAX_FLOAT
ref_ptr< OpBinary >	spla::LOR_INT
ref_ptr< OpBinary >	spla::LOR_UINT
ref_ptr< OpBinary >	spla::LOR_FLOAT
ref_ptr< OpBinary >	spla::LAND_INT
ref_ptr< OpBinary >	spla::LAND_UINT
ref_ptr< OpBinary >	spla::LAND_FLOAT
ref_ptr< OpBinary >	spla::BOR_INT
ref_ptr< OpBinary >	spla::BOR_UINT
ref_ptr< OpBinary >	spla::BAND_INT
ref_ptr< OpBinary >	spla::BAND_UINT
ref_ptr< OpBinary >	spla::BXOR_INT
ref_ptr< OpBinary >	spla::BXOR_UINT
ref_ptr< OpSelect >	spla::EQZERO_INT
ref_ptr< OpSelect >	spla::EQZERO_UINT
ref_ptr< OpSelect >	spla::EQZERO_FLOAT
ref_ptr< OpSelect >	spla::NQZERO_INT
ref_ptr< OpSelect >	spla::NQZERO_UINT
ref_ptr< OpSelect >	spla::NQZERO_FLOAT
ref_ptr< OpSelect >	spla::GTZERO_INT
ref_ptr< OpSelect >	spla::GTZERO_UINT
ref_ptr< OpSelect >	spla::GTZERO_FLOAT
ref_ptr< OpSelect >	spla::GEZERO_INT
ref_ptr< OpSelect >	spla::GEZERO_UINT
ref_ptr< OpSelect >	spla::GEZERO_FLOAT
ref_ptr< OpSelect >	spla::LTZERO_INT
ref_ptr< OpSelect >	spla::LTZERO_UINT
ref_ptr< OpSelect >	spla::LTZERO_FLOAT
ref_ptr< OpSelect >	spla::LEZERO_INT
ref_ptr< OpSelect >	spla::LEZERO_UINT
ref_ptr< OpSelect >	spla::LEZERO_FLOAT
ref_ptr< OpSelect >	spla::ALWAYS_INT
ref_ptr< OpSelect >	spla::ALWAYS_UINT
ref_ptr< OpSelect >	spla::ALWAYS_FLOAT
ref_ptr< OpSelect >	spla::NEVER_INT
ref_ptr< OpSelect >	spla::NEVER_UINT
ref_ptr< OpSelect >	spla::NEVER_FLOAT
ref_ptr< Type >	spla::BOOL = TType<T_INT>::make_type("BOOL", "B", "bool", "4 byte logical type", 1)
ref_ptr< Type >	spla::INT = TType<T_INT>::make_type("INT", "I", "int", "signed 4 byte integral type", 2)
ref_ptr< Type >	spla::UINT = TType<T_UINT>::make_type("UINT", "U", "uint", "unsigned 4 byte integral type", 3)
ref_ptr< Type >	spla::FLOAT = TType<T_FLOAT>::make_type("FLOAT", "F", "float", "4 byte floating point type", 4)

Detailed Description

Typedef Documentation

MessageCallback

using spla::MessageCallback

Initial value:

 std::function<void(Status             status,
                                               const std::string& msg,
                                               const std::string& file,
                                               const std::string& function,
                                               int                line)>

ScheduleCallback

using spla::ScheduleCallback = std::function<void()>

T_BOOL

using spla::T_BOOL = bool

T_FLOAT

using spla::T_FLOAT = float

T_INT

using spla::T_INT = std::int32_t

T_UINT

using spla::T_UINT = std::uint32_t

uint

using spla::uint = std::uint32_t

Library index and size type.

Enumeration Type Documentation

AcceleratorType

enum class spla::AcceleratorType : uint

strong

Enumerator
None	No acceleration to be used
OpenCL	OpenCL-based single device acceleration

FormatMatrix

enum class spla::FormatMatrix : uint

strong

Enumerator
CpuLil	Matrix list of lists format for fast increment build
CpuDok	Matrix dictionary of keys for fast look-up of values
CpuCoo	Matrix coordinates list format
CpuCsr	Matrix compressed sparse rows format
CpuCsc	Matrix compressed sparse columns format
AccCoo	Matrix acceleration structured coo format
AccCsr	Matrix acceleration structured csr format
AccCsc	Matrix acceleration structured csc format
Count	Total number of supported matrix formats

FormatVector

enum class spla::FormatVector : uint

strong

Enumerator
CpuDok	Vector dictionary of keys representation
CpuDense	Vector dense array of values representation
CpuCoo	Vector list of values for sparse data
AccDense	Vector acceleration structured dense format
AccCoo	Vector acceleration structured coo format
Count	Total number of supported vector formats

Status

enum class spla::Status : uint

strong

Enumerator
Ok	No error
Error	Some error occurred
NoAcceleration	Library has no configured accelerator for computations
PlatformNotFound	Accelerator platform not found
DeviceNotFound	Accelerator device not found
InvalidState	Call of the function is not possible for some context
InvalidArgument	Passed invalid argument for some function
NoValue	No such requested value in matrix, vector or scalar storage
CompilationError	Failed to compile GPU/ACC kernel
NotImplemented	Some library feature is not implemented

Function Documentation

bfs()

Status spla::bfs	(	const ref_ptr< Vector > &	v,
		const ref_ptr< Matrix > &	A,
		uint	s,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

Breadth-first search algorithm.

Parameters

v	int vector to store reached distances
A	int matrix filled with 1 where exist edge from i to j
s	start vertex id to search
descriptor	optional descriptor for algorithm

Returns

ok on success

bfs_naive()

Status spla::bfs_naive	(	std::vector< int > &	v,
		std::vector< std::vector< spla::uint > > &	A,
		uint	s,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

Naive breadth-first search algorithm (reference cpu implementation)

Parameters

v	int vector to store reached distances
A	int graph adjacency lists filled with 1 where exist edge from i to j
s	start vertex id to search
descriptor	optional descriptor for algorithm

Returns

ok on success

make_ref()

template<typename T , typename... TArgs>

ref_ptr< T > spla::make_ref

(

TArgs &&...

args

)

make_schedule()

ref_ptr< Schedule > spla::make_schedule

(

)

Makes new schedule for making execution schedule.

Returns

New created schedule

pr()

Status spla::pr	(	ref_ptr< Vector > &	p,
		const ref_ptr< Matrix > &	A,
		float	alpha = 0.85,
		float	eps = 1e-6,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

PageRank algorithm.

Parameters

p	float vector to store result vertices weights
A	float graph matrix with weights A[i][j] = alpha / outdegree(i)
alpha	float alpha to control PageRank (default is 0.85)
eps	float tolerance to control precision of PageRank (default is 1e-6)
descriptor	optional descriptor for algorithm

Returns

ok on success

pr_naive()

Status spla::pr_naive	(	std::vector< float > &	p,
		std::vector< std::vector< uint > > &	Ai,
		std::vector< std::vector< float > > &	Ax,
		float	alpha = 0.85,
		float	eps = 1e-6,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

Naive PageRank algorithm (reference cpu implementation)

Parameters

p	float vector to store result vertices weights
Ai	float graph matrix column indices
Ax	float graph matrix weights A[i][j] = alpha / outdegree(i)
alpha	float alpha to control PageRank (default is 0.85)
eps	float tolerance to control precision of PageRank (default is 1e-6)
descriptor	optional descriptor for algorithm

Returns

ok on success

sssp()

Status spla::sssp	(	const ref_ptr< Vector > &	v,
		const ref_ptr< Matrix > &	A,
		uint	s,
		const ref_ptr< Descriptor > &	descriptor = ref_ptr<Descriptor>() )

Single-source shortest path algorithm.

Parameters

v	float vector to store reached distances
A	float matrix filled with >0.0f distances where exist edge from i to j otherwise 0.0f
s	start vertex id to search
descriptor	optional descriptor for algorithm

Returns

ok on success

sssp_naive()

Status spla::sssp_naive	(	std::vector< float > &	v,
		std::vector< std::vector< uint > > &	Ai,
		std::vector< std::vector< float > > &	Ax,
		uint	s,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

Naive single-source shortest path algorithm (reference cpu implementation)

Parameters

v	float vector to store reached distances
Ai	uint matrix column indices
Ax	float matrix values with >0.0f distances where exist edge from i to j
s	start vertex id to search
descriptor	optional descriptor for algorithm

Returns

ok on success

tc()

Status spla::tc	(	int &	ntrins,
		const ref_ptr< Matrix > &	A,
		const ref_ptr< Matrix > &	B,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

Triangles counting algorithm.

Parameters

ntrins	Number of triangles counted
A	Lower trilingual int matrix with 1 where has edge in a graph
B	Buffer int matrix to store result
descriptor	optional descriptor for algorithm

Returns

ok on success

tc_naive()

Status spla::tc_naive	(	int &	ntrins,
		std::vector< std::vector< spla::uint > > &	Ai,
		const ref_ptr< Descriptor > &	descriptor = spla::Descriptor::make() )

Naive triangles counting algorithm (reference cpu implementation)

Parameters

ntrins	Number of triangles counted
A	Lower trilingual int matrix structure
descriptor	optional descriptor for algorithm

Returns

ok on success

Variable Documentation

ABS_FLOAT

ref_ptr< OpUnary > spla::ABS_FLOAT

ABS_INT

ref_ptr< OpUnary > spla::ABS_INT

ABS_UINT

ref_ptr< OpUnary > spla::ABS_UINT

ACOS_FLOAT

ref_ptr< OpUnary > spla::ACOS_FLOAT

AINV_FLOAT

ref_ptr< OpUnary > spla::AINV_FLOAT

AINV_INT

ref_ptr< OpUnary > spla::AINV_INT

AINV_UINT

ref_ptr< OpUnary > spla::AINV_UINT

ALWAYS_FLOAT

ref_ptr< OpSelect > spla::ALWAYS_FLOAT

ALWAYS_INT

ref_ptr< OpSelect > spla::ALWAYS_INT

ALWAYS_UINT

ref_ptr< OpSelect > spla::ALWAYS_UINT

ASIN_FLOAT

ref_ptr< OpUnary > spla::ASIN_FLOAT

ATAN_FLOAT

ref_ptr< OpUnary > spla::ATAN_FLOAT

BAND_INT

ref_ptr< OpBinary > spla::BAND_INT

BAND_UINT

ref_ptr< OpBinary > spla::BAND_UINT

BNOT_INT

ref_ptr< OpUnary > spla::BNOT_INT

BNOT_UINT

ref_ptr< OpUnary > spla::BNOT_UINT

BONE_FLOAT

ref_ptr< OpBinary > spla::BONE_FLOAT

BONE_INT

ref_ptr< OpBinary > spla::BONE_INT

BONE_UINT

ref_ptr< OpBinary > spla::BONE_UINT

BOOL

ref_ptr< Type > spla::BOOL = TType<T_INT>::make_type("BOOL", "B", "bool", "4 byte logical type", 1)

BOR_INT

ref_ptr< OpBinary > spla::BOR_INT

BOR_UINT

ref_ptr< OpBinary > spla::BOR_UINT

BXOR_INT

ref_ptr< OpBinary > spla::BXOR_INT

BXOR_UINT

ref_ptr< OpBinary > spla::BXOR_UINT

CEIL_FLOAT

ref_ptr< OpUnary > spla::CEIL_FLOAT

COS_FLOAT

ref_ptr< OpUnary > spla::COS_FLOAT

DIV_FLOAT

ref_ptr< OpBinary > spla::DIV_FLOAT

DIV_INT

ref_ptr< OpBinary > spla::DIV_INT

DIV_UINT

ref_ptr< OpBinary > spla::DIV_UINT

EQZERO_FLOAT

ref_ptr< OpSelect > spla::EQZERO_FLOAT

EQZERO_INT

ref_ptr< OpSelect > spla::EQZERO_INT

EQZERO_UINT

ref_ptr< OpSelect > spla::EQZERO_UINT

EXP_FLOAT

ref_ptr< OpUnary > spla::EXP_FLOAT

FIRST_FLOAT

ref_ptr< OpBinary > spla::FIRST_FLOAT

FIRST_INT

ref_ptr< OpBinary > spla::FIRST_INT

FIRST_UINT

ref_ptr< OpBinary > spla::FIRST_UINT

FLOAT

ref_ptr< Type > spla::FLOAT = TType<T_FLOAT>::make_type("FLOAT", "F", "float", "4 byte floating point type", 4)

FLOOR_FLOAT

ref_ptr< OpUnary > spla::FLOOR_FLOAT

GEZERO_FLOAT

ref_ptr< OpSelect > spla::GEZERO_FLOAT

GEZERO_INT

ref_ptr< OpSelect > spla::GEZERO_INT

GEZERO_UINT

ref_ptr< OpSelect > spla::GEZERO_UINT

GTZERO_FLOAT

ref_ptr< OpSelect > spla::GTZERO_FLOAT

GTZERO_INT

ref_ptr< OpSelect > spla::GTZERO_INT

GTZERO_UINT

ref_ptr< OpSelect > spla::GTZERO_UINT

IDENTITY_FLOAT

ref_ptr< OpUnary > spla::IDENTITY_FLOAT

IDENTITY_INT

ref_ptr< OpUnary > spla::IDENTITY_INT

IDENTITY_UINT

ref_ptr< OpUnary > spla::IDENTITY_UINT

INT

ref_ptr< Type > spla::INT = TType<T_INT>::make_type("INT", "I", "int", "signed 4 byte integral type", 2)

LAND_FLOAT

ref_ptr< OpBinary > spla::LAND_FLOAT

LAND_INT

ref_ptr< OpBinary > spla::LAND_INT

LAND_UINT

ref_ptr< OpBinary > spla::LAND_UINT

LEZERO_FLOAT

ref_ptr< OpSelect > spla::LEZERO_FLOAT

LEZERO_INT

ref_ptr< OpSelect > spla::LEZERO_INT

LEZERO_UINT

ref_ptr< OpSelect > spla::LEZERO_UINT

LNOT_FLOAT

ref_ptr< OpUnary > spla::LNOT_FLOAT

LNOT_INT

ref_ptr< OpUnary > spla::LNOT_INT

LNOT_UINT

ref_ptr< OpUnary > spla::LNOT_UINT

LOG_FLOAT

ref_ptr< OpUnary > spla::LOG_FLOAT

LOR_FLOAT

ref_ptr< OpBinary > spla::LOR_FLOAT

LOR_INT

ref_ptr< OpBinary > spla::LOR_INT

LOR_UINT

ref_ptr< OpBinary > spla::LOR_UINT

LTZERO_FLOAT

ref_ptr< OpSelect > spla::LTZERO_FLOAT

LTZERO_INT

ref_ptr< OpSelect > spla::LTZERO_INT

LTZERO_UINT

ref_ptr< OpSelect > spla::LTZERO_UINT

MAX_FLOAT

ref_ptr< OpBinary > spla::MAX_FLOAT

MAX_INT

ref_ptr< OpBinary > spla::MAX_INT

MAX_UINT

ref_ptr< OpBinary > spla::MAX_UINT

MIN_FLOAT

ref_ptr< OpBinary > spla::MIN_FLOAT

MIN_INT

ref_ptr< OpBinary > spla::MIN_INT

MIN_UINT

ref_ptr< OpBinary > spla::MIN_UINT

MINUS_FLOAT

ref_ptr< OpBinary > spla::MINUS_FLOAT

MINUS_INT

ref_ptr< OpBinary > spla::MINUS_INT

MINUS_POW2_FLOAT

ref_ptr< OpBinary > spla::MINUS_POW2_FLOAT

MINUS_POW2_INT

ref_ptr< OpBinary > spla::MINUS_POW2_INT

MINUS_POW2_UINT

ref_ptr< OpBinary > spla::MINUS_POW2_UINT

MINUS_UINT

ref_ptr< OpBinary > spla::MINUS_UINT

MINV_FLOAT

ref_ptr< OpUnary > spla::MINV_FLOAT

MINV_INT

ref_ptr< OpUnary > spla::MINV_INT

MINV_UINT

ref_ptr< OpUnary > spla::MINV_UINT

MULT_FLOAT

ref_ptr< OpBinary > spla::MULT_FLOAT

MULT_INT

ref_ptr< OpBinary > spla::MULT_INT

MULT_UINT

ref_ptr< OpBinary > spla::MULT_UINT

NEVER_FLOAT

ref_ptr< OpSelect > spla::NEVER_FLOAT

NEVER_INT

ref_ptr< OpSelect > spla::NEVER_INT

NEVER_UINT

ref_ptr< OpSelect > spla::NEVER_UINT

NQZERO_FLOAT

ref_ptr< OpSelect > spla::NQZERO_FLOAT

NQZERO_INT

ref_ptr< OpSelect > spla::NQZERO_INT

NQZERO_UINT

ref_ptr< OpSelect > spla::NQZERO_UINT

PLUS_FLOAT

ref_ptr< OpBinary > spla::PLUS_FLOAT

PLUS_INT

ref_ptr< OpBinary > spla::PLUS_INT

PLUS_UINT

ref_ptr< OpBinary > spla::PLUS_UINT

ROUND_FLOAT

ref_ptr< OpUnary > spla::ROUND_FLOAT

SECOND_FLOAT

ref_ptr< OpBinary > spla::SECOND_FLOAT

SECOND_INT

ref_ptr< OpBinary > spla::SECOND_INT

SECOND_UINT

ref_ptr< OpBinary > spla::SECOND_UINT

SIN_FLOAT

ref_ptr< OpUnary > spla::SIN_FLOAT

SQRT_FLOAT

ref_ptr< OpUnary > spla::SQRT_FLOAT

TAN_FLOAT

ref_ptr< OpUnary > spla::TAN_FLOAT

TRUNC_FLOAT

ref_ptr< OpUnary > spla::TRUNC_FLOAT

UINT

ref_ptr< Type > spla::UINT = TType<T_UINT>::make_type("UINT", "U", "uint", "unsigned 4 byte integral type", 3)

UONE_FLOAT

ref_ptr< OpUnary > spla::UONE_FLOAT

UONE_INT

ref_ptr< OpUnary > spla::UONE_INT

UONE_UINT

ref_ptr< OpUnary > spla::UONE_UINT