Getting Started

Documentation

Glish

Learn More

Programming

Contact Us

Version 1.9 Build 1556

News	FAQ
Search	Home

Functionality

In this section we list the full functionality available in the LEL classes.

The next small table lists the data type codes used subsequently.

Type	Code
Float	1
Double	2
Complex	3
DComplex	4
Bool	5

First we give a descriptive table of the available classes and the generic input Lattice expression types and output types that they handle.

Class	Description	Type that Operates on	Return Type
LELLattice	Reads Lattice pixels	1,2,3,4,5	1,2,3,4,5
LELUnary	Handles numerical unary operators	1,2,3,4	1,2,3,4
LELUnaryConst	Handles scalar constants	1,2,3,4,5	1,2,3,4,5
LELUnaryBool	Handles logical unary operators	5	5
LELBinary	Handles numerical binary operators	1,2,3,4	1,2,3,4
LELBinaryCmp	Handles relational binary numerical operators	1,2,3,4	5
LELBinaryBool	Handles logical binary operators	5	5
LELFunction1D	Handles numerical 1-argument functions	1,2,3,4	1,2,3,4
LELFunctionND	Handles numerical N-argument functions	1,2,3,4	1,2,3,4
LELFunctionReal1D	Handles real numerical 1-argument functions	1,2	1,2
LELFunctionFloat	Handles numerical N-argument functions returning Float	1,3	1
LELFunctionDouble	Handles numerical N-argument functions returning Double	2,4	2
LELFunctionComplex	Handles complex numerical N-argument functions	3	3
LELFunctionDComplex	Handles double complex numerical N-argument functions	4	4
LELFunctionBool	Handles logical N-argument functions	5	5

Note that some classes are essentially non-templated specializations of others. For example, LELFunctionReal1D handles functions that couldn't be in LELFunction1D because there was no complex version of that function (e.g. asin) so templating would fail.

In the usage column of the last table, the examples use the following objects:

   Lattice<Float> a;
   Lattice<Float> b;
   Lattice<Double> aDouble;
   Lattice<Double> bDouble;
   Lattice<Complex> aComplex;
   Lattice<Complex> bComplex;
   Lattice<DComplex> aDComplex;
   Lattice<DComplex> bDComplex;
   Lattice<Bool> aBool;
   Lattice<Bool> bBool;
   Double const;
   LatticeExprNode expr;

Class	Operation	Input Data Type	Result dim.	Arguments	Usage example
LELLattice	getSlice	1,2,3,4,5	Array	1	expr = a
LELUnary	-	1,2,3,4	Scalar,Array	1	expr = - a
	+	1,2,3,4	Scalar,Array	1	expr = +a (does nothing)
LELUnaryConst	constant	1,2,3,4,5	Scalar	1	expr = const
LELUnaryBool	!	5	Scalar,Array	1	expr = !aBool
LELBinary	+	1,2,3,4	Scalar,Array	2	expr = a+b
	-	1,2,3,4	Scalar,Array	2	expr = a-b
	*	1,2,3,4	Scalar,Array	2	expr = a*b
	/	1,2,3,4	Scalar,Array	2	expr = a/b
LELBinaryCmp	==	1,2,3,4	Scalar,Array	2	expr = a==b
	!=	1,2,3,4	Scalar,Array	2	expr = a!=b
	>	1,2,3,4	Scalar,Array	2	expr = a>b
	<	1,2,3,4	Scalar,Array	2	expr = a<b
	> =	1,2,3,4	Scalar,Array	2	expr = a> =b
	> =	1,2,3,4	Scalar,Array	2	expr = a< =b
LELBinaryBool	==	5	Scalar,Array	2	expr = aBool==bBool
	!=	5	Scalar,Array	2	expr = aBool!=bBool
	&&	5	Scalar,Array	2	expr = Bool&&bBool
	||	5	Scalar,Array	2	expr = Bool||bBool
LELFunction1D	sin	1,2,3,4	Scalar,Array	1	expr = sin(a)
	sinh	1,2,3,4	Scalar,Array	1	expr = sinh(a)
	cos	1,2,3,4	Scalar,Array	1	expr = cos(a)
	cosh	1,2,3,4	Scalar,Array	1	expr = cosh(a)
	exp	1,2,3,4	Scalar,Array	1	expr = exp(a)
	log	1,2,3,4	Scalar,Array	1	expr = log(a)
	log10	1,2,3,4	Scalar,Array	1	expr = log10(a)
	sqrt	1,2,3,4	Scalar,Array	1	expr = sqrt(a)
	min	1,2,3,4	Scalar	1	expr = min(a)
	max	1,2,3,4	Scalar	1	expr = max(a)
	mean	1,2,3,4	Scalar	1	expr = meann(a)
	sum	1,2,3,4	Scalar	1	expr = sum(a)
LELFunctionND	iif	1,2,3,4	Scalar,Array	1	expr = iif(aBool,a,b)
LELFunctionReal1D	asin	1,2	Scalar,Array	1	expr = asin(a)
	acos	1,2	Scalar,Array	1	expr = acos(a)
	tan	1,2	Scalar,Array	1	expr = tan(a)
	atan	1,2	Scalar,Array	1	expr = atan(a)
	tanh	1,2	Scalar,Array	1	expr = tanh(a)
	ceil	1,2	Scalar,Array	1	expr = ceil(a)
	floor	1,2	Scalar,Array	1	expr = floor(a)
LELFunctionFloat	min	1	Scalar,Array	2	expr = min(a,b)
	max	1	Scalar,Array	2	expr = max(a,b)
	pow	1	Scalar,Array	2	expr = pow(a,b)
	atan2	1	Scalar,Array	2	expr = atan2(a,b)
	fmod	1	Scalar,Array	2	expr = fmod(a,b)
	abs	1,3	Scalar,Array	1	expr = abs(a), abs(aComplex)
	arg	3	Scalar,Array	1	expr = arg(aComplex)
	real	1,3	Scalar,Array	1	expr = real(aComplex)
	imag	1,3	Scalar,Array	1	expr = imag(aComplex)

Class	Operation	Input Data Type	Result dim.	Arguments	Usage example
LELFunctionDouble	min	2	Scalar,Array	2	expr = min(aDouble,bDouble)
	max	2	Scalar,Array	2	expr = max(aDouble,bDouble)
	pow	2	Scalar,Array	2	expr = pow(aDouble,bDouble)
	atan2	2	Scalar,Array	2	expr = atan2(aDouble,bDouble)
	fmod	2	Scalar,Array	2	expr = fmod(aDouble,bDouble)
	abs	2,4	Scalar,Array	1	expr = abs(aDouble), abs(aDComplex)
	arg	4	Scalar,Array	1	expr = arg(aDComplex)
	real	2,4	Scalar,Array	1	expr = real(aDComplex)
	imag	2,4	Scalar,Array	1	expr = imag(aDComplex)
LELFunctionDouble	ntrue	5	Scalar	1	expr = ntrue(aBool)
	nfalse	5	Scalar	1	expr = nfalse(aBool)
LELFunctionDouble	nelements	Any	Scalar	1	expr = nelements(a)
LELFunctionComplex	pow	3	Scalar,Array	2	expr = pow(aComplex,bComplex)
	conj	3	Scalar,Array	1	expr = conj(aComplex)
LELFunctionDComplex	pow	4	Scalar,Array	2	expr = pow(aDComplex,bDComplex)
	conj	4	Scalar,Array	1	expr = conj(aComplex)
LELFunctionBool	all	5	Scalar	1	expr = all(aBool)
	any	5	Scalar	1	expr = any(aBool)
LatticeExprNode	amp	1,2,3,4	Scalar,Array	2	expr = amp(a,b)
LatticeExprNode	pa	1,2	Scalar,Array	2	expr = pa(a,b)