dlr::numeric Namespace Reference

This namespace contains code for 1D, 2D, and 3D arrays, matrices, coordinate transformations, rotation conversions, and much more. More...

Classes
class	AmanatidesWoo2D
	This class implements the Fast Voxel Traversal Algorithm of Amanatides and Woo [Ref] for 2D arrays. More...
class	AmanatidesWoo2DIterator
	This class provides access to the elements of a data array along a straight path, and does the actual work of Amanatides and Woo's fast voxel traversal algorithm. More...
class	AmanatidesWoo3D
	This class implements the Fast Voxel Traversal Algorithm of Amanatides and Woo [Ref] for 3D arrays. More...
class	AmanatidesWoo3DIterator
	This class provides access to the elements of a data array along a straight path, and does the actual work of Amanatides and Woo's fast voxel traversal algorithm. More...
class	Array1D
	The Array1D class template represents a 1D array of arbitrary type. More...
class	Array2D
	The Array2D class template represents a 2D array of arbitrary type. More...
class	Array3D
	The Array3D class template represents a 3D array of arbitrary type. More...
class	BilinearInterpolator
class	BSpline
	Warning: This class is very new, and its test suite is still incomplete. More...
struct	Gaussian1DFunctor
	Functor template which computes the value of a Gaussian evaluated at its argument. More...
struct	LogFunctor
	Functor template which computes the natural logarithm of its argument (using std::log(), if appropriate). More...
struct	NumericTypeConversionFunctor
	Functor template which uses static_cast to convert instances of one type into instances of another, but does the right thing with regard to rounding, so that the difference between the input and the returned value is minimized. More...
struct	SquareRootFunctor
	Functor template which computes the square root of its argument (using std::sqrt(), if appropriate). More...
class	IEEEFloat32
	The IEEEFloat32 class is for manipulating 32-bit IEEE floating point numbers. More...
class	Index2D
	The Index2D class represents a 2 dimensional index in (row, column) format, such as (0, 1), (23, 7), or (-4, 2). More...
class	NumericTraits
	This class is used to customize the behavior of dlr_libs classes & functions for specific numeric types. More...
class	NumericTraits< char >
	This class is used to customize the behavior of dlr_libs classes & functions for the char type. More...
class	NumericTraits< unsigned char >
	This class is used to customize the behavior of dlr_libs classes & functions for the unsigned char type. More...
class	NumericTraits< short >
	This class is used to customize the behavior of dlr_libs classes & functions for the short type. More...
class	NumericTraits< int >
	This class is used to customize the behavior of dlr_libs classes & functions for the int type. More...
class	NumericTraits< long >
	This class is used to customize the behavior of dlr_libs classes & functions for the long type. More...
class	NumericTraits< float >
	This class is used to customize the behavior of dlr_libs classes & functions for the float type. More...
class	NumericTraits< double >
	This class is used to customize the behavior of dlr_libs classes & functions for the double type. More...
class	Polynomial
	This class represents polynomials of the form. More...
class	Quaternion
	This class implements a quaternion. More...
class	Slice
	A simple Slice class to work with SubArrays. More...
class	StencilIterator
	WARNING: This class is still under development and quite unstable. More...
class	Stencil2D
	WARNING: This class is still under development and quite unstable. More...
class	SubArray1D
	Header file defining a simple SubArray class to work with Array1D.h The goal here is simplicity. More...
class	SubArray2D
	Header file defining a simple SubArray class to work with Array2D.h The goal here is simplicity. More...
class	Transform2D
	The Transform2D class represents a homogeneous coordinate transform from one 2D coordinate system to another 2D coordinate system. More...
class	Transform2DFunctor
	This helper class works with Transform2D::getFunctor(). More...
class	Transform3D
	The Transform3D class represents a homogeneous coordinate transform from one 3D coordinate system to another 3D coordinate system. More...
class	Transform3DFunctor
	This helper class works with Transform3D::getFunctor(). More...
class	Transform3DTo2D
	The Transform3DTo2D class represents a homogeneous coordinate transformation from a 3D coordinate system to a 2D coordinate system. More...
class	Transform3DTo2DFunctor
	This helper class works with Transform3DTo2D::getFunctor(). More...
class	Vector2D
	The Vector2D class represents a real valued 2D vector. More...
class	Vector3D
	The Vector2D class represents a real valued 2D vector. More...
Namespaces
namespace	constants
Enumerations
enum	ConvolutionStrategy {   DLR_CONVOLVE_TRUNCATE_RESULT, DLR_CONVOLVE_PAD_RESULT, DLR_CONVOLVE_ZERO_PAD_RESULT, DLR_CONVOLVE_PAD_SIGNAL,   DLR_CONVOLVE_ZERO_PAD_SIGNAL, DLR_CONVOLVE_REFLECT_SIGNAL, DLR_CONVOLVE_WRAP_SIGNAL }
enum	ConvolutionROI { DLR_CONVOLVE_ROI_SAME, DLR_CONVOLVE_ROI_VALID, DLR_CONVOLVE_ROI_FULL }
Functions
template<class Type>
Array1D< Type >	operator+ (const Array1D< Type > &array0, const Array1D< Type > &array1)
	Elementwise addition of Array1D instances.
template<class Type>
Array1D< Type >	operator- (const Array1D< Type > &array0, const Array1D< Type > &array1)
	Elementwise subtraction of Array1D instances.
template<class Type>
Array1D< Type >	operator * (const Array1D< Type > &array0, const Array1D< Type > &array1)
	Elementwise multiplication of Array1D instances.
template<class Type>
Array1D< Type >	operator/ (const Array1D< Type > &array0, const Array1D< Type > &array1)
	Elementwise division of Array1D instances.
template<class Type>
Array1D< Type >	operator+ (const Array1D< Type > &array, Type scalar)
	Addition of Array1D and scalar.
template<class Type>
Array1D< Type >	operator- (const Array1D< Type > &array0, Type scalar)
	Subtraction of Array1D and scalar.
template<class Type>
Array1D< Type >	operator * (const Array1D< Type > &array0, Type scalar)
	Multiplication of Array1D and scalar.
template<class Type>
Array1D< Type >	operator/ (const Array1D< Type > &array0, Type scalar)
	Division of Array1D and scalar.
template<class Type>
Array1D< Type >	operator+ (Type scalar, const Array1D< Type > &array0)
	Addition of scalar and Array1D.
template<class Type>
Array1D< Type >	operator- (Type scalar, const Array1D< Type > &array0)
	Subtraction of scalar and Array1D.
template<class Type>
Array1D< Type >	operator * (Type scalar, const Array1D< Type > &array0)
	Multiplication of scalar and Array1D.
template<class Type>
Array1D< Type >	operator/ (Type scalar, const Array1D< Type > &array0)
	Division of scalar and Array1D.
template<class Type>
Array1D< bool >	operator== (const Array1D< Type > &array0, const Type arg)
	Elementwise comparison of an Array1D with a constant.
template<class Type>
Array1D< bool >	operator== (const Array1D< Type > &array0, const Array1D< Type > &array1)
	Elementwise comparison of an Array1D with another array.
template<class Type>
Array1D< bool >	operator> (const Array1D< Type > &array0, const Type arg)
	Elementwise comparison of an Array1D with a constant.
template<class Type>
Array1D< bool >	operator>= (const Array1D< Type > &array0, const Type arg)
	Elementwise comparison of an Array1D with a constant.
template<class Type>
Array1D< bool >	operator< (const Array1D< Type > &array0, const Type arg)
	Elementwise comparison of an Array1D with a constant.
template<class Type>
Array1D< bool >	operator<= (const Array1D< Type > &array0, const Type arg)
	Elementwise comparison of an Array1D with a constant.
template<class Type>
std::ostream &	operator<< (std::ostream &stream, const Array1D< Type > &array0)
	Outputs a text representation of an Array1D instance to a std::ostream.
template<class Type>
std::istream &	operator>> (std::istream &stream, Array1D< Type > &array0)
	Sets the value of an Array1D instance from a std::istream.
template<class Type>
Array2D< Type >	squareRoot (const Array2D< Type > &array0)
	This function returns an array which is the same size as its argument, and in which the value of each element is the square root of the corresponding element of the argument.
template<class Type>
Array2D< Type >	sqrt (const Array2D< Type > &array0)
	This function returns an array which is the same size as its argument, and in which the value of each element is the square root of the corresponding element of the argument.
template<class Type>
Array2D< Type >	operator+ (const Array2D< Type > &array0, const Array2D< Type > &array1)
	Elementwise addition of Array2D instances.
template<class Type>
Array2D< Type >	operator- (const Array2D< Type > &array0, const Array2D< Type > &array1)
	Elementwise subtraction of Array2D instances.
template<class Type>
Array2D< Type >	operator * (const Array2D< Type > &array0, const Array2D< Type > &array1)
	Elementwise multiplication of Array2D instances.
template<class Type>
Array2D< Type >	operator/ (const Array2D< Type > &array0, const Array2D< Type > &array1)
	Elementwise division of Array2D instances.
template<class Type>
Array2D< Type >	operator+ (const Array2D< Type > &array0, Type scalar)
	Addition of Array2D and scalar.
template<class Type>
Array2D< Type >	operator- (const Array2D< Type > &array0, Type scalar)
	Subtraction of Array2D and scalar.
template<class Type>
Array2D< Type >	operator * (const Array2D< Type > &array0, Type scalar)
	Multiplication of Array2D and scalar.
template<class Type>
Array2D< Type >	operator/ (const Array2D< Type > &array0, Type scalar)
	Division of Array2D and scalar.
template<class Type>
Array2D< Type >	operator+ (Type scalar, const Array2D< Type > &array0)
	Addition of scalar and Array2D.
template<class Type>
Array2D< Type >	operator * (Type scalar, const Array2D< Type > &array0)
	Multiplication of scalar and Array2D.
template<class Type>
Array2D< bool >	operator== (const Array2D< Type > &array0, const Type arg)
	Elementwise comparison of an Array2D with a constant.
template<class Type>
Array2D< bool >	operator== (const Array2D< Type > &array0, const Array2D< Type > &array1)
	Elementwise comparison of an Array2D with another array.
template<class Type>
Array2D< bool >	operator> (const Array2D< Type > &array0, Type arg)
	Elementwise comparison of Array2D with a constant.
template<class Type>
Array2D< bool >	operator< (const Array2D< Type > &array0, Type arg)
	Elementwise comparison of Array2D with a constant.
template<class Type>
Array2D< bool >	operator>= (const Array2D< Type > &array0, Type arg)
	Elementwise comparison of Array2D with a constant.
template<class Type>
Array2D< bool >	operator<= (const Array2D< Type > &array0, Type arg)
	Elementwise comparison of Array2D with a constant.
template<class Type>
std::ostream &	operator<< (std::ostream &stream, const Array2D< Type > &array0)
	Outputs a text representation of an Array2D instance to a std::ostream.
template<class Type>
std::istream &	operator>> (std::istream &stream, Array2D< Type > &array0)
	Sets the value of an Array2D instance from a std::istream.
template<class Type>
Array3D< Type >	operator+ (const Array3D< Type > &array0, const Array3D< Type > &array1)
	Elementwise addition of Array3D instances.
template<class Type>
Array3D< Type >	operator- (const Array3D< Type > &array0, const Array3D< Type > &array1)
	Elementwise subtraction of Array3D instances.
template<class Type>
Array3D< Type >	operator * (const Array3D< Type > &array0, const Array3D< Type > &array1)
	Elementwise multiplication of Array3D instances.
template<class Type>
Array3D< Type >	operator/ (const Array3D< Type > &array0, const Array3D< Type > &array1)
	Elementwise division of Array3D instances.
template<class Type>
Array3D< Type >	operator+ (const Array3D< Type > &array0, Type scalar)
	Addition of Array3D and scalar.
template<class Type>
Array3D< Type >	operator- (const Array3D< Type > &array0, Type scalar)
	Subtraction of Array3D and scalar.
template<class Type>
Array3D< Type >	operator * (const Array3D< Type > &array0, Type scalar)
	Multiplication of Array3D and scalar.
template<class Type>
Array3D< Type >	operator/ (const Array3D< Type > &array0, Type scalar)
	Division of Array3D and scalar.
template<class Type>
Array3D< Type >	operator+ (Type scalar, const Array3D< Type > &array0)
	Addition of scalar and Array3D.
template<class Type>
Array3D< Type >	operator * (Type scalar, const Array3D< Type > &array0)
	Multiplication of scalar and Array3D.
template<class Type>
Array3D< bool >	operator== (const Array3D< Type > &array0, const Type arg)
	Elementwise comparison of an Array3D with a constant.
template<class Type>
Array3D< bool >	operator== (const Array3D< Type > &array0, const Array3D< Type > &array1)
	Elementwise comparison of an Array3D with another array.
template<class Type>
Array3D< bool >	operator< (const Array3D< Type > &array0, Type arg)
	Elementwise comparison of Array2D with a constant.
template<class Type>
Array3D< bool >	operator<= (const Array3D< Type > &array0, Type arg)
	Elementwise comparison of Array3D with a constant.
template<class Type>
Array3D< bool >	operator> (const Array3D< Type > &array0, Type arg)
	Elementwise comparison of Array3D with a constant.
template<class Type>
Array3D< bool >	operator>= (const Array3D< Type > &array0, Type arg)
	Elementwise comparison of Array3D with a constant.
template<class Type>
std::ostream &	operator<< (std::ostream &stream, const Array3D< Type > &array0)
	This operator outputs a text representation of an Array3D instance to a std::ostream.
template<class Type>
std::istream &	operator>> (std::istream &stream, Array3D< Type > &array0)
	This operator sets the value of an Array3D instance from a std::istream.
template<class Type>
Array1D< Type >	convolve (const Array1D< Type > &kernel, const Array1D< Type > &signal, ConvolutionStrategy strategy)
template<class Type0, class Type1>
Array1D< Type1 >	convolve (const Array1D< Type0 > &kernel, const Array1D< Type0 > &signal, type_tag< Type1 > resultTag, ConvolutionStrategy strategy=DLR_CONVOLVE_ZERO_PAD_RESULT)
template<class Type>
Array1D< Type >	correlate (const Array1D< Type > &kernel, const Array1D< Type > &signal, ConvolutionStrategy strategy=DLR_CONVOLVE_ZERO_PAD_RESULT)
template<class Type0, class Type1>
Array1D< Type1 >	correlate (const Array1D< Type0 > &kernel, const Array1D< Type0 > &signal, type_tag< Type1 > resultTag, ConvolutionStrategy strategy=DLR_CONVOLVE_ZERO_PAD_RESULT)
template<class OutputType, class KernelType, class SignalType>
Array1D< OutputType >	convolve1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy=DLR_CONVOLVE_ZERO_PAD_RESULT, ConvolutionROI roi=DLR_CONVOLVE_ROI_SAME)
template<class OutputType, class KernelType, class SignalType, class FillType>
Array1D< OutputType >	convolve1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy, ConvolutionROI roi, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class KernelType, class SignalType>
Array1D< OutputType >	convolve1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy, int boundary0, int boundary1)
	Unstable: interface subject to change.
template<class OutputType, class KernelType, class SignalType, class FillType>
Array1D< OutputType >	convolve1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy, int boundary0, int boundary1, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class KernelType, class SignalType>
Array1D< OutputType >	correlate1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy=DLR_CONVOLVE_ZERO_PAD_RESULT, ConvolutionROI roi=DLR_CONVOLVE_ROI_SAME)
	Unstable: interface subject to change.
template<class OutputType, class KernelType, class SignalType, class FillType>
Array1D< OutputType >	correlate1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy, ConvolutionROI roi, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class KernelType, class SignalType>
Array1D< OutputType >	correlate1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy, int boundary0, int boundary1)
	Unstable: interface subject to change.
template<class OutputType, class KernelType, class SignalType, class FillType>
Array1D< OutputType >	correlate1D (const Array1D< KernelType > &kernel, const Array1D< SignalType > &signal, ConvolutionStrategy strategy, int boundary0, int boundary1, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType>
Array2D< OutputType >	convolve2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy=DLR_CONVOLVE_PAD_RESULT, ConvolutionROI roi=DLR_CONVOLVE_ROI_SAME)
template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>
Array2D< OutputType >	convolve2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy, ConvolutionROI roi, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType>
Array2D< OutputType >	convolve2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy, const Index2D &corner0, const Index2D &corner1)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>
Array2D< OutputType >	convolve2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy, const Index2D &corner0, const Index2D &corner1, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType>
Array2D< OutputType >	correlate2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy=DLR_CONVOLVE_PAD_RESULT, ConvolutionROI roi=DLR_CONVOLVE_ROI_SAME)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>
Array2D< OutputType >	correlate2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy, ConvolutionROI roi, const FillType &fillValue)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType>
Array2D< OutputType >	correlate2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy, const Index2D &corner0, const Index2D &corner1)
	Unstable: interface subject to change.
template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>
Array2D< OutputType >	correlate2D (const Array2D< KernelType > &kernel, const Array2D< SignalType > &signal, ConvolutionStrategy strategy, const Index2D &corner0, const Index2D &corner1, const FillType &fillValue)
	Unstable: interface subject to change.
bool	bilaterate (const Vector2D &point0, const Vector2D &point1, double range0, double range1, Vector2D &intersection0, Vector2D &intersection1)
	This function finds a 2D point, given two other points and distance between each of those points and the point to be recovered.
Index2D	operator+ (const Index2D &index0, const Index2D &index1)
	This operator returns the elementwise sum of two Index2D instances.
Index2D	operator- (const Index2D &index0, const Index2D &index1)
	This operator returns the elementwise difference of two Index2D instances.
Index2D	operator * (const Index2D &index0, const Index2D &index1)
	This operator returns the elementwise product of two Index2D instances.
Index2D	operator/ (const Index2D &index0, const Index2D &index1)
	This operator returns the elementwise dividend of two Index2D instances.
Index2D	operator+ (const Index2D &index0, int scalar0)
	This operator adds a scalar and an Index2D.
Index2D	operator- (const Index2D &index0, int scalar0)
	This operator subtracts a scalar from an Index2D.
Index2D	operator * (const Index2D &index0, int scalar0)
	This operator multiplies an Index2D by scalar.
Index2D	operator/ (const Index2D &index0, int scalar0)
	This operator divides an Index2D by scalar.
bool	operator== (const Index2D &index0, const Index2D &index1)
	This operator checks the supplied indexs for equality.
bool	operator!= (const Index2D &index0, const Index2D &index1)
	This operator checks the supplied indexs for inequality.
std::ostream &	operator<< (std::ostream &stream, const Index2D &index0)
	This function outputs a text representation of an Index2D instance to a std::ostream.
std::istream &	operator>> (std::istream &stream, Index2D &index0)
	This function sets the value of an Index2D instance from a std::istream.
Index2D	operator+ (int scalar0, const Index2D &index0)
	This operator adds a scalar value to each element of an Index2D instance.
Index2D	operator * (int scalar0, const Index2D &index0)
	This operator multiplies a scalar value with each element of a Index2D instance.
template<class Type>
Polynomial< Type >	operator * (const Polynomial< Type > &arg0, const Polynomial< Type > &arg1)
	This operator multiplies two Polynomial instances.
template<class Type>
Polynomial< Type >	operator+ (const Polynomial< Type > &arg0, const Polynomial< Type > &arg1)
	This operator adds two Polynomial instances.
template<class Type>
Polynomial< Type >	operator- (const Polynomial< Type > &arg0, const Polynomial< Type > &arg1)
	This operator subtracts two Polynomial instances.
Quaternion	conjugate (const Quaternion &source)
	This function returns the conjugate of a Quaternion, in which the sign of each imaginary component has been reversed.
Quaternion	angleAxisToQuaternion (double angle, const Vector3D &axis, bool isNormalized=false)
	This function converts a rotation from angle-axis representation to unit quaternion representation.
Vector3D	angleAxisToRollPitchYaw (double angle, const Vector3D &axis, bool isNormalized=false)
	This function converts a rotation from angle-axis representation to roll-pitch-yaw representation.
Transform3D	angleAxisToTransform3D (double angle, const Vector3D &axis, bool isNormalized=false)
	This function converts a rotation from angle-axis representation to Transform3D representation.
std::pair< double, Vector3D >	quaternionToAngleAxis (const Quaternion &quaternion)
	This function converts a rotation from Quaternion representation to Angle-Axis representation.
Vector3D	quaternionToRollPitchYaw (const Quaternion &quaternion)
	This function converts a rotation from Quaternion representation to Roll-Pitch-Yaw representation.
Transform3D	quaternionToTransform3D (const Quaternion &quaternion)
	This function converts a rotation from Quaternion representation to Transform3D representation.
std::pair< double, Vector3D >	rollPitchYawToAngleAxis (const Vector3D &rollPitchYaw)
	This function converts a rotation from Roll-Pitch-Yaw representation to Angle-Axis representation.
Quaternion	rollPitchYawToQuaternion (const Vector3D &rollPitchYaw)
	This function converts a rotation from Roll-Pitch-Yaw representation to Quaternion representation.
Transform3D	rollPitchYawToTransform3D (const Vector3D &rollPitchYaw)
	This function converts a rotation from Roll-Pitch-Yaw representation to Transform3D representation.
std::pair< double, Vector3D >	transform3DToAngleAxis (const Transform3D &transform3D)
	This function converts a rotation from Transform3D representation to Angle-Axis representation.
Quaternion	transform3DToQuaternion (const Transform3D &transform3D)
	This function converts a rotation from Transform3D representation to Quaternion representation.
Vector3D	transform3DToRollPitchYaw (const Transform3D &transform3D)
	This function converts a rotation from Transform3D representation to Roll-Pitch-Yaw representation.
template<class TYPE>
Array1D< TYPE >	getGaussian1D (size_t size, double sigma=0.0, bool normalize=false)
	This function returns an array in which the elements are sampled from a 1D Gaussian.
template<class Type>
SubArray1D< Type >	subArray (const Array1D< Type > &source)
	This is a convenience function for constructing SubArray1D instances which reference every element of the source array.
template<class Type>
SubArray1D< Type >	subArray (const Array1D< Type > &source, const Slice &rowSlice)
	This is a convenience function for constructing SubArray1D instances which reference only selected elements of the source array.
template<class Type>
std::ostream &	operator<< (std::ostream &stream, const SubArray1D< Type > &subArray0)
	This stream output operator sends a text representation of the SubArray1D instance to the supplied stream instance.
template<class Type>
SubArray2D< Type >	subArray (const Array2D< Type > &source)
	This is a convenience function for constructing SubArray2D instances which reference every element of the source array.
template<class Type>
SubArray2D< Type >	subArray (const Array2D< Type > &source, const Slice &rowSlice, const Slice &columnSlice)
	This is a convenience function for constructing SubArray2D instances which reference only selected elements of the source array.
template<class Type>
SubArray2D< Type >	subArray (const Array2D< Type > &source, const int row, const Slice &columnSlice)
	This function is just like subArray(const Array2D<Type>&, const Slice&, const Slice&), above except that it constructs a SubArray2D instance which references only selected elements _of a particular row_ in the source array.
template<class Type>
SubArray2D< Type >	subArray (const Array2D< Type > &source, const Slice &rowSlice, int column)
	This function is just like subArray(const Array2D<Type>&, const Slice&, const Slice&), above except that it constructs a SubArray2D instance which references only selected elements _of a particular column_ in the source array.
template<class Type>
std::ostream &	operator<< (std::ostream &stream, const SubArray2D< Type > &subArray0)
	This stream output operator sends a text representation of the SubArray2D instance to the supplied stream instance.
Transform2D	operator * (const Transform2D &transform0, const Transform2D &transform1)
	This operator composes two Transform2D instances.
std::ostream &	operator<< (std::ostream &stream, const Transform2D &transform0)
	Outputs a text representation of a Transform2D instance to a std::ostream.
std::istream &	operator>> (std::istream &stream, Transform2D &transform0)
	Sets the value of a Transform2D instance from a std::istream.
Transform3D	operator * (const Transform3D &transform0, const Transform3D &transform1)
	This operator composes two Transform3D instances.
std::ostream &	operator<< (std::ostream &stream, const Transform3D &transform0)
	Outputs a text representation of a Transform3D instance to a std::ostream.
std::istream &	operator>> (std::istream &stream, Transform3D &transform0)
	Sets the value of a Transform3D instance from a std::istream.
Transform3DTo2D	operator * (const Transform3DTo2D &transform0, const Transform3D &transform1)
	This operator composes a Transform3DTo2D instance with a Transform3D instance.
template<class Type>
Array1D< Type >	abs (const Array1D< Type > &array0)
template<class Type>
Array2D< Type >	abs (const Array2D< Type > &array0)
	This function returns an array of the same size and element type as its input argument, in which each element is set to the absolute value of the corresponding element of the input array.
template<class Type>
bool	allFalse (const Array1D< Type > &array0)
	This function returns true if each element of its argument is false, and returns false otherwise.
template<class Type>
bool	allTrue (const Array1D< Type > &array0)
	This function returns true if each element of its argument is true, and returns false otherwise.
template<class Type>
bool	anyFalse (const Array1D< Type > &array0)
	This function returns true if any element of its argument is true, and returns false otherwise.
template<class Type>
bool	anyTrue (const Array1D< Type > &array0)
	This function returns true if any element of its argument is true, and returns false otherwise.
template<class Type>
size_t	argmax (const Array1D< Type > &array0)
	This function returns the index of the largest element of its input array.
template<class Type, class Functor>
size_t	argmax (const Array1D< Type > &array0, Functor comparator)
	This function returns the index of the largest element of its input array, where largeness is defined by the second argument.
template<class Type>
size_t	argmin (const Array1D< Type > &array0)
	This function returns the index of the smallest element of its input array.
template<class Type, class Functor>
size_t	argmin (const Array1D< Type > &array0, Functor comparator)
	This function returns the index of the smallest element of its input array, where smallness is defined by the second argument.
template<class Type>
Array1D< size_t >	argsort (const Array1D< Type > &array0)
	This function returns an array of indices, result, so that the sequence (array0[result[0]], array0[result[1]], array0[result[2]], .
template<class Type>
Array1D< Type >	axisMax (const Array2D< Type > &array0, size_t axis)
	This function is just an alias for the function axisMaximum().
template<class Type>
Array1D< Type >	axisMaximum (const Array2D< Type > &array0, size_t axis)
	This function returns an Array1D in which each element has the value of the largest element in one row or column of the input Array2D.
template<class Type, class Functor>
Array1D< Type >	axisMaximum (const Array2D< Type > &array0, size_t axis, Functor comparator)
	This function returns an Array1D in which each element has the value of the largest element in one row or column of the input Array2D, where largeness is defined by the third argument.
template<class Type>
Array1D< Type >	axisMin (const Array2D< Type > &array0, size_t axis)
	This function is just an alias for the function axisMinimum().
template<class Type>
Array1D< Type >	axisMinimum (const Array2D< Type > &array0, size_t axis)
	This function returns an Array1D in which each element has the value of the smallest element in one row or column of the input Array2D.
template<class Type, class Functor>
Array1D< Type >	axisMinimum (const Array2D< Type > &array0, size_t axis, Functor comparator)
	This function returns an Array1D in which each element has the value of the smallest element in one row or column of the input Array2D, where smallness is defined by the return value of the third argument.
template<class Type>
Array1D< typename NumericTraits< Type >::SumType >	axisSum (const Array2D< Type > &array0, size_t axis)
	This function returns an Array1D in which each element has the sum of one row or column of the input Array2D.
template<class Type, class ResultType>
Array1D< ResultType >	axisSum (const Array2D< Type > &array0, size_t axis, type_tag< ResultType > resultTag)
	This function returns an Array1D in which each element has the sum of one row or column of the input Array2D.
template<class Type, class ResultType, class Functor>
Array1D< ResultType >	axisSum (const Array2D< Type > &array0, size_t axis, type_tag< ResultType > resultTag, const ResultType &initialValue, Functor adder)
	This function returns an Array1D in which each element has the sum of one row or column of the input Array2D.
template<class Type>
Array2D< Type >	columnIndices (size_t rows, size_t columns, type_tag< Type > typeTag)
	columnIndices(rows, columns): Returns an Array2D in which each element contains the index of its column.
template<class Type0, class Type1>
Array1D< Type1 >	compress (const Array1D< Type0 > &condition, const Array1D< Type1 > &input)
	This function selects those elements of an input Array1D which correspond to "true" values of a mask Array1D, and returns an Array1D containing only those elements.
template<class Type0, class Type1>
Array1D< Type1 >	compress (const Array1D< Type0 > &condition, const Array1D< Type1 > &input, size_t numTrue)
	This function behaves in exactly the same way as compress(const Array1D&, const Array1D&), above, but it permits the user to specify the number of true elements in the condition array.
template<class Type>
size_t	count (const Array1D< Type > &array0)
	This element counts the number of elements of the input array which evaluate to true, and returns that number.
Vector3D	cross (const Vector3D &vector0, const Vector3D &vector1)
	This function computes the cross product of two Vector3D instances.
template<class Type>
NumericTraits< Type >::ProductType	dot (const Array1D< Type > &array0, const Array1D< Type > &array1)
	This function computes the inner product of two input arrays.
template<class Type0, class Type1, class Type2>
Type2	dot (const Array1D< Type0 > &array0, const Array1D< Type1 > &array1, type_tag< Type2 > typeTag)
	This function computes the inner product of two input arrays, and allows the user to control which type is used to do the calculation.
double	dot (const Vector2D &vector0, const Vector2D &vector1)
	This function computes the inner product of two Vector2D instances.
double	dot (const Vector3D &vector0, const Vector3D &vector1)
	This function computes the inner product of two Vector3D instances.
template<class Type>
Array2D< Type >	equivalentMatrix (const Array1D< Type > &vector0, size_t rowsInMatrix)
	This function computes from a vector, x, the matrix, X, such that the matrix product A * x is equal to the matrix product X * vec(A).
template<class Type>
void	getMeanAndCovariance (const Array2D< Type > &sampleArray, Array1D< double > &mean, Array2D< double > &covariance, size_t majorAxis=0)
	This function estimates the mean and covariance of a set of vectors, which are represented by the rows (or columns) of the input 2D array.
template<class Type>
Array2D< Type >	identity (size_t rows, size_t columns, type_tag< Type > typeTag)
	This function returns an Array2D instance with the specified shape in which the elements on the diagonal are set to 1, and all other elements are set to 0.
template<class Type>
Array1D< Type >	ln (const Array1D< Type > &array0)
	This function returns an array in which each element is the natural logarithm of the corresponding element of its input.
template<class Type>
Array2D< Type >	ln (const Array2D< Type > &array0)
	This function returns an array in which each element is the natural logarithm of the corresponding element of its input.
template<class Type>
Array2D< Type >	logicalNot (const Array2D< Type > &array0)
	This function returns an Array2D instance in which the value of each element is the logical not of the corresponding element of the input array.
template<class Type>
Type	magnitude (const Array1D< Type > &array0)
	This function computes the magnitude of its input argument.
double	magnitude (const Vector2D &vector0)
	This function computes the magnitude of its input argument.
double	magnitude (const Vector3D &vector0)
	This function computes the magnitude of its input argument.
template<class Type>
NumericTraits< Type >::ProductType	magnitudeSquared (const Array1D< Type > &array0)
	This function computes the square of the magnitude of its input argument.
double	magnitudeSquared (const Vector2D &vector0)
	This function computes the square of the magnitude of its input argument.
double	magnitudeSquared (const Vector3D &vector0)
	This function computes the square of the magnitude of its input argument.
template<class Type>
Array1D< typename NumericTraits< Type >::ProductType >	matrixMultiply (const Array1D< Type > &vector0, const Array2D< Type > &matrix0)
	This function computes a vector * matrix product.
template<class Type0, class Type1, class Type2>
Array1D< Type2 >	matrixMultiply (const Array1D< Type0 > &vector0, const Array2D< Type0 > &matrix0, type_tag< Type2 > typeTag)
	This function computes a vector * matrix product just like matrixMultiply(const Array1D<Type>&, const Array2D<Type>&), above.
template<class Type>
Array1D< typename NumericTraits< Type >::ProductType >	matrixMultiply (const Array2D< Type > &matrix0, const Array1D< Type > &vector0)
	This function computes a matrix * vector product.
template<class Type0, class Type1, class Type2>
Array1D< Type2 >	matrixMultiply (const Array2D< Type0 > &matrix0, const Array1D< Type1 > &vector0, type_tag< Type2 > typeTag)
	This function computes a matrix * vector product just like matrixMultiply(const Array2D<Type>&, const Array1D<Type>&), above.
template<class Type>
Array2D< typename NumericTraits< Type >::ProductType >	matrixMultiply (const Array2D< Type > &matrix0, const Array2D< Type > &matrix1)
	This function computes a matrix * matrix product.
template<class Type0, class Type1, class Type2>
Array2D< Type2 >	matrixMultiply (const Array2D< Type0 > &matrix0, const Array2D< Type1 > &matrix1, type_tag< Type2 > typeTag)
	This function computes a matrix * matrix product, just like matrixMultiply(const Array2D<Type>&, const Array2D<Type>&), above.
template<class Type>
Type	maximum (const Array1D< Type > &array0)
	This function returns a copy of the largest element in the input Array1D instance.
template<class Type, class Functor>
Type	maximum (const Array1D< Type > &array0, Functor comparator)
	This function returns a copy of the largest element in the input Array1D instance, where largeness is defined by the return value of the second argument.
template<class Iterator, class Type>
Type	mean (const Iterator &beginIter, const Iterator &endIter)
	This function computes the average value, or geometric mean, of the elements of its argument.
template<class Type>
double	mean (const Array1D< Type > &array0)
	This function computes the average value, or geometric mean, of the elements of its argument.
template<class Type0, class Type1>
Type1	mean (const Array1D< Type0 > &array0, type_tag< Type1 > typeTag)
	This function computes the average value, or geometric mean, of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.
template<class Type>
Type	minimum (const Array1D< Type > &array0)
	This function returns a copy of the smallest element in the input Array1D instance.
template<class Type, class Functor>
Type	minimum (const Array1D< Type > &array0, Functor comparator)
	This function returns a copy of the smallest element in the input Array1D instance, where largeness is defined by the return value of the second argument.
template<class FUNCTOR>
double	newtonRaphson (double startPoint, FUNCTOR objectiveFunction, double epsilon, size_t maxIterations)
	This function uses the iterative method of Newton and Raphson to search for a zero crossing of the supplied functor.
template<class Type>
double	normalizedCorrelation (const Array1D< Type > &x, const Array1D< Type > &y)
	This function computes the normalized correlation of two Array1D arguments.
template<class Type, class Type2>
Type2	normalizedCorrelation (const Array1D< Type > &x, const Array1D< Type > &y, type_tag< Type2 > typeTag)
	This function is equivalent to normalizedCorrelation(const Array1D&, const Array1D&), except that the computation is carried out using the type specified by the third argument.
template<class Type>
Array1D< Type >	ones (int size, type_tag< Type > typeTag)
	This function returns an Array1D of the specified size and type in which the value of every element is initialized to 1.
template<class Type>
Array2D< Type >	ones (int rows, int columns, type_tag< Type > typeTag)
	This function returns an Array2D of the specified size and type in which the value of every element is initialized to one.
template<class Type>
Array2D< typename NumericTraits< Type >::ProductType >	outerProduct (const Array1D< Type > &array0, const Array1D< Type > &array1)
	This function computes the outer product of two input Array1D instances.
template<class Type0, class Type1, class Type2>
Array2D< Type2 >	outerProduct (const Array1D< Type0 > &array0, const Array1D< Type1 > &array1, type_tag< Type2 > typeTag)
	This function computes the outer product of two input Array1D instances and allows the user to control which type is used to do the calculation.
template<class Type>
Array1D< Type >	range (Type start, Type stop, Type stride=1)
	This function returns an Array1D in which the first element has value equal to argument "start," and each subsequent element has value equal to the previous element plus argument "stride." The length of the array is equal to largest integer less than the quantity ((stop - start) / stride).
template<class Type>
Array1D< Type >	ravel (Array2D< Type > &inputArray)
	This function takes an Array2D argument and returns an Array1D instance which references the same data.
template<class Type>
const Array1D< Type >	ravel (const Array2D< Type > &inputArray)
	This function takes a const Array2D argument and returns a const Array1D instance which references the same data.
template<class Type>
Type	rms (const Array1D< Type > &array0)
	This function computes the RMS (Root Mean Square) value of the elements of its argument.
template<class Type0, class Type1>
Type1	rms (const Array1D< Type0 > &array0, type_tag< Type1 > typeTag)
	This function computes the RMS (Root Mean Square) value of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.
template<class Type>
Array2D< Type >	rowIndices (size_t rows, size_t columns, type_tag< Type > typeTag)
	rowIndices(rows, columns): Returns an Array2D in which each element contains the index of its row.
template<class Type0, class Type1>
bool	shapeMatch (const Array1D< Type0 > &array0, const Array1D< Type1 > &array1)
	This function returns true if the two arrays have the same shape, false otherwise.
template<class Type0, class Type1>
bool	shapeMatch (const Array2D< Type0 > &array0, const Array2D< Type1 > &array1)
	This function returns true if the two arrays have the same shape, false otherwise.
template<class Type0, class Type1>
bool	shapeMatch (const Array3D< Type0 > &array0, const Array3D< Type1 > &array1)
	This function returns true if the two arrays have the same shape, false otherwise.
template<class Type>
Array2D< Type >	skewSymmetric (const Array1D< Type > &vector0)
	skewSymmetric(x): Returns a skew symmetric matrix X such that matrixMultiply(X, y) = cross(x, y)
template<class Type>
void	solveQuadratic (Type c0, Type c1, Type c2, Type &root0, Type &root1, bool &valid, bool checkValidity=true)
	This function computes the real roots of the quadratic polynomial c0*x^2 + c1*x + c0 = 0.
template<class Type>
double	standardDeviation (const Array1D< Type > &array0)
	This function computes the standard deviation of a group of scalar samples.
template<class Type0, class Type1>
Type1	standardDeviation (const Array1D< Type0 > &array0, type_tag< Type1 > typeTag)
	This function computes the standard deviation of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.
template<class Type>
NumericTraits< Type >::SumType	sum (const Array1D< Type > &array0)
	This function computes the sum of the elements of its argument.
template<class Type, class Type2>
Type2	sum (const Array1D< Type > &array0, type_tag< Type2 > typeTag)
	This function computes the sum of the elements of its argument.
template<class Type>
NumericTraits< Type >::SumType	sum (const Array2D< Type > &array0, const Index2D &upperLeftCorner, const Index2D &lowerRightCorner)
	This function computes the sum of those elements of its argument which lie within a rectangular region of interest.
template<class Type, class Type2>
Type2	sum (const Array2D< Type > &array0, const Index2D &upperLeftCorner, const Index2D &lowerRightCorner, type_tag< Type2 > typeTag)
	This function computes the sum of those elements of its argument which lie within a rectangular region of interest.
template<class Type>
double	variance (const Array1D< Type > &array0)
	This function computes the variance of a group of scalar samples.
template<class Type0, class Type1>
Type1	variance (const Array1D< Type0 > &array0, type_tag< Type1 > typeTag)
	This function computes the variance, of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.
template<class Type>
Array1D< Type >	zeros (size_t size, type_tag< Type > typeTag)
	This function returns an Array1D of the specified size and type in which the value of every element is zero.
template<class Type>
Array2D< Type >	zeros (size_t rows, size_t columns, type_tag< Type > typeTag)
	This function returns an Array2D of the specified size and type in which the value of every element is zero.
template<class Type>
Array3D< Type >	zeros (size_t shape0, size_t shape1, size_t shape2, type_tag< Type > typeTag)
	This function returns an Array3D of the specified size and type in which the value of every element is zero.
Vector2D	operator+ (const Vector2D &vector0, const Vector2D &vector1)
	This operator returns the elementwise sum of two Vector2D instances.
Vector2D	operator- (const Vector2D &vector0, const Vector2D &vector1)
	This operator returns the elementwise difference of two Vector2D instances.
Vector2D	operator * (const Vector2D &vector0, const Vector2D &vector1)
	This operator returns the elementwise product of two Vector2D instances.
Vector2D	operator/ (const Vector2D &vector0, const Vector2D &vector1)
	This operator returns the elementwise dividend of two Vector2D instances.
Vector2D	operator+ (const Vector2D &vector0, double scalar0)
	This operator adds a scalar and a Vector2D.
Vector2D	operator- (const Vector2D &vector0, double scalar0)
	This operator subtracts a scalar from a Vector2D.
Vector2D	operator * (const Vector2D &vector0, double scalar0)
	This operator multiplies a Vector2D by scalar.
Vector2D	operator/ (const Vector2D &vector0, double scalar0)
	This operator divides a Vector2D by scalar.
bool	operator== (const Vector2D &vector0, const Vector2D &vector1)
	This operator checks the supplied vectors for equality.
bool	operator!= (const Vector2D &vector0, const Vector2D &vector1)
	This operator checks the supplied vectors for inequality.
std::ostream &	operator<< (std::ostream &stream, const Vector2D &vector0)
	This function outputs a text representation of a Vector2D instance to a std::ostream.
std::istream &	operator>> (std::istream &stream, Vector2D &vector0)
	This function sets the value of a Vector2D instance from a std::istream.
Vector2D	operator+ (double scalar0, const Vector2D &vector0)
	This operator adds a scalar value to each element of a Vector2D instance.
Vector2D	operator * (double scalar0, const Vector2D &vector0)
	This operator multiplies a scalar value with each element of a Vector2D instance.
Vector3D	operator+ (const Vector3D &vector0, const Vector3D &vector1)
	This operator returns the elementwise sum of two Vector3D instances.
Vector3D	operator- (const Vector3D &vector0, const Vector3D &vector1)
	This operator returns the elementwise difference of two Vector3D instances.
Vector3D	operator * (const Vector3D &vector0, const Vector3D &vector1)
	This operator returns the elementwise product of two Vector3D instances.
Vector3D	operator/ (const Vector3D &vector0, const Vector3D &vector1)
	This operator returns the elementwise dividend of two Vector3D instances.
Vector3D	operator+ (const Vector3D &vector0, double scalar0)
	This operator adds a scalar and a Vector3D.
Vector3D	operator- (const Vector3D &vector0, double scalar0)
	This operator subtracts a scalar from a Vector3D.
Vector3D	operator * (const Vector3D &vector0, double scalar0)
	This operator multiplies a Vector3D by scalar.
Vector3D	operator/ (const Vector3D &vector0, double scalar0)
	This operator divides a Vector3D by scalar.
bool	operator== (const Vector3D &vector0, const Vector3D &vector1)
	This operator checks the supplied vectors for equality.
bool	operator!= (const Vector3D &vector0, const Vector3D &vector1)
	This operator checks the supplied vectors for inequality.
std::ostream &	operator<< (std::ostream &stream, const Vector3D &vector0)
	This function outputs a text representation of a Vector3D instance to a std::ostream.
std::istream &	operator>> (std::istream &stream, Vector3D &vector0)
	This function sets the value of a Vector3D instance from a std::istream.
Vector3D	operator+ (double scalar0, const Vector3D &vector0)
	This operator adds a scalar value to each element of a Vector3D instance.
Vector3D	operator * (double scalar0, const Vector3D &vector0)
	This operator multiplies a scalar value with each element of a Vector3D instance.

---

Detailed Description

This namespace contains code for 1D, 2D, and 3D arrays, matrices, coordinate transformations, rotation conversions, and much more.

---

Enumeration Type Documentation

enum dlr::numeric::ConvolutionROI

Enumerator:

DLR_CONVOLVE_ROI_SAME
DLR_CONVOLVE_ROI_VALID
DLR_CONVOLVE_ROI_FULL

Definition at line 37 of file convolutionStrategy.h.

enum dlr::numeric::ConvolutionStrategy

Enumerator:

DLR_CONVOLVE_TRUNCATE_RESULT
DLR_CONVOLVE_PAD_RESULT
DLR_CONVOLVE_ZERO_PAD_RESULT	Deprecated: {Please use DLR_CONVOLVE_PAD_RESULT instead.}
DLR_CONVOLVE_PAD_SIGNAL
DLR_CONVOLVE_ZERO_PAD_SIGNAL
DLR_CONVOLVE_REFLECT_SIGNAL
DLR_CONVOLVE_WRAP_SIGNAL

Definition at line 23 of file convolutionStrategy.h.

---

Function Documentation

template<class Type>

Array2D< Type > dlr::numeric::abs

(

const Array2D< Type > &

array0

)

[inline]

This function returns an array of the same size and element type as its input argument, in which each element is set to the absolute value of the corresponding element of the input array.

Parameters:

array0

The elements of the returned array will take on the absolute value of the elements of this array.

Returns:

The return value is an array in which each element contains the absolute value of the corresponding element in the input array.

Definition at line 2086 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::abs

(

const Array1D< Type > &

array0

)

[inline]

Parameters:

array0

The elements of the returned array will take on the absolute value of the elements of this array.

Returns:

The return value is an array in which each element contains the absolute value of the corresponding element in the input array.

Definition at line 2073 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

bool dlr::numeric::allFalse

(

const Array1D< Type > &

array0

)

[inline]

This function returns true if each element of its argument is false, and returns false otherwise.

Parameters:

array0

The elements of this array will be tested.

Returns:

The return value is true if all of the elements of array0 are false.

Definition at line 2099 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

Referenced by anyTrue().

template<class Type>

bool dlr::numeric::allTrue

(

const Array1D< Type > &

array0

)

[inline]

This function returns true if each element of its argument is true, and returns false otherwise.

Parameters:

array0

The elements of this array will be tested.

Returns:

The return value is true if all of the elements of array0 are true.

Definition at line 2116 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

Referenced by anyFalse().

Quaternion dlr::numeric::angleAxisToQuaternion	(	double	angle,
		const Vector3D &	axis,
		bool	isNormalized = false
	)

This function converts a rotation from angle-axis representation to unit quaternion representation.

Parameters:

	angle	This argument specifies the size of the rotation in radians. For further information, please see the rotations.h file comment.
	axis	This argument specifies the axis of rotation. For further information, please see the rotations.h file comment.
	isNormalized	If set to true, this argument disables normalization of the axis prior to use. You should only set it to true if you know that the magnitude of argument axis is equal to 1.0.

Returns:

The return value is a unit quaternion representing the specified rotation. For further information, please see the rotations.h file comment.

Definition at line 32 of file rotations.cpp.

References magnitude(), dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Referenced by angleAxisToRollPitchYaw(), and angleAxisToTransform3D().

Vector3D dlr::numeric::angleAxisToRollPitchYaw	(	double	angle,
		const Vector3D &	axis,
		bool	isNormalized = false
	)

This function converts a rotation from angle-axis representation to roll-pitch-yaw representation.

Parameters:

	angle	This argument specifies the size of the rotation in radians. For further information, please see the rotations.h file comment.
	axis	This argument specifies the axis of rotation. For further information, please see the rotations.h file comment.
	isNormalized	If set to true, this argument disables normalization of the axis prior to use. You should only set it to true if you know that the magnitude of argument axis is equal to 1.0.

Returns:

The return value is a Vector3D instance containing roll, pitch, and yaw. For further information, please see the rotations.h file comment.

Definition at line 60 of file rotations.cpp.

References angleAxisToQuaternion(), and quaternionToRollPitchYaw().

Transform3D dlr::numeric::angleAxisToTransform3D	(	double	angle,
		const Vector3D &	axis,
		bool	isNormalized = false
	)

This function converts a rotation from angle-axis representation to Transform3D representation.

Parameters:

	angle	This argument specifies the size of the rotation in radians. For further information, please see the rotations.h file comment.
	axis	This argument specifies the axis of rotation. For further information, please see the rotations.h file comment.
	isNormalized	If set to true, this argument disables normalization of the axis prior to use. You should only set it to true if you know that the magnitude of argument axis is equal to 1.0.

Returns:

The return value is a Transform3D instance representing the rotation. For further information, please see the rotations.h file comment.

Definition at line 69 of file rotations.cpp.

References angleAxisToQuaternion(), and quaternionToTransform3D().

template<class Type>

bool dlr::numeric::anyFalse

(

const Array1D< Type > &

array0

)

[inline]

This function returns true if any element of its argument is true, and returns false otherwise.

Parameters:

array0

The elements of this array will be tested.

Returns:

The return value is true if any of the elements of array0 are false.

Definition at line 2133 of file dlrNumeric/utilities.h.

References allTrue().

template<class Type>

bool dlr::numeric::anyTrue

(

const Array1D< Type > &

array0

)

[inline]

This function returns true if any element of its argument is true, and returns false otherwise.

Parameters:

array0

The elements of this array will be tested.

Returns:

The return value is true if any of the elements of array0 are true.

Definition at line 2143 of file dlrNumeric/utilities.h.

References allFalse().

template<class Type, class Functor>

size_t dlr::numeric::argmax	(	const Array1D< Type > &	array0,
		Functor	comparator
	)			[inline]

This function returns the index of the largest element of its input array, where largeness is defined by the second argument.

This function is equivalent to the quantity

(std::max_element(array0.begin(), array0.end(), comparator)

• array0.begin())

NOTE: Read the argument description for comparator carefully. It is consistent with the standard library convention, but many people find it to be counterintuitive.

Parameters:

	array0	The elements of this array will be evaluated, and the index of the largest will be returned.
	comparator	This argument is a functor which supports the std::binary_function<Type, Type, bool> interface, and returns true if its first argument is smaller than its second argument.

Returns:

The index of the largest element of the array.

Definition at line 2162 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

Referenced by dlr::computerVision::registerPoints3D().

template<class Type>

size_t dlr::numeric::argmax

(

const Array1D< Type > &

array0

)

[inline]

This function returns the index of the largest element of its input array.

This function is equivalent to the quantity (std::max_element(array0.begin(), array0.end()) - array0.begin())

Parameters:

array0

The elements of this array will be evaluated, and the index of the largest will be returned.

Returns:

The index of the largest element of the array.

Definition at line 2153 of file dlrNumeric/utilities.h.

template<class Type, class Functor>

size_t dlr::numeric::argmin	(	const Array1D< Type > &	array0,
		Functor	comparator
	)			[inline]

This function returns the index of the smallest element of its input array, where smallness is defined by the second argument.

This function is equivalent to the quantity

(std::min_element(array0.begin(), array0.end(), comparator)

• array0.begin())

Parameters:

	array0	The elements of this array will be evaluated, and the index of the smallest will be returned.
	comparator	This argument is a functor which supports the std::binary_function<Type, Type, bool> interface, and returns true if its first argument is smaller than its second argument.

Returns:

The index of the smallest element of the array.

Definition at line 2184 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

template<class Type>

size_t dlr::numeric::argmin

(

const Array1D< Type > &

array0

)

[inline]

This function returns the index of the smallest element of its input array.

This function is equivalent to (std::min_element(array0.begin(), array0.end()) - array0.begin());

Parameters:

array0

The elements of this array will be evaluated, and the index of the smallest will be returned.

Returns:

The index of the smallest element of the array.

Definition at line 2174 of file dlrNumeric/utilities.h.

template<class Type>

Array1D< size_t > dlr::numeric::argsort

(

const Array1D< Type > &

array0

)

[inline]

This function returns an array of indices, result, so that the sequence (array0[result[0]], array0[result[1]], array0[result[2]], .

..) is sorted from smallest to largest using operator<().

Parameters:

array0

The of this array will be compared to each other in order to establish the correct sequence of indices.

Returns:

An array of indices as described above.

Definition at line 2198 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::size().

Referenced by dlr::geometry::Plane3D::Plane3D().

template<class Type>

Array1D<Type> dlr::numeric::axisMax	(	const Array2D< Type > &	array0,
		size_t	axis
	)			[inline]

This function is just an alias for the function axisMaximum().

Parameters:

	array0	See documentation for axisMaximum().
	axis	See documentation for axisMaximum().

Returns:

See documentation for axisMaximum().

Definition at line 256 of file dlrNumeric/utilities.h.

References axisMaximum().

template<class Type, class Functor>

Array1D< Type > dlr::numeric::axisMaximum	(	const Array2D< Type > &	array0,
		size_t	axis,
		Functor	comparator
	)			[inline]

This function returns an Array1D in which each element has the value of the largest element in one row or column of the input Array2D, where largeness is defined by the third argument.

The maximum is taken along the axis specified by the second argument. For example:

Array2D<int> testArray("[[1, 3, 0], [5, 0, 2]]"); std::cout << axisMaximum(testArray, 0, std::less<int>()) << ", " << axisMaximum(testArray, 1, std::less<int>()) << ".";

will print "Array1D([5, 3, 2]), Array1D([3, 5])."

NOTE: Read the argument description for comparator carefully. It is consistent with the standard library convention, but many people find it to be counterintuitive.

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the maximum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.
	comparator	This argument is a functor which supports the std::binary_function<Type, Type, bool> interface, and returns true if its first argument is smaller than its second argument.

Returns:

The return value is an Array1D instance containing the maximum element from each row or column of the input array.

Definition at line 2250 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::data(), DLR_THROW3, dlr::numeric::Array1D< Type >::reinit(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::axisMaximum	(	const Array2D< Type > &	array0,
		size_t	axis
	)			[inline]

This function returns an Array1D in which each element has the value of the largest element in one row or column of the input Array2D.

The maximum is taken along the axis specified by the second argument. For more information see the documentation of axisMaximum(const Array2D&, size_t, Functor).

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the maximum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.

Returns:

The return value is an Array1D instance containing the maximum element from each row or column of the input array.

Definition at line 2239 of file dlrNumeric/utilities.h.

Referenced by axisMax().

template<class Type>

Array1D<Type> dlr::numeric::axisMin	(	const Array2D< Type > &	array0,
		size_t	axis
	)			[inline]

This function is just an alias for the function axisMinimum().

Parameters:

	array0	See documentation for axisMinimum().
	axis	See documentation for axisMinimum().

Returns:

See documentation for axisMinimum().

Definition at line 324 of file dlrNumeric/utilities.h.

References axisMinimum().

template<class Type, class Functor>

Array1D< Type > dlr::numeric::axisMinimum	(	const Array2D< Type > &	array0,
		size_t	axis,
		Functor	comparator
	)			[inline]

This function returns an Array1D in which each element has the value of the smallest element in one row or column of the input Array2D, where smallness is defined by the return value of the third argument.

The minimum is taken along the axis specified by the second argument. For example:

Array2D<int> testArray("[[1, 3, 0], [5, 0, 2]]"); std::cout << axisMinimum(testArray, 0, std::less<int>()) << ", " << axisMinimum(testArray, 1, std::less<int>()) << ".";

will print "Array1D([1, 0, 0]), Array1D([0, 0])."

NOTE: Read the argument description for comparator carefully. It is consistent with the standard library convention, but many people find it to be counterintuitive.

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the minimum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.
	comparator	This argument is a functor which supports the std::binary_function<Type, Type, bool> interface, and returns true if its first argument is smaller than its second argument.

Returns:

The return value is an Array1D instance containing the minimum element from each row or column of the input array.

Definition at line 2310 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::data(), DLR_THROW3, dlr::numeric::Array1D< Type >::reinit(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::axisMinimum	(	const Array2D< Type > &	array0,
		size_t	axis
	)			[inline]

This function returns an Array1D in which each element has the value of the smallest element in one row or column of the input Array2D.

The minimum is taken along the axis specified by the second argument. For more information see the documentation of axisMinimum(const Array2D&, size_t, Functor).

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the minimum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.

Returns:

The return value is an Array1D instance containing the minimum element from each row or column of the input array.

Definition at line 2299 of file dlrNumeric/utilities.h.

Referenced by axisMin().

template<class Type, class ResultType, class Functor>

Array1D< ResultType > dlr::numeric::axisSum	(	const Array2D< Type > &	array0,
		size_t	axis,
		type_tag< ResultType >	resultTag,
		const ResultType &	initialValue,
		Functor	adder
	)			[inline]

This function returns an Array1D in which each element has the sum of one row or column of the input Array2D.

The sum is taken along the axis specified by the second argument, as described for axisSum(const Array2D&, size_t), above, and addition is performed using a user supplied binary operator. For each row or column, the sum is initialized to the value specified by initialValue before the summation is performed. After this initialization, each row- or column- sum is updated according to the equation:

sum = adder(sum, nextElement)

for each element of the row or column. For more information, see the documentation of other axisSum() versions.

This version of axisSum also permits the user to control the precision of the summation by specifying the type which will be used to do the computation.

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the sum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.
	resultTag	This argument is a type_tag indicating which type is to be used to perform the computation.
	initialValue	This argument specifies the value to which each row/column sum will be initialized prior to accumulating the elements of the array.
	adder	This argument is a functor conforming to the std::binary_function interface which will be used to add element values.

Returns:

The return value is an Array1D instance containing the sums of the rows or columns of the input array.

Definition at line 2378 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::data(), DLR_THROW3, dlr::numeric::Array1D< Type >::reinit(), and dlr::numeric::Array2D< Type >::rows().

template<class Type, class ResultType>

Array1D< ResultType > dlr::numeric::axisSum	(	const Array2D< Type > &	array0,
		size_t	axis,
		type_tag< ResultType >	resultTag
	)			[inline]

This function returns an Array1D in which each element has the sum of one row or column of the input Array2D.

The sum is taken along the axis specified by the second argument, as described for axisSum(const Array2D&, size_t), above.

This version of axisSum permits the user to control the precision of the summation by specifying the type which will be used to do the computation.

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the sum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.
	resultTag	This argument is a type_tag indicating which type is to be used to perform the computation.

Returns:

The return value is an Array1D instance containing the sums of the rows or columns of the input array.

Definition at line 2368 of file dlrNumeric/utilities.h.

References axisSum().

template<class Type>

Array1D< typename NumericTraits< Type >::SumType > dlr::numeric::axisSum	(	const Array2D< Type > &	array0,
		size_t	axis
	)			[inline]

This function returns an Array1D in which each element has the sum of one row or column of the input Array2D.

The sum is taken along the axis specified by the second argument. For Example:

Array2D<int> testArray("[[1, 3, 0], [5, 0, 2]]"); std::cout << axisSum(testArray, 0) << ", " << axisSum(testArray, 1) << ".";

will print "Array1D([6, 3, 2]), Array1D([4, 7])."

The summation is done using values of type NumericTraits<Type>::SumType, where Type is the type of the elements in the input array.

Parameters:

	array0	This is the input Array2D instance.
	axis	This argument indicates along which axis the sum should be computed. Axis 0 is aligned with the columns of the array, while axis 1 is aligned with the rows of the array.

Returns:

The return value is an Array1D instance containing the sums of the rows or columns of the input array.

Definition at line 2358 of file dlrNumeric/utilities.h.

Referenced by axisSum().

bool dlr::numeric::bilaterate	(	const Vector2D &	point0,
		const Vector2D &	point1,
		double	range0,
		double	range1,
		Vector2D &	intersection0,
		Vector2D &	intersection1
	)

This function finds a 2D point, given two other points and distance between each of those points and the point to be recovered.

That is, it answers the question "what point is at range0 from point0 and also at range1 from point1?" Note that there may be two points which satisfy this constraint, or there may be none if the sum of range0 and range1 is less than the distance between point0 and point1.

Parameters:

	point0	This argument specifies the first known point.
	point1	This argument specifies the second known point.
	range0	This argument specifies the distance from point0 to the target point.
	range1	This argument specifies the distance from point1 to the target point.
	intersection0	This argument returns the first of the two points which is at range0 from point0 and at range1 from point1. If no solution is found, then this argument will not be touched.
	intersection1	This argument returns the second of the two points which is at range0 from point0 and at range1 from point1. In degenerate cases, intersection1 will be identical to intersection0. If no solution is found, then this argument will not be touched.

Returns:

The return value is true if a solution was found, false otherwise.

Definition at line 23 of file geometry2D.cpp.

References magnitude(), sqrt(), dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

template<class Type>

Array2D< Type > dlr::numeric::columnIndices	(	size_t	rows,
		size_t	columns,
		type_tag< Type >	typeTag
	)			[inline]

columnIndices(rows, columns): Returns an Array2D in which each element contains the index of its column.

The element type of the returned array depends on the type_tag argument. For example:

columnIndices(2, 3, type_tag<int>());

will return:

Array2D<int>([[0, 1, 2], [0, 1, 2]]);

Parameters:

	rows	This argument specifies the number of rows in the returned array.
	columns	This argument specifies the number of columns in the returned array.
	typeTag	This argument specifies the element type of the returned array.

Returns:

The return value is an Array2D of the specified size and type in which all elements in the first column have value initialized to 0, all elements in the second column have value initialized to 1, and so on.

Definition at line 2422 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array2D< Type >::data(), dlr::numeric::Array1D< Type >::end(), and range().

template<class Type0, class Type1>

Array1D< Type1 > dlr::numeric::compress	(	const Array1D< Type0 > &	condition,
		const Array1D< Type1 > &	input,
		size_t	numTrue
	)			[inline]

This function behaves in exactly the same way as compress(const Array1D&, const Array1D&), above, but it permits the user to specify the number of true elements in the condition array.

This eliminates one pass through the condition array, slightly speeding up the computation. Use this version with caution, since specifying an incorrect count can crash your program.

Parameters:

	condition	This argument is the mask which selects which elements will be included in the output array. Elements of argument this array which evaluate to true will cause the corresponding elements of the input array to be included in the output.
	input	Elements of this argument will be included in the output array if the corresponding elements of the condition array evaluate to true. This array must have the same number of elements as the condition array.
	numTrue	This argument specifies the number of "true" elements in the condition array.

Returns:

The return value is an Array1D instance containing only those elements of the input array which correspond to true elements of the condition array.

Definition at line 2451 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW3, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type0, class Type1>

Array1D< Type1 > dlr::numeric::compress	(	const Array1D< Type0 > &	condition,
		const Array1D< Type1 > &	input
	)			[inline]

This function selects those elements of an input Array1D which correspond to "true" values of a mask Array1D, and returns an Array1D containing only those elements.

For example:

Array1D<int> a = compress( Array1D<bool>("1, 1, 0, 1, 0]"), Array1D<int>("1, 2, 3, 4, 5")); std::cout << a;

will print:

"Array1D([1, 2, 4])"

It is an error for the two array arguments to have different sizes.

Parameters:

	condition	This argument is the mask which selects which elements will be included in the output array. Elements of argument this array which evaluate to true will cause the corresponding elements of the input array to be included in the output.
	input	Elements of this argument will be included in the output array if the corresponding elements of the condition array evaluate to true. This array must have the same number of elements as the condition array.

Returns:

The return value is an Array1D instance containing only those elements of the input array which correspond to true elements of the condition array.

Definition at line 2439 of file dlrNumeric/utilities.h.

References count().

Quaternion dlr::numeric::conjugate

(

const Quaternion &

source

)

[inline]

This function returns the conjugate of a Quaternion, in which the sign of each imaginary component has been reversed.

Note that for quaternions which represent rotation, the rotation represented by the conjugate is also the inverse rotation. That is, if you rotate by a quaternion, q, and then rotate by conjugate(q), you wind up exactly where you started.

Parameters:

source

This argument specifies the Quaternion whose conjugate is to be computed.

Returns:

The return value is a Quaternion which is conjugate to the argument.

Definition at line 204 of file quaternion.h.

References dlr::numeric::Quaternion::i(), dlr::numeric::Quaternion::j(), dlr::numeric::Quaternion::k(), and dlr::numeric::Quaternion::s().

template<class Type0, class Type1>

Array1D< Type1 > dlr::numeric::convolve	(	const Array1D< Type0 > &	kernel,
		const Array1D< Type0 > &	signal,
		type_tag< Type1 >	resultTag,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_ZERO_PAD_RESULT
	)			[inline]

Deprecated:

{Please use convolve1D() from dlrNumeric/convolve1D.h instead.}

Definition at line 160 of file convolve.h.

References dlr::numeric::Array1D< Type >::begin(), correlate(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::convolve	(	const Array1D< Type > &	kernel,
		const Array1D< Type > &	signal,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_ZERO_PAD_RESULT
	)			[inline]

Deprecated:

{Please use convolve1D() from dlrNumeric/convolve1D.h instead.}

Definition at line 150 of file convolve.h.

template<class OutputType, class KernelType, class SignalType, class FillType>

Array1D< OutputType > dlr::numeric::convolve1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		int	boundary0,
		int	boundary1,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 630 of file convolve1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class KernelType, class SignalType>

Array1D< OutputType > dlr::numeric::convolve1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		int	boundary0,
		int	boundary1
	)			[inline]

Unstable: interface subject to change.

Definition at line 614 of file convolve1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class KernelType, class SignalType, class FillType>

Array1D< OutputType > dlr::numeric::convolve1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		ConvolutionROI	roi,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 599 of file convolve1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class KernelType, class SignalType>

Array1D< OutputType > dlr::numeric::convolve1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_ZERO_PAD_RESULT,
		ConvolutionROI	roi = DLR_CONVOLVE_ROI_SAME
	)			[inline]

Definition at line 584 of file convolve1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>

Array2D< OutputType > dlr::numeric::convolve2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		const Index2D &	corner0,
		const Index2D &	corner1,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 1544 of file convolve2D.h.

template<class OutputType, class AccumulatorType, class KernelType, class SignalType>

Array2D< OutputType > dlr::numeric::convolve2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		const Index2D &	corner0,
		const Index2D &	corner1
	)			[inline]

Unstable: interface subject to change.

Definition at line 1529 of file convolve2D.h.

template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>

Array2D< OutputType > dlr::numeric::convolve2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		ConvolutionROI	roi,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 1514 of file convolve2D.h.

template<class OutputType, class AccumulatorType, class KernelType, class SignalType>

Array2D< OutputType > dlr::numeric::convolve2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_PAD_RESULT,
		ConvolutionROI	roi = DLR_CONVOLVE_ROI_SAME
	)			[inline]

Definition at line 1500 of file convolve2D.h.

template<class Type0, class Type1>

Array1D< Type1 > dlr::numeric::correlate	(	const Array1D< Type0 > &	kernel,
		const Array1D< Type0 > &	signal,
		type_tag< Type1 >	resultTag,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_ZERO_PAD_RESULT
	)			[inline]

Deprecated:

{Please use correlate1D() from dlrNumeric/convolve1D.h instead.}

Definition at line 184 of file convolve.h.

References DLR_CONVOLVE_PAD_RESULT, DLR_CONVOLVE_REFLECT_SIGNAL, DLR_CONVOLVE_ROI_FULL, DLR_CONVOLVE_ROI_SAME, DLR_CONVOLVE_ROI_VALID, DLR_CONVOLVE_TRUNCATE_RESULT, DLR_CONVOLVE_WRAP_SIGNAL, DLR_CONVOLVE_ZERO_PAD_RESULT, DLR_CONVOLVE_ZERO_PAD_SIGNAL, and DLR_THROW.

template<class Type>

Array1D< Type > dlr::numeric::correlate	(	const Array1D< Type > &	kernel,
		const Array1D< Type > &	signal,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_ZERO_PAD_RESULT
	)			[inline]

Deprecated:

{Please use correlate1D() from dlrNumeric/convolve1D.h instead.}

Definition at line 174 of file convolve.h.

Referenced by convolve().

template<class OutputType, class KernelType, class SignalType, class FillType>

Array1D< OutputType > dlr::numeric::correlate1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		int	boundary0,
		int	boundary1,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 785 of file convolve1D.h.

References DLR_CONVOLVE_PAD_RESULT, DLR_CONVOLVE_PAD_SIGNAL, DLR_CONVOLVE_REFLECT_SIGNAL, DLR_CONVOLVE_TRUNCATE_RESULT, DLR_CONVOLVE_WRAP_SIGNAL, DLR_CONVOLVE_ZERO_PAD_RESULT, DLR_CONVOLVE_ZERO_PAD_SIGNAL, DLR_THROW, and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class KernelType, class SignalType>

Array1D< OutputType > dlr::numeric::correlate1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		int	boundary0,
		int	boundary1
	)			[inline]

Unstable: interface subject to change.

Definition at line 730 of file convolve1D.h.

References DLR_CONVOLVE_PAD_RESULT, DLR_CONVOLVE_PAD_SIGNAL, DLR_CONVOLVE_REFLECT_SIGNAL, DLR_CONVOLVE_TRUNCATE_RESULT, DLR_CONVOLVE_WRAP_SIGNAL, DLR_CONVOLVE_ZERO_PAD_RESULT, DLR_CONVOLVE_ZERO_PAD_SIGNAL, DLR_THROW, and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class KernelType, class SignalType, class FillType>

Array1D< OutputType > dlr::numeric::correlate1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		ConvolutionROI	roi,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 688 of file convolve1D.h.

References DLR_CONVOLVE_ROI_FULL, DLR_CONVOLVE_ROI_SAME, DLR_CONVOLVE_ROI_VALID, DLR_THROW, and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class KernelType, class SignalType>

Array1D< OutputType > dlr::numeric::correlate1D	(	const Array1D< KernelType > &	kernel,
		const Array1D< SignalType > &	signal,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_ZERO_PAD_RESULT,
		ConvolutionROI	roi = DLR_CONVOLVE_ROI_SAME
	)			[inline]

Unstable: interface subject to change.

Definition at line 646 of file convolve1D.h.

References DLR_CONVOLVE_ROI_FULL, DLR_CONVOLVE_ROI_SAME, DLR_CONVOLVE_ROI_VALID, DLR_THROW, and dlr::numeric::Array1D< Type >::size().

template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>

Array2D< OutputType > dlr::numeric::correlate2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		const Index2D &	corner0,
		const Index2D &	corner1,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 1715 of file convolve2D.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_CONVOLVE_PAD_RESULT, DLR_CONVOLVE_PAD_SIGNAL, DLR_CONVOLVE_REFLECT_SIGNAL, DLR_CONVOLVE_TRUNCATE_RESULT, DLR_CONVOLVE_WRAP_SIGNAL, DLR_CONVOLVE_ZERO_PAD_RESULT, DLR_CONVOLVE_ZERO_PAD_SIGNAL, DLR_THROW, and dlr::numeric::Array2D< Type >::rows().

template<class OutputType, class AccumulatorType, class KernelType, class SignalType>

Array2D< OutputType > dlr::numeric::correlate2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		const Index2D &	corner0,
		const Index2D &	corner1
	)			[inline]

Unstable: interface subject to change.

Definition at line 1651 of file convolve2D.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_CONVOLVE_PAD_RESULT, DLR_CONVOLVE_PAD_SIGNAL, DLR_CONVOLVE_REFLECT_SIGNAL, DLR_CONVOLVE_TRUNCATE_RESULT, DLR_CONVOLVE_WRAP_SIGNAL, DLR_CONVOLVE_ZERO_PAD_RESULT, DLR_CONVOLVE_ZERO_PAD_SIGNAL, DLR_THROW, and dlr::numeric::Array2D< Type >::rows().

template<class OutputType, class AccumulatorType, class KernelType, class SignalType, class FillType>

Array2D< OutputType > dlr::numeric::correlate2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy,
		ConvolutionROI	roi,
		const FillType &	fillValue
	)			[inline]

Unstable: interface subject to change.

Definition at line 1605 of file convolve2D.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_CONVOLVE_ROI_FULL, DLR_CONVOLVE_ROI_SAME, DLR_CONVOLVE_ROI_VALID, DLR_THROW, dlr::numeric::Index2D::getColumn(), dlr::numeric::Index2D::getRow(), and dlr::numeric::Array2D< Type >::rows().

template<class OutputType, class AccumulatorType, class KernelType, class SignalType>

Array2D< OutputType > dlr::numeric::correlate2D	(	const Array2D< KernelType > &	kernel,
		const Array2D< SignalType > &	signal,
		ConvolutionStrategy	strategy = DLR_CONVOLVE_PAD_RESULT,
		ConvolutionROI	roi = DLR_CONVOLVE_ROI_SAME
	)			[inline]

Unstable: interface subject to change.

Definition at line 1560 of file convolve2D.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_CONVOLVE_ROI_FULL, DLR_CONVOLVE_ROI_SAME, DLR_CONVOLVE_ROI_VALID, DLR_THROW, dlr::numeric::Index2D::getColumn(), dlr::numeric::Index2D::getRow(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

size_t dlr::numeric::count

(

const Array1D< Type > &

array0

)

[inline]

This element counts the number of elements of the input array which evaluate to true, and returns that number.

Parameters:

array0

This argument is the array of elements to be counted.

Returns:

The return value is the total number of elements in x which, when cast to bool, evaluate to true.

Definition at line 2502 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

Referenced by compress(), mean(), newtonRaphson(), dlr::computerVision::registerPoints3D(), and dlr::utilities::toPythonList().

Vector3D dlr::numeric::cross	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)			[inline]

This function computes the cross product of two Vector3D instances.

That is, it computes a Vector3D which lies perpendicular to each of the arguments and has magnitude equal to the product of the magnitudes of the arguments times the sine of the angle between them.

Parameters:

	vector0	This is the first argument of the cross product.
	vector1	This is the first argument of the cross product.

Returns:

The cross product of the two arguments.

Definition at line 2510 of file dlrNumeric/utilities.h.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Referenced by dlr::geometry::Plane3D::getNormal().

double dlr::numeric::dot	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)			[inline]

This function computes the inner product of two Vector3D instances.

Parameters:

	vector0	A Vector3D, the first argument of the dot product.
	vector1	A Vector3D, the second argument of the dot product.

Returns:

The inner product of the two Vector3D arguments.

Definition at line 2553 of file dlrNumeric/utilities.h.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Referenced by dlr::geometry::Plane3D::findDistance(), dlr::linearAlgebra::linearFit(), dlr::GaussianDistribution< VectorType >::operator()(), and dlr::geometry::Plane3D::Plane3D().

double dlr::numeric::dot	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)			[inline]

This function computes the inner product of two Vector2D instances.

Parameters:

	vector0	A Vector2D, the first argument of the dot product.
	vector1	A Vector2D, the second argument of the dot product.

Returns:

The inner product of the two Vector2D arguments.

Definition at line 2546 of file dlrNumeric/utilities.h.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

template<class Type0, class Type1, class Type2>

Type2 dlr::numeric::dot	(	const Array1D< Type0 > &	array0,
		const Array1D< Type1 > &	array1,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes the inner product of two input arrays, and allows the user to control which type is used to do the calculation.

Parameters:

	array0	A 1D array, the first argument of the dot product.
	array1	A 1D array, the second argument of the dot product.
	typeTag	The third argument is a type tag indicating which type is to be used to perform the computation.

Returns:

The inner product of the two array arguments.

Definition at line 2531 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW3, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

NumericTraits< Type >::ProductType dlr::numeric::dot	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

This function computes the inner product of two input arrays.

The computation is done using the ProductType specified by the appropriate NumericTraits class.

Parameters:

	array0	A 1D array, the first argument of the dot product.
	array1	A 1D array, the second argument of the dot product.

Returns:

The inner product of the two arguments.

Definition at line 2521 of file dlrNumeric/utilities.h.

Referenced by matrixMultiply(), dlr::numeric::BSpline< Type >::operator()(), and transform3DToQuaternion().

template<class Type>

Array2D< Type > dlr::numeric::equivalentMatrix	(	const Array1D< Type > &	vector0,
		size_t	rowsInMatrix
	)			[inline]

This function computes from a vector, x, the matrix, X, such that the matrix product A * x is equal to the matrix product X * vec(A).

That is, if

X = equivalentMatrix(x, n);

then

A * x == X * vec(A)

where x is a vector of m elements, and A is a matrix with n rows and m columns.

Parameters:

	vector0	This argument represents the vector x.
	rowsInMatrix	This argument describes the matrix A.

Returns:

The return value is an Array2D instance describing the matrix X.

Definition at line 2562 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::length(), dlr::numeric::Array1D< Type >::size(), and zeros().

template<class TYPE>

Array1D< TYPE > dlr::numeric::getGaussian1D	(	size_t	size,
		double	sigma = 0.0,
		bool	normalize = false
	)			[inline]

This function returns an array in which the elements are sampled from a 1D Gaussian.

The maximum of the Gaussian is at the center of the returned array, and the distance between adjacent samples (elements of the array) is assumed to be exactly 1.0.

Parameters:

	size	This argument specifies how many elements should be in the returned array.
	sigma	This argument specifies the desired standard deviation of the Gaussian.
	normalize	This argument specifies whether, after the elements of the array have been computed, the array should be rescaled so that its elements sum to 1.0.

Returns:

The return value is an array containing the sampled values.

Definition at line 70 of file sampledFunctions.h.

References sum().

template<class Type>

void dlr::numeric::getMeanAndCovariance	(	const Array2D< Type > &	sampleArray,
		Array1D< double > &	mean,
		Array2D< double > &	covariance,
		size_t	majorAxis = 0
	)			[inline]

This function estimates the mean and covariance of a set of vectors, which are represented by the rows (or columns) of the input 2D array.

Estimated mean and covariance are returned via reference arguments.

Parameters:

	sampleArray	This argument is the array of sample vectors. If argument majorAxis is set to 0, then each row of sampleArray represents a sample. If argument majorAxis is nonzero, then each column of sampleArray represents a sample.
	mean	The estimated mean vector is returned by reference using this argument.
	covariance	The estimated covariance matrix is returned by reference using this argument.
	majorAxis	This argument is normally set to 0 or 1, and specifies the arrangement of samples in sampleArray as described above. If majorAxis is set to a value which is not equal to 0 or 1, computation will proceed as if it had been set to 1.

Definition at line 2910 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::reinit(), dlr::numeric::Array1D< Type >::reinit(), dlr::numeric::Array2D< Type >::rows(), and dlr::numeric::Array2D< Type >::size().

template<class Type>

Array2D< Type > dlr::numeric::identity	(	size_t	rows,
		size_t	columns,
		type_tag< Type >	typeTag
	)			[inline]

This function returns an Array2D instance with the specified shape in which the elements on the diagonal are set to 1, and all other elements are set to 0.

Parameters:

	rows	This argument specifies the number of rows in the returned Array2D instance.
	columns	This argument specifies the number of columns in the returned Array2D instance.
	typeTag	This argument controls the element type of the returned Array2D instance.

Returns:

An Array2D in each element on the diagonal is set to 1, and all other elements are set to 0.

Definition at line 2579 of file dlrNumeric/utilities.h.

References zeros().

Referenced by dlr::linearAlgebra::inverse().

template<class Type>

Array2D< Type > dlr::numeric::ln

(

const Array2D< Type > &

array0

)

[inline]

This function returns an array in which each element is the natural logarithm of the corresponding element of its input.

Parameters:

array0

This argument is an Array2D with arguments in a common floating point type such as double or float.

Returns:

The return value is an array of natural log values.

Definition at line 2635 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::ln

(

const Array1D< Type > &

array0

)

[inline]

This function returns an array in which each element is the natural logarithm of the corresponding element of its input.

Parameters:

array0

This argument is an Array1D with arguments in a common floating point type such as double or float.

Returns:

The return value is an array of natural log values.

Definition at line 2594 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::size().

template<class Type>

Array2D< Type > dlr::numeric::logicalNot

(

const Array2D< Type > &

array0

)

[inline]

This function returns an Array2D instance in which the value of each element is the logical not of the corresponding element of the input array.

For example:

Array2D<int> a = logical_not(Array2D<int>("[[1, 2], [0, -5]]"); std::cout << a;

will print:

"Array2D([[0, 0], [1, 0]])"

Parameters:

array0

This argument is an Array2D with elements of a type which can be cast to bool.

Returns:

The return value is an Array2D instance of the same shape and element type as the input array, in which each element is set to the logical not of the corresponding element of the input array.

Definition at line 2651 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), dlr::numeric::Array2D< Type >::rows(), and dlr::common::unaryComposeFunctor().

double dlr::numeric::magnitude

(

const Vector3D &

vector0

)

[inline]

This function computes the magnitude of its input argument.

That is, it computes the square root of the sum of the squares of the elements of its input argument.

Parameters:

vector0

A Vector3D whose magnitude is to be calculated.

Returns:

The magnitude of the input argument.

Definition at line 2679 of file dlrNumeric/utilities.h.

References magnitudeSquared(), and sqrt().

Referenced by dlr::geometry::Plane3D::findDistance(), dlr::geometry::Plane3D::Plane3D(), and dlr::geometry::Ray3D::Ray3D().

double dlr::numeric::magnitude

(

const Vector2D &

vector0

)

[inline]

This function computes the magnitude of its input argument.

That is, it computes the square root of the sum of the squares of the elements of its input argument.

Parameters:

vector0

A Vector2D whose magnitude is to be calculated.

Returns:

The magnitude of the input argument.

Definition at line 2672 of file dlrNumeric/utilities.h.

References magnitudeSquared(), and sqrt().

template<class Type>

Type dlr::numeric::magnitude

(

const Array1D< Type > &

array0

)

[inline]

This function computes the magnitude of its input argument.

That is, it computes the square root of the sum of the squares of the elements of its input argument.

Parameters:

array0

An Array1D whose magnitude is to be calculated.

Returns:

The magnitude of the input argument.

Definition at line 2664 of file dlrNumeric/utilities.h.

References magnitudeSquared(), and sqrt().

Referenced by angleAxisToQuaternion(), bilaterate(), and quaternionToAngleAxis().

double dlr::numeric::magnitudeSquared

(

const Vector3D &

vector0

)

[inline]

This function computes the square of the magnitude of its input argument.

That is, it computes the sum of the squares of the elements of its input argument.

Parameters:

vector0

A Vector3D whose squared magnitude is to be calculated.

Returns:

The squared magnitude of the input argument.

Definition at line 2707 of file dlrNumeric/utilities.h.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Referenced by dlr::computerVision::registerPoints3D().

double dlr::numeric::magnitudeSquared

(

const Vector2D &

vector0

)

[inline]

This function computes the square of the magnitude of its input argument.

That is, it computes the sum of the squares of the elements of its input argument.

Parameters:

vector0

A Vector2D whose squared magnitude is to be calculated.

Returns:

The squared magnitude of the input argument.

Definition at line 2699 of file dlrNumeric/utilities.h.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

template<class Type>

NumericTraits< Type >::ProductType dlr::numeric::magnitudeSquared

(

const Array1D< Type > &

array0

)

[inline]

This function computes the square of the magnitude of its input argument.

That is, it computes the sum of the squares of the elements of its input argument.

Parameters:

array0

An Array1D whose squared magnitude is to be calculated.

Returns:

The squared magnitude of the input argument.

Definition at line 2688 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

Referenced by magnitude().

template<class Type0, class Type1, class Type2>

Array2D< Type2 > dlr::numeric::matrixMultiply	(	const Array2D< Type0 > &	matrix0,
		const Array2D< Type1 > &	matrix1,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes a matrix * matrix product, just like matrixMultiply(const Array2D<Type>&, const Array2D<Type>&), above.

This function differs in that the element type of the return value is set explicitly using a third argument.

Parameters:

	matrix0	The first operand for the multiplication.
	matrix1	The second operand for the multiplication.
	typeTag	The third argument is a type tag indicating which type is to be used to perform the computation.

Returns:

A 2D array which is the matrix product of matrix0 and matrix1. The element type of this array is set by the type_tag argument.

Definition at line 2809 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dlr::numeric::Array2D< Type >::rows(), and zeros().

Referenced by dlr::optimization::OptimizerBFGS< Functor >::doBfgs(), dlr::linearAlgebra::linearFit(), dlr::GaussianDistribution< VectorType >::operator()(), dlr::linearAlgebra::pseudoinverse(), and dlr::computerVision::registerPoints3D().

template<class Type>

Array2D< typename NumericTraits< Type >::ProductType > dlr::numeric::matrixMultiply	(	const Array2D< Type > &	matrix0,
		const Array2D< Type > &	matrix1
	)			[inline]

This function computes a matrix * matrix product.

That is, the elements of the resulting array are the dot products of the rows of the first argument with the columns of the second argument.

Parameters:

	matrix0	The first operand for the multiplication.
	matrix1	The second operand for the multiplication.

Returns:

A 2D array which is the matrix product of matrix0 and matrix1. The element type of this array is determined by NumericTraits<Type>::ProductType for the element type of the arguments.

Definition at line 2797 of file dlrNumeric/utilities.h.

References matrixMultiply().

template<class Type0, class Type1, class Type2>

Array1D< Type2 > dlr::numeric::matrixMultiply	(	const Array2D< Type0 > &	matrix0,
		const Array1D< Type1 > &	vector0,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes a matrix * vector product just like matrixMultiply(const Array2D<Type>&, const Array1D<Type>&), above.

This function differs in that the element type of the return value is set explicitly using a third argument.

Parameters:

	matrix0	The first operand for the multiplication.
	vector0	The second operand for the multiplication.
	typeTag	The third argument is a type tag indicating which type is to be used to perform the computation.

Returns:

A 1D array which is the matrix product of matrix0 and vector0. The element type of this array is set by the type_tag argument.

Definition at line 2775 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dot(), dlr::numeric::Array2D< Type >::row(), dlr::numeric::Array2D< Type >::rows(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< typename NumericTraits< Type >::ProductType > dlr::numeric::matrixMultiply	(	const Array2D< Type > &	matrix0,
		const Array1D< Type > &	vector0
	)			[inline]

This function computes a matrix * vector product.

Assuming the first argument, matrix0, represents a matrix, and the and the second argument, vector0, represents a column vector, then this function computes the product: matrix0 * vector0

Parameters:

	matrix0	The first operand for the multiplication.
	vector0	The second operand for the multiplication.

Returns:

A 1D array which is the matrix product of matrix0 and vector0. The element type of this array is determined by NumericTraits<Type>::ProductType for the element type of the arguments.

Definition at line 2762 of file dlrNumeric/utilities.h.

References matrixMultiply().

template<class Type0, class Type1, class Type2>

Array1D< Type2 > dlr::numeric::matrixMultiply	(	const Array1D< Type0 > &	vector0,
		const Array2D< Type0 > &	matrix0,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes a vector * matrix product just like matrixMultiply(const Array1D<Type>&, const Array2D<Type>&), above.

This function differs in that the element type of the return value is set explicitly using a third argument.

Parameters:

	vector0	The first operand for the multiplication.
	matrix0	The second operand for the multiplication.
	typeTag	The third argument is a type tag indicating which type is to be used to perform the computation.

Returns:

A 1D array which is the matrix product of vector0 and matrix0. The element type of this array is set by the type_tag argument.

Definition at line 2733 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dlr::numeric::Array2D< Type >::rows(), dlr::numeric::Array1D< Type >::size(), and zeros().

template<class Type>

Array1D< typename NumericTraits< Type >::ProductType > dlr::numeric::matrixMultiply	(	const Array1D< Type > &	vector0,
		const Array2D< Type > &	matrix0
	)			[inline]

This function computes a vector * matrix product.

Assuming the first argument, vector0, represents a column vector and the second argument, matrix0, represents a 2D array, then this function computes the product: vector0' * matrix0 Where the single quote indicates transpose.

Parameters:

	vector0	The first operand for the multiplication.
	matrix0	The second operand for the multiplication.

Returns:

A 1D array which is the matrix product of vector0 and matrix0. The element type of this array is determined by NumericTraits<Type>::ProductType for the element type of the arguments.

Definition at line 2721 of file dlrNumeric/utilities.h.

Referenced by matrixMultiply().

template<class Type, class Functor>

Type dlr::numeric::maximum	(	const Array1D< Type > &	array0,
		Functor	comparator
	)			[inline]

This function returns a copy of the largest element in the input Array1D instance, where largeness is defined by the return value of the second argument.

NOTE: Read the argument description for comparator carefully. It is consistent with the standard library convention, but many people find it to be counterintuitive.

Parameters:

	array0	This argument is the input array.
	comparator	This argument is a functor which supports the std::binary_function<Type, Type, bool> interface, and returns true if its first argument is smaller than its second argument.

Returns:

A copy of an element of the input array such that no other element of the input array is larger, where largeness is defined by comparator.

Definition at line 2850 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW3, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

Referenced by dlr::computerVision::applyCanny().

template<class Type>

Type dlr::numeric::maximum

(

const Array1D< Type > &

array0

)

[inline]

This function returns a copy of the largest element in the input Array1D instance.

Parameters:

array0

This argument is the input array.

Returns:

A copy of an element of the input array such that no other element of the input array is larger.

Definition at line 2840 of file dlrNumeric/utilities.h.

template<class Type0, class Type1>

Type1 dlr::numeric::mean	(	const Array1D< Type0 > &	array0,
		type_tag< Type1 >	typeTag
	)			[inline]

This function computes the average value, or geometric mean, of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.

The computation is performed using the type specified by the second argument to the mean() function call.

Parameters:

	array0	This argument is the input array, from the elements of which the mean will be computed.
	typeTag	This argument specifies the type which will be used to perform the computation, and also specifies the return type of the function.

Returns:

The return value is the mean of the elements of array0.

Definition at line 2899 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::size(), and sum().

template<class Type>

double dlr::numeric::mean

(

const Array1D< Type > &

array0

)

[inline]

This function computes the average value, or geometric mean, of the elements of its argument.

The computation is performed using the precision specified by NumericTraits<Type>::SumType, but is returned as an instance of Type.

Parameters:

array0

This argument is the input array, from the elements of which the mean will be computed.

Returns:

The return value is the mean of the elements of array0.

Definition at line 2881 of file dlrNumeric/utilities.h.

References DLR_THROW3, mean(), and dlr::numeric::Array1D< Type >::size().

template<class Iterator, class Type>

Type dlr::numeric::mean	(	const Iterator &	beginIter,
		const Iterator &	endIter
	)			[inline]

This function computes the average value, or geometric mean, of the elements of its argument.

The computation is performed using the precision specified by NumericTraits<Type>::SumType, but is returned as an instance of Type.

Parameters:

array0

This argument is the input array, from the elements of which the mean will be computed.

Returns:

The return value is the mean of the elements of array0.

Definition at line 2864 of file dlrNumeric/utilities.h.

References count().

Referenced by mean(), normalizedCorrelation(), and variance().

template<class Type, class Functor>

Type dlr::numeric::minimum	(	const Array1D< Type > &	array0,
		Functor	comparator
	)			[inline]

This function returns a copy of the smallest element in the input Array1D instance, where largeness is defined by the return value of the second argument.

NOTE: Read the argument description for comparator carefully. It is consistent with the standard library convention, but many people find it to be counterintuitive.

Parameters:

	array0	This argument is the input array.
	comparator	This argument is a functor which supports the std::binary_function<Type, Type, bool> interface, and returns true if its first argument is smaller than its second argument.

Returns:

A copy of an element of the input array such that no other element of the input array is smaller, where largeness is defined by comparator.

Definition at line 3042 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

Referenced by dlr::computerVision::applyCanny().

template<class Type>

Type dlr::numeric::minimum

(

const Array1D< Type > &

array0

)

[inline]

This function returns a copy of the smallest element in the input Array1D instance.

Parameters:

array0

This argument is the input array.

Returns:

A copy of an element of the input array such that no other element of the input array is smaller.

Definition at line 3028 of file dlrNumeric/utilities.h.

References DLR_THROW3, and dlr::numeric::Array1D< Type >::size().

template<class FUNCTOR>

double dlr::numeric::newtonRaphson	(	double	startPoint,
		FUNCTOR	objectiveFunction,
		double	epsilon,
		size_t	maxIterations
	)			[inline]

This function uses the iterative method of Newton and Raphson to search for a zero crossing of the supplied functor.

If convergence fails, it throws a ValueException (blaming the argument for not having a sufficiently findable zero crossing).

Parameters:

	startPoint	This argument specifies the point at which to start the search.
	objectiveFunction	This argument is an instance of the functor type. The functor must accept a single argument of type double, and return a double, and must provide a method derivative(double), which returns the first derivative.
	epsilon	This argument specifies the convergence tolerance. Iteration will stop when the algorithm finds a value which, when passed to objectiveFunction, results in a return value with magnitude less than epsilon.
	maxIterations	This argument specifies how many iterations should be permitted before giving up the search (& throwing an exception).

Returns:

The return value is a value which, when passed to objectiveFunction, results in a return value with magnitude less than epsilon.

Definition at line 3051 of file dlrNumeric/utilities.h.

References count(), and DLR_THROW.

template<class Type, class Type2>

Type2 dlr::numeric::normalizedCorrelation	(	const Array1D< Type > &	x,
		const Array1D< Type > &	y,
		type_tag< Type2 >	typeTag
	)			[inline]

This function is equivalent to normalizedCorrelation(const Array1D&, const Array1D&), except that the computation is carried out using the type specified by the third argument.

Parameters:

	x	This argument is an Array1D instance containing the first of the signals to be correlated.
	y	This argument is an Array1D instance containing the second of the signals to be correlated.
	typeTag	This parameter specifies the type with which the normalized correlation computation will be calculated.

Returns:

The return value is the normalized correlation of the two signals.

Definition at line 3085 of file dlrNumeric/utilities.h.

References mean(), dlr::numeric::Array1D< Type >::size(), sqrt(), and sum().

template<class Type>

double dlr::numeric::normalizedCorrelation	(	const Array1D< Type > &	x,
		const Array1D< Type > &	y
	)			[inline]

This function computes the normalized correlation of two Array1D arguments.

This is equivalent to (but slightly more efficient than) independently normalizing the signal in each Array1D to zero mean and unit variance, and then computing the dot product of the two normalized Array1D elements. The computation is carried out in double precision floating point. For more information on normalized correlation, which is often called "correlation coefficient," please refer to R. O. Duda and P. E. Hart, Pattern Classification and Scene Analysis, Wiley, NY, 1973.

Parameters:

	x	This argument is an Array1D instance containing the first of the signals to be correlated.
	y	This argument is an Array1D instance containing the second of the signals to be correlated.

Returns:

The return value is the normalized correlation of the two signals.

Definition at line 3075 of file dlrNumeric/utilities.h.

template<class Type>

Array2D< Type > dlr::numeric::ones	(	int	rows,
		int	columns,
		type_tag< Type >	typeTag
	)			[inline]

This function returns an Array2D of the specified size and type in which the value of every element is initialized to one.

Parameters:

	rows	This argument specifies the number of rows in the returned array.
	columns	This argument specifies the number of columns in the returned array.
	typeTag	This is a type_tag instance which specifies the element type of the returned array.

Returns:

An Array2D instance in which each element is set to zero.

Definition at line 3117 of file dlrNumeric/utilities.h.

template<class Type>

Array1D< Type > dlr::numeric::ones	(	int	size,
		type_tag< Type >	typeTag
	)			[inline]

This function returns an Array1D of the specified size and type in which the value of every element is initialized to 1.

Parameters:

	size	This argument specifies the number of elements in the returned array.
	typeTag	This is a type_tag instance which specifies the element type of the returned array.

Returns:

An Array1D instance in which each element is set to zero.

Definition at line 3106 of file dlrNumeric/utilities.h.

Vector3D dlr::numeric::operator *	(	double	scalar0,
		const Vector3D &	vector0
	)			[inline]

This operator multiplies a scalar value with each element of a Vector3D instance.

Parameters:

	scalar0	Scalar argument of the multiplication.
	vector0	Vector argument of the multiplication.

Returns:

Vector3D instance in which the value of each element is the product of the scalar argument and the corresponding element of the Vector3D argument.

Definition at line 441 of file vector3D.h.

Vector3D dlr::numeric::operator *	(	const Vector3D &	vector0,
		double	scalar0
	)

This operator multiplies a Vector3D by scalar.

Parameters:

	vector0	This is the Vector3D instance which is to be multiplied by the scalar.
	scalar0	This is amount by which should argument vector0 is to be multiplied.

Returns:

A Vector3D instance in which the value of each element is equal to the corresponding value of the first argument multiplied by the value of the second argument.

Definition at line 70 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector3D dlr::numeric::operator *	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)

This operator returns the elementwise product of two Vector3D instances.

Parameters:

	vector0	This is the first of the two Vector3D instances to be multiplied.
	vector1	This is the second of the two Vector3D instances to be multiplied.

Returns:

A Vector3D instance in which the value of each element is equal to the product of the corresponding elements of the two arguments.

Definition at line 38 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector2D dlr::numeric::operator *	(	double	scalar0,
		const Vector2D &	vector0
	)			[inline]

This operator multiplies a scalar value with each element of a Vector2D instance.

Parameters:

	scalar0	Scalar argument of the multiplication.
	vector0	Vector argument of the multiplication.

Returns:

Vector2D instance in which the value of each element is the product of the scalar argument and the corresponding element of the Vector2D argument.

Definition at line 463 of file vector2D.h.

Vector2D dlr::numeric::operator *	(	const Vector2D &	vector0,
		double	scalar0
	)

This operator multiplies a Vector2D by scalar.

Parameters:

	vector0	This is the Vector2D instance which is to be multiplied by the scalar.
	scalar0	This is amount by which should argument vector0 is to be multiplied.

Returns:

A Vector2D instance in which the value of each element is equal to the corresponding value of the first argument multiplied by the value of the second argument.

Definition at line 57 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

Vector2D dlr::numeric::operator *	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)

This operator returns the elementwise product of two Vector2D instances.

Parameters:

	vector0	This is the first of the two Vector2D instances to be multiplied.
	vector1	This is the second of the two Vector2D instances to be multiplied.

Returns:

A Vector2D instance in which the value of each element is equal to the product of the corresponding elements of the two arguments.

Definition at line 33 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

Transform3DTo2D dlr::numeric::operator *	(	const Transform3DTo2D &	transform0,
		const Transform3D &	transform1
	)

This operator composes a Transform3DTo2D instance with a Transform3D instance.

The resulting Transform3DTo2D instance the equation:

(transform0 * transform1) * v0 = transform0 * (transform1 * v0),

where v0 is a Vector3D instance.

Parameters:

	transform0	This is the Transform3DTo2D instance to be composed.
	transform1	This is the Transform3D instance to be composed.

Returns:

A Transform3DTo2D instance which is equivalent to the composition of the two arguments.

Definition at line 207 of file transform3DTo2D.cpp.

References dlr::numeric::Transform3DTo2D::Transform3DTo2D(), dlr::numeric::Transform3D::value(), and dlr::numeric::Transform3DTo2D::value().

Transform3D dlr::numeric::operator *	(	const Transform3D &	transform0,
		const Transform3D &	transform1
	)

This operator composes two Transform3D instances.

The resulting transform satisfies the equation:

(transform0 * transform1) * v0 = transform0 * (transform1 * v0),

where v0 is a Vector3D instance.

Parameters:

	transform0	This is the first of the two Transform3D instances to be composed.
	transform1	This is the second of the two Transform3D instances to be composed.

Returns:

A Transform3D instance which is equivalent to the composition of the two arguments.

Definition at line 336 of file transform3D.cpp.

References dlr::numeric::Transform3D::Transform3D(), and dlr::numeric::Transform3D::value().

Transform2D dlr::numeric::operator *	(	const Transform2D &	transform0,
		const Transform2D &	transform1
	)

This operator composes two Transform2D instances.

The resulting transform satisfies the equation:

(transform0 * transform1) * v0 = transform0 * (transform1 * v0),

where v0 is a Vector2D instance.

Parameters:

	transform0	This is the first of the two Transform2D instances to be composed.
	transform1	This is the second of the two Transform2D instances to be composed.

Returns:

A Transform2D instance which is equivalent to the composition of the two arguments.

Definition at line 253 of file transform2D.cpp.

References dlr::numeric::Transform2D::Transform2D(), and dlr::numeric::Transform2D::value().

template<class Type>

Polynomial< Type > dlr::numeric::operator *	(	const Polynomial< Type > &	arg0,
		const Polynomial< Type > &	arg1
	)			[inline]

This operator multiplies two Polynomial instances.

Values returned by operator()(xValue) of the result of this multiplication will be equal to the product of the values returned by the operator()(xValue) of arg0 and arg1.

Parameters:

	arg0	This argument is one of the Polynomial instances to be multiplied.
	arg1	This argument is one of the Polynomial instances to be multiplied.

Returns:

The return value is the result of the multiplication.

Definition at line 492 of file polynomial.h.

Index2D dlr::numeric::operator *	(	int	scalar0,
		const Index2D &	index0
	)			[inline]

This operator multiplies a scalar value with each element of a Index2D instance.

Parameters:

	scalar0	Scalar argument of the multiplication.
	index0	Index2D argument of the multiplication.

Returns:

Index2D instance in which the value of each element is the product of the scalar argument and the corresponding element of the Index2D argument.

Definition at line 407 of file index2D.h.

Index2D dlr::numeric::operator *	(	const Index2D &	index0,
		int	scalar0
	)

This operator multiplies an Index2D by scalar.

Parameters:

	index0	This is the Index2D instance which is to be multiplied by the scalar.
	scalar0	This is amount by which should argument index0 is to be multiplied.

Returns:

An Index2D instance in which the value of each element is equal to the corresponding value of the first argument multiplied by the value of the second argument.

Definition at line 63 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

Index2D dlr::numeric::operator *	(	const Index2D &	index0,
		const Index2D &	index1
	)

This operator returns the elementwise product of two Index2D instances.

Parameters:

	index0	This is the first of the two Index2D instances to be multiplied.
	index1	This is the second of the two Index2D instances to be multiplied.

Returns:

An Index2D instance in which the value of each element is equal to the product of the corresponding elements of the two arguments.

Definition at line 35 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

template<class Type>

Array3D< Type > dlr::numeric::operator *	(	Type	scalar,
		const Array3D< Type > &	array0
	)			[inline]

Multiplication of scalar and Array3D.

Parameters:

	scalar	Scalar argument of the multiplication.
	array0	Array3D argument of the multiplication.

Returns:

Array3D instance in which the value of each element is the product of the scalar argument and the corresponding element of the Array3D argument.

Definition at line 1858 of file array3D.h.

template<class Type>

Array3D< Type > dlr::numeric::operator *	(	const Array3D< Type > &	array0,
		Type	scalar
	)			[inline]

Multiplication of Array3D and scalar.

Parameters:

	array0	Array3D argument of the multiplication.
	scalar	Scalar argument of the multiplication.

Returns:

Array3D instance in which the value of each element is the product of the corresponding element of the Array3D argument and the scalar argument.

Definition at line 1831 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array3D< Type > dlr::numeric::operator *	(	const Array3D< Type > &	array0,
		const Array3D< Type > &	array1
	)			[inline]

Elementwise multiplication of Array3D instances.

Parameters:

	array0	First argument for multiplication.
	array1	Second argument for multiplication.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array3D instance in which the value of each element is the product of the values of the corresponding elements of the two Array3D arguments.

Definition at line 1765 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), DLR_THROW, dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< Type > dlr::numeric::operator *	(	Type	scalar,
		const Array2D< Type > &	array0
	)			[inline]

Multiplication of scalar and Array2D.

Parameters:

	scalar	Scalar argument of the multiplication.
	array0	Array2D argument of the multiplication.

Returns:

Array2D instance in which the value of each element is the product of the scalar argument and the corresponding element of the Array2D argument.

Definition at line 2002 of file array2D.h.

template<class Type>

Array2D< Type > dlr::numeric::operator *	(	const Array2D< Type > &	array0,
		Type	scalar
	)			[inline]

Multiplication of Array2D and scalar.

Parameters:

	array0	Array2D argument of the multiplication.
	scalar	Scalar argument of the multiplication.

Returns:

Array2D instance in which the value of each element is the product of the corresponding element of the Array2D argument and the scalar argument.

Definition at line 1978 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array2D< Type > dlr::numeric::operator *	(	const Array2D< Type > &	array0,
		const Array2D< Type > &	array1
	)			[inline]

Elementwise multiplication of Array2D instances.

Parameters:

	array0	First argument for multiplication.
	array1	Second argument for multiplication.

Exceptions:

ValueException

thrown when array sizes differ.

Returns:

Array2D instance in which the value of each element is the product of the values of the corresponding elements of the two Array2D arguments.

Definition at line 1924 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::operator *	(	Type	scalar,
		const Array1D< Type > &	array0
	)			[inline]

Multiplication of scalar and Array1D.

Parameters:

	scalar	Scalar argument of the multiplication.
	array0	Array1D argument of the multiplication.

Returns:

Array1D instance in which the value of each element is the product of the scalar argument and the corresponding element of the Array1D argument.

Definition at line 1548 of file array1D.h.

template<class Type>

Array1D< Type > dlr::numeric::operator *	(	const Array1D< Type > &	array0,
		Type	scalar
	)			[inline]

Multiplication of Array1D and scalar.

Parameters:

	array0	Array1D argument of the multiplication.
	scalar	Scalar argument of the multiplication.

Returns:

Array1D instance in which the value of each element is the product of the corresponding element of the Array1D argument and the scalar argument.

Definition at line 1511 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::operator *	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

Elementwise multiplication of Array1D instances.

Parameters:

	array0	First argument for multiplication.
	array1	Second argument for multiplication.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array1D instance in which the value of each element is the product of the values of the corresponding elements of the two Array1D arguments.

Definition at line 1455 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

bool dlr::numeric::operator!=	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)

This operator checks the supplied vectors for inequality.

Parameters:

	vector0	First vector to compare.
	vector1	Second vector to compare.

Returns:

Result of comparing vector0 to vector1 for inequality.

Definition at line 94 of file vector3D.cpp.

bool dlr::numeric::operator!=	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)

This operator checks the supplied vectors for inequality.

Parameters:

	vector0	First vector to compare.
	vector1	Second vector to compare.

Returns:

Result of comparing vector0 to vector1 for inequality.

Definition at line 76 of file vector2D.cpp.

bool dlr::numeric::operator!=	(	const Index2D &	index0,
		const Index2D &	index1
	)

This operator checks the supplied indexs for inequality.

Parameters:

	index0	First Index2D instance to compare.
	index1	Second Index2D instance to compare.

Returns:

Result of comparing index0 to index1 for inequality.

Definition at line 86 of file index2D.cpp.

Vector3D dlr::numeric::operator+	(	double	scalar0,
		const Vector3D &	vector0
	)			[inline]

This operator adds a scalar value to each element of a Vector3D instance.

Parameters:

	scalar0	Scalar argument of the addition.
	vector0	Vector argument of the addition.

Returns:

Vector3D instance in which the value of each element is the sum of the scalar argument and the corresponding element of the Vector3D argument.

Definition at line 436 of file vector3D.h.

Vector3D dlr::numeric::operator+	(	const Vector3D &	vector0,
		double	scalar0
	)

This operator adds a scalar and a Vector3D.

Parameters:

	vector0	This is the Vector3D instance to which the scalar should be added.
	scalar0	This is amount which should be added to each element of argument vector0.

Returns:

A Vector3D instance in which the value of each element is equal to the corresponding value of the first argument plus the value of the second argument.

Definition at line 54 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector3D dlr::numeric::operator+	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)

This operator returns the elementwise sum of two Vector3D instances.

Parameters:

	vector0	This is the first of the two Vector3D instances to be added.
	vector1	This is the second of the two Vector3D instances to be added.

Returns:

A Vector3D instance in which the value of each element is equal to the sum of the corresponding elements of the two arguments.

Definition at line 22 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector2D dlr::numeric::operator+	(	double	scalar0,
		const Vector2D &	vector0
	)			[inline]

This operator adds a scalar value to each element of a Vector2D instance.

Parameters:

	scalar0	Scalar argument of the addition.
	vector0	Vector argument of the addition.

Returns:

Vector2D instance in which the value of each element is the sum of the scalar argument and the corresponding element of the Vector2D argument.

Definition at line 458 of file vector2D.h.

Vector2D dlr::numeric::operator+	(	const Vector2D &	vector0,
		double	scalar0
	)

This operator adds a scalar and a Vector2D.

Parameters:

	vector0	This is the Vector2D instance to which the scalar should be added.
	scalar0	This is amount which should be added to each element of argument vector0.

Returns:

A Vector2D instance in which the value of each element is equal to the corresponding value of the first argument plus the value of the second argument.

Definition at line 45 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

Vector2D dlr::numeric::operator+	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)

This operator returns the elementwise sum of two Vector2D instances.

Parameters:

	vector0	This is the first of the two Vector2D instances to be added.
	vector1	This is the second of the two Vector2D instances to be added.

Returns:

A Vector2D instance in which the value of each element is equal to the sum of the corresponding elements of the two arguments.

Definition at line 21 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

template<class Type>

Polynomial< Type > dlr::numeric::operator+	(	const Polynomial< Type > &	arg0,
		const Polynomial< Type > &	arg1
	)			[inline]

This operator adds two Polynomial instances.

Values returned by operator()(xValue) of the result of this multiplication will be equal to the sum of the values returned by the operator()(xValue) of arg0 and arg1.

Parameters:

	arg0	This argument is one of the Polynomial instances to be added.
	arg1	This argument is one of the Polynomial instances to be added.

Returns:

The return value is the result of the addition.

Definition at line 503 of file polynomial.h.

Index2D dlr::numeric::operator+	(	int	scalar0,
		const Index2D &	index0
	)			[inline]

This operator adds a scalar value to each element of an Index2D instance.

Parameters:

	scalar0	Scalar argument of the addition.
	index0	Index2D argument of the addition.

Returns:

Index2D instance in which the value of each element is the sum of the scalar argument and the corresponding element of the Index2D argument.

Definition at line 402 of file index2D.h.

Index2D dlr::numeric::operator+	(	const Index2D &	index0,
		int	scalar0
	)

This operator adds a scalar and an Index2D.

Parameters:

	index0	This is the Index2D instance to which the scalar should be added.
	scalar0	This is amount which should be added to each element of argument index0.

Returns:

An Index2D instance in which the value of each element is equal to the corresponding value of the first argument plus the value of the second argument.

Definition at line 49 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

Index2D dlr::numeric::operator+	(	const Index2D &	index0,
		const Index2D &	index1
	)

This operator returns the elementwise sum of two Index2D instances.

Parameters:

	index0	This is the first of the two Index2D instances to be added.
	index1	This is the second of the two Index2D instances to be added.

Returns:

An Index2D instance in which the value of each element is equal to the sum of the corresponding elements of the two arguments.

Definition at line 21 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

template<class Type>

Array3D< Type > dlr::numeric::operator+	(	Type	scalar,
		const Array3D< Type > &	array0
	)			[inline]

Addition of scalar and Array3D.

Parameters:

	scalar	Scalar argument of the addition.
	array0	Array3D argument of the addition.

Returns:

Array3D instance in which the value of each element is the sum of the scalar argument and the corresponding element of the Array3D argument.

Definition at line 1851 of file array3D.h.

template<class Type>

Array3D< Type > dlr::numeric::operator+	(	const Array3D< Type > &	array0,
		Type	scalar
	)			[inline]

Addition of Array3D and scalar.

Parameters:

	array0	Array3D argument of the addition.
	scalar	Scalar argument of the addition.

Returns:

Array3D instance in which the value of each element is the sum of the corresponding element of the Array3D argument and the scalar argument.

Definition at line 1811 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array3D< Type > dlr::numeric::operator+	(	const Array3D< Type > &	array0,
		const Array3D< Type > &	array1
	)			[inline]

Elementwise addition of Array3D instances.

Parameters:

	array0	First argument for addition.
	array1	Second argument for addition.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array3D instance in which the value of each element is the sum of the values of the corresponding elements of the two Array3D arguments.

Definition at line 1719 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), DLR_THROW, dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< Type > dlr::numeric::operator+	(	Type	scalar,
		const Array2D< Type > &	array0
	)			[inline]

Addition of scalar and Array2D.

Parameters:

	scalar	Scalar argument of the addition.
	array0	Array2D argument of the addition.

Returns:

Array2D instance in which the value of each element is the sum of the scalar argument and the corresponding element of the Array2D argument.

Definition at line 1996 of file array2D.h.

template<class Type>

Array2D< Type > dlr::numeric::operator+	(	const Array2D< Type > &	array0,
		Type	scalar
	)			[inline]

Addition of Array2D and scalar.

Parameters:

	array0	Array2D argument of the addition.
	scalar	Scalar argument of the addition.

Returns:

Array2D instance in which the value of each element is the sum of the corresponding element of the Array2D argument and the scalar argument.

Definition at line 1960 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array2D< Type > dlr::numeric::operator+	(	const Array2D< Type > &	array0,
		const Array2D< Type > &	array1
	)			[inline]

Elementwise addition of Array2D instances.

Parameters:

	array0	First argument for addition.
	array1	Second argument for addition.

Exceptions:

ValueException

thrown when array sizes differ.

Returns:

Array2D instance in which the value of each element is the sum of the values of the corresponding elements of the two Array2D arguments.

Definition at line 1888 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::operator+	(	Type	scalar,
		const Array1D< Type > &	array0
	)			[inline]

Addition of scalar and Array1D.

Parameters:

	scalar	Scalar argument of the addition.
	array0	Array1D argument of the addition.

Returns:

Array1D instance in which the value of each element is the sum of the scalar argument and the corresponding element of the Array1D argument.

Definition at line 1531 of file array1D.h.

template<class Type>

Array1D< Type > dlr::numeric::operator+	(	const Array1D< Type > &	array,
		Type	scalar
	)			[inline]

Addition of Array1D and scalar.

Parameters:

	array	Array1D argument of the addition.
	scalar	Scalar argument of the addition.

Returns:

Array1D instance in which the value of each element is the sum of the corresponding element of the Array1D argument and the scalar argument.

Definition at line 1491 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::operator+	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

Elementwise addition of Array1D instances.

Parameters:

	array0	First argument for addition.
	array1	Second argument for addition.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array1D instance in which the value of each element is the sum of the values of the corresponding elements of the two Array1D arguments.

Definition at line 1419 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

Vector3D dlr::numeric::operator-	(	const Vector3D &	vector0,
		double	scalar0
	)

This operator subtracts a scalar from a Vector3D.

Parameters:

	vector0	This is the Vector3D instance from which the scalar should be subtracted.
	scalar0	This is amount which should be subtracted from each element of argument vector0.

Returns:

A Vector3D instance in which the value of each element is equal to the corresponding value of the first argument minus the value of the second argument.

Definition at line 62 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector3D dlr::numeric::operator-	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)

This operator returns the elementwise difference of two Vector3D instances.

Parameters:

	vector0	This is the first of the two Vector3D instances to be subtracted.
	vector1	This is the second of the two Vector3D instances to be subtracted.

Returns:

A Vector3D instance in which the value of each element is equal to the difference of the corresponding elements of the two arguments.

Definition at line 30 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector2D dlr::numeric::operator-	(	const Vector2D &	vector0,
		double	scalar0
	)

This operator subtracts a scalar from a Vector2D.

Parameters:

	vector0	This is the Vector2D instance from which the scalar should be subtracted.
	scalar0	This is amount which should be subtracted from each element of argument vector0.

Returns:

A Vector2D instance in which the value of each element is equal to the corresponding value of the first argument minus the value of the second argument.

Definition at line 51 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

Vector2D dlr::numeric::operator-	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)

This operator returns the elementwise difference of two Vector2D instances.

Parameters:

	vector0	This is the first of the two Vector2D instances to be subtracted.
	vector1	This is the second of the two Vector2D instances to be subtracted.

Returns:

A Vector2D instance in which the value of each element is equal to the difference of the corresponding elements of the two arguments.

Definition at line 27 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

template<class Type>

Polynomial< Type > dlr::numeric::operator-	(	const Polynomial< Type > &	arg0,
		const Polynomial< Type > &	arg1
	)			[inline]

This operator subtracts two Polynomial instances.

Values returned by operator()(xValue) of the result of this multiplication will be equal to arg0.operator(xValue) - arg1.operator()(xValue).

Parameters:

	arg0	This argument is the Polynomial instances from which arg1 is to be subtracted.
	arg1	This argument is the Polynomial instances to be subtracted from arg0.

Returns:

The return value is the result of the subtraction.

Definition at line 514 of file polynomial.h.

Index2D dlr::numeric::operator-	(	const Index2D &	index0,
		int	scalar0
	)

This operator subtracts a scalar from an Index2D.

Parameters:

	index0	This is the Index2D instance from which the scalar should be subtracted.
	scalar0	This is amount which should be subtracted from each element of argument index0.

Returns:

An Index2D instance in which the value of each element is equal to the corresponding value of the first argument minus the value of the second argument.

Definition at line 56 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

Index2D dlr::numeric::operator-	(	const Index2D &	index0,
		const Index2D &	index1
	)

This operator returns the elementwise difference of two Index2D instances.

Parameters:

	index0	This is the first of the two Index2D instances to be subtracted.
	index1	This is the second of the two Index2D instances to be subtracted.

Returns:

An Index2D instance in which the value of each element is equal to the difference of the corresponding elements of the two arguments.

Definition at line 28 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

template<class Type>

Array3D< Type > dlr::numeric::operator-	(	const Array3D< Type > &	array0,
		Type	scalar
	)			[inline]

Subtraction of Array3D and scalar.

Parameters:

	array0	Array3D argument of the subtraction.
	scalar	Scalar argument of the subtraction.

Returns:

Array3D instance in which the value of each element is the difference of the corresponding element of the Array3D argument and the scalar argument.

Definition at line 1821 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array3D< Type > dlr::numeric::operator-	(	const Array3D< Type > &	array0,
		const Array3D< Type > &	array1
	)			[inline]

Elementwise subtraction of Array3D instances.

Parameters:

	array0	First argument for subtraction.
	array1	Second argument for subtraction.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array3D instance in which the value of each element is the difference of the values of the corresponding elements of the two Array3D arguments.

Definition at line 1742 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), DLR_THROW, dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< Type > dlr::numeric::operator-	(	const Array2D< Type > &	array0,
		Type	scalar
	)			[inline]

Subtraction of Array2D and scalar.

Parameters:

	array0	Array2D argument of the subtraction.
	scalar	Scalar argument of the subtraction.

Returns:

Array2D instance in which the value of each element is the difference of the corresponding element of the Array2D argument and the scalar argument.

Definition at line 1969 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array2D< Type > dlr::numeric::operator-	(	const Array2D< Type > &	array0,
		const Array2D< Type > &	array1
	)			[inline]

Elementwise subtraction of Array2D instances.

Parameters:

	array0	First argument for subtraction.
	array1	Second argument for subtraction.

Exceptions:

ValueException

thrown when array sizes differ.

Returns:

Array2D instance in which the value of each element is the difference of the values of the corresponding elements of the two Array2D arguments.

Definition at line 1906 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::operator-	(	Type	scalar,
		const Array1D< Type > &	array0
	)			[inline]

Subtraction of scalar and Array1D.

Parameters:

	scalar	Scalar argument of the subtraction.
	array0	Array1D argument of the subtraction.

Returns:

Array1D instance in which the value of each element is the difference of the scalar argument and the corresponding element of the Array1D argument.

Definition at line 1538 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::operator-	(	const Array1D< Type > &	array0,
		Type	scalar
	)			[inline]

Subtraction of Array1D and scalar.

Parameters:

	array0	Array1D argument of the subtraction.
	scalar	Scalar argument of the subtraction.

Returns:

Array1D instance in which the value of each element is the difference of the corresponding element of the Array1D argument and the scalar argument.

Definition at line 1501 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::operator-	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

Elementwise subtraction of Array1D instances.

Parameters:

	array0	First argument for subtraction.
	array1	Second argument for subtraction.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array1D instance in which the value of each element is the difference of the values of the corresponding elements of the two Array1D arguments.

Definition at line 1437 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

Vector3D dlr::numeric::operator/	(	const Vector3D &	vector0,
		double	scalar0
	)

This operator divides a Vector3D by scalar.

Parameters:

	vector0	This is the Vector3D instance which is to be divided by the scalar.
	scalar0	This is amount by which should argument vector0 is to be divided.

Returns:

A Vector3D instance in which the value of each element is equal to the corresponding value of the first argument divided by the value of the second argument.

Definition at line 78 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector3D dlr::numeric::operator/	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)

This operator returns the elementwise dividend of two Vector3D instances.

Parameters:

	vector0	This is the Vector3D instance whose element values are to be divided.
	vector1	This is the Vector3D instance by whose elements the first argument is to be divided.

Returns:

A Vector3D instance in which the value of each element is equal to the corresponding value of the first argument divided by the corresponding value of the second argument.

Definition at line 46 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Vector2D dlr::numeric::operator/	(	const Vector2D &	vector0,
		double	scalar0
	)

This operator divides a Vector2D by scalar.

Parameters:

	vector0	This is the Vector2D instance which is to be divided by the scalar.
	scalar0	This is amount by which should argument vector0 is to be divided.

Returns:

A Vector2D instance in which the value of each element is equal to the corresponding value of the first argument divided by the value of the second argument.

Definition at line 62 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

Vector2D dlr::numeric::operator/	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)

This operator returns the elementwise dividend of two Vector2D instances.

Parameters:

	vector0	This is the Vector2D instance whose element values are to be divided.
	vector1	This is the Vector2D instance by whose elements the first argument is to be divided.

Returns:

A Vector2D instance in which the value of each element is equal to the corresponding value of the first argument divided by the corresponding value of the second argument.

Definition at line 39 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

Index2D dlr::numeric::operator/	(	const Index2D &	index0,
		int	scalar0
	)

This operator divides an Index2D by scalar.

Parameters:

	index0	This is the Index2D instance which is to be divided by the scalar.
	scalar0	This is amount by which should argument index0 is to be divided.

Returns:

An Index2D instance in which the value of each element is equal to the corresponding value of the first argument divided by the value of the second argument.

Definition at line 70 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

Index2D dlr::numeric::operator/	(	const Index2D &	index0,
		const Index2D &	index1
	)

This operator returns the elementwise dividend of two Index2D instances.

Parameters:

	index0	This is the Index2D instance whose element values are to be divided.
	index1	This is the Index2D instance by whose elements the first argument is to be divided.

Returns:

An Index2D instance in which the value of each element is equal to the corresponding value of the first argument divided by the corresponding value of the second argument.

Definition at line 42 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

template<class Type>

Array3D< Type > dlr::numeric::operator/	(	const Array3D< Type > &	array0,
		Type	scalar
	)			[inline]

Division of Array3D and scalar.

Parameters:

	array0	Array3D argument of the division.
	scalar	Scalar argument of the division.

Returns:

Array3D instance in which the value of each element is the difference of the corresponding element of the Array3D argument and the scalar argument.

Definition at line 1841 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array3D< Type > dlr::numeric::operator/	(	const Array3D< Type > &	array0,
		const Array3D< Type > &	array1
	)			[inline]

Elementwise division of Array3D instances.

Parameters:

	array0	First argument for division.
	array1	Second argument for division.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array3D instance in which the value of each element is the dividend of the values of the corresponding elements of the two Array3D arguments.

Definition at line 1788 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), DLR_THROW, dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< Type > dlr::numeric::operator/	(	const Array2D< Type > &	array0,
		Type	scalar
	)			[inline]

Division of Array2D and scalar.

Parameters:

	array0	Array2D argument of the division.
	scalar	Scalar argument of the division.

Returns:

Array2D instance in which the value of each element is the difference of the corresponding element of the Array2D argument and the scalar argument.

Definition at line 1987 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array2D< Type > dlr::numeric::operator/	(	const Array2D< Type > &	array0,
		const Array2D< Type > &	array1
	)			[inline]

Elementwise division of Array2D instances.

Parameters:

	array0	First argument for division.
	array1	Second argument for division.

Exceptions:

ValueException

thrown when array sizes differ.

Returns:

Array2D instance in which the value of each element is the dividend of the values of the corresponding elements of the two Array2D arguments.

Definition at line 1942 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), DLR_THROW, dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< Type > dlr::numeric::operator/	(	Type	scalar,
		const Array1D< Type > &	array0
	)			[inline]

Division of scalar and Array1D.

Parameters:

	scalar	Scalar argument of the division.
	array0	Array1D argument of the division.

Returns:

Array1D instance in which the value of each element is the dividend of the scalar argument and the corresponding element of the Array1D argument.

Definition at line 1555 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::operator/	(	const Array1D< Type > &	array0,
		Type	scalar
	)			[inline]

Division of Array1D and scalar.

Parameters:

	array0	Array1D argument of the division.
	scalar	Scalar argument of the division.

Returns:

Array1D instance in which the value of each element is the difference of the corresponding element of the Array1D argument and the scalar argument.

Definition at line 1521 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< Type > dlr::numeric::operator/	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

Elementwise division of Array1D instances.

Parameters:

	array0	First argument for division.
	array1	Second argument for division.

Exceptions:

ValueException

on incompatible array sizes

Returns:

Array1D instance in which the value of each element is the dividend of the values of the corresponding elements of the two Array1D arguments.

Definition at line 1473 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), DLR_THROW, dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array3D< bool > dlr::numeric::operator<	(	const Array3D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array2D with a constant.

Parameters:

	array0	Array2D instance.
	arg	Value to which array0 elements should be compared.

Returns:

Array2D<bool> in which each element has value "true" if the corresponding element of array0 is less than arg.

Definition at line 1900 of file array3D.h.

template<class Type>

Array2D< bool > dlr::numeric::operator<	(	const Array2D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array2D with a constant.

Parameters:

	array0	An Array2D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array2D<bool> in which each element has value "true" if the corresponding element of array0 is less than arg.

Definition at line 2043 of file array2D.h.

template<class Type>

Array1D< bool > dlr::numeric::operator<	(	const Array1D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array1D with a constant.

Parameters:

	array0	An Array1D instance.
	arg	Value to which array elements should be compared.

Returns:

An Array1D<bool> in which each element has value "true" if the corresponding element of array0 is less than arg.

Definition at line 1613 of file array1D.h.

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Vector3D &	vector0
	)

This function outputs a text representation of a Vector3D instance to a std::ostream.

The output format looks like this:

Vector3D(1.0, 2.0, 3.0)

Parameters:

	stream	This argument is a reference to the the output stream.
	vector0	This argument is a const reference to the Vector3D instance to be output.

Returns:

The return value is a reference to the input stream after the write has taken place.

Definition at line 100 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Vector2D &	vector0
	)

This function outputs a text representation of a Vector2D instance to a std::ostream.

The output format looks like this:

Vector2D(1.0, 2.0)

Parameters:

	stream	This argument is a reference to the the output stream.
	vector0	This argument is a const reference to the Vector2D instance to be output.

Returns:

The return value is a reference to the input stream after the write has taken place.

Definition at line 82 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Transform3D &	transform0
	)

Outputs a text representation of a Transform3D instance to a std::ostream.

The output format looks like this:

Transform3D(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 1.0)

Parameters:

	stream	Reference to the the output stream.
	transform0	Const reference to the Transform3D instance to be output.

Returns:

Reference to the output stream.

Definition at line 410 of file transform3D.cpp.

References dlr::numeric::Transform3D::value().

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Transform2D &	transform0
	)

Outputs a text representation of a Transform2D instance to a std::ostream.

The output format looks like this:

Transform2D(1.0, 2.0, 3.0, 5.0, 6.0, 7.0, 9.0, 10.0, 1.0)

Parameters:

	stream	Reference to the the output stream.
	transform0	Const reference to the Transform2D instance to be output.

Returns:

Reference to the output stream.

Definition at line 289 of file transform2D.cpp.

References dlr::numeric::Transform2D::value().

template<class Type>

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const SubArray2D< Type > &	subArray0
	)			[inline]

This stream output operator sends a text representation of the SubArray2D instance to the supplied stream instance.

Parameters:

	stream	The stream to which data should be written.
	subArray0	The SubArray2D instance to be written.

Returns:

A reference to argument stream.

Definition at line 710 of file subArray2D.h.

References subArray().

template<class Type>

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const SubArray1D< Type > &	subArray0
	)			[inline]

This stream output operator sends a text representation of the SubArray1D instance to the supplied stream instance.

Parameters:

	stream	The stream to which data should be written.
	subArray0	The SubArray1D instance to be written.

Returns:

A reference to argument stream.

Definition at line 504 of file subArray1D.h.

References subArray().

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Index2D &	index0
	)

This function outputs a text representation of an Index2D instance to a std::ostream.

The output format looks like this:

Index2D(1.0, 2.0)

Parameters:

	stream	This argument is a reference to the the output stream.
	index0	This argument is a const reference to the Index2D instance to be output.

Returns:

The return value is a reference to the input stream after the write has taken place.

Definition at line 93 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

template<class Type>

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Array3D< Type > &	array0
	)			[inline]

This operator outputs a text representation of an Array3D instance to a std::ostream.

The output format looks like this:

Array3D([[[1, 2, 4, 8, 16], [5, 1, 6, 7, 2]], [[8, 2, 4, 1, 0], [3, 3, 4, 5, 1]]])

Where the array elements are output using operator<<(std::ostream&, const Type&) and each element is separated from its neighbors by a comma and whitespace.

Parameters:

	stream	Reference to the the output stream.
	array0	Const reference to the Array3D to be output.

Returns:

Reference to output stream.

Definition at line 1932 of file array3D.h.

template<class Type>

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Array2D< Type > &	array0
	)			[inline]

Outputs a text representation of an Array2D instance to a std::ostream.

The output format looks like this:

Array2D([[1, 2, 4, 8, 16], [5, 1, 6, 7, 2]])

Where the array elements are output using operator<<(std::ostream&, const Type&) and each element is separated from its neighbors by a comma and whitespace.

Parameters:

	stream	Reference to the the output stream.
	array0	Const reference to the Array2D to be output.

Returns:

Reference to output stream.

Definition at line 2070 of file array2D.h.

template<class Type>

std::ostream & dlr::numeric::operator<<	(	std::ostream &	stream,
		const Array1D< Type > &	array0
	)			[inline]

Outputs a text representation of an Array1D instance to a std::ostream.

The output format looks like this:

Array1D([1, 2, 4, 8, 16])

Where the array elements are output using operator<<(std::ostream&, const Type&) and each element is separated from its neighbors by a comma and whitespace.

Parameters:

	stream	Reference to the the output stream.
	array0	const Reference to the Array1D to be output.

Exceptions:

IOException

on invalid stream.

Returns:

Reference to output stream.

Definition at line 1634 of file array1D.h.

References DLR_THROW.

template<class Type>

Array3D< bool > dlr::numeric::operator<=	(	const Array3D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array3D with a constant.

Parameters:

	array0	Array3D instance.
	arg	Value to which array0 elements should be compared.

Returns:

Array3D<bool> in which each element has value "true" if the corresponding element of array0 is less than or equal to arg.

Definition at line 1920 of file array3D.h.

template<class Type>

Array2D< bool > dlr::numeric::operator<=	(	const Array2D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array2D with a constant.

Parameters:

	array0	An Array2D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array2D<bool> in which each element has value "true" if the corresponding element of array0 is less than or equal to arg.

Definition at line 2061 of file array2D.h.

template<class Type>

Array1D< bool > dlr::numeric::operator<=	(	const Array1D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array1D with a constant.

Parameters:

	array0	An Array1D instance.
	arg	Value to which array elements should be compared.

Returns:

An Array1D<bool> in which each element has value "true" if the corresponding element of array0 is less than or equal to arg.

Definition at line 1624 of file array1D.h.

bool dlr::numeric::operator==	(	const Vector3D &	vector0,
		const Vector3D &	vector1
	)

This operator checks the supplied vectors for equality.

Parameters:

	vector0	First vector to compare.
	vector1	Second vector to compare.

Returns:

Result of comparing vector0 to vector1 for equality.

Definition at line 86 of file vector3D.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

bool dlr::numeric::operator==	(	const Vector2D &	vector0,
		const Vector2D &	vector1
	)

This operator checks the supplied vectors for equality.

Parameters:

	vector0	First vector to compare.
	vector1	Second vector to compare.

Returns:

Result of comparing vector0 to vector1 for equality.

Definition at line 69 of file vector2D.cpp.

References dlr::numeric::Vector2D::x(), and dlr::numeric::Vector2D::y().

bool dlr::numeric::operator==	(	const Index2D &	index0,
		const Index2D &	index1
	)

This operator checks the supplied indexs for equality.

Parameters:

	index0	First Index2D instance to compare.
	index1	Second Index2D instance to compare.

Returns:

Result of comparing index0 to index1 for equality.

Definition at line 78 of file index2D.cpp.

References dlr::numeric::Index2D::getColumn(), and dlr::numeric::Index2D::getRow().

template<class Type>

Array3D< bool > dlr::numeric::operator==	(	const Array3D< Type > &	array0,
		const Array3D< Type > &	array1
	)			[inline]

Elementwise comparison of an Array3D with another array.

Parameters:

	array0	An Array3D instance.
	array1	A second Array3D instance with the same size as array0.

Returns:

An Array3D<bool> in which each element has value "true" if the corresponding element of array0 is equal to the corresponding element of array1.

Definition at line 1879 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::checkDimension(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array3D< bool > dlr::numeric::operator==	(	const Array3D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array3D with a constant.

Parameters:

	array0	An Array3D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array3D<bool> in which each element has value "true" if the corresponding element of array0 is equal to arg.

Definition at line 1867 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< bool > dlr::numeric::operator==	(	const Array2D< Type > &	array0,
		const Array2D< Type > &	array1
	)			[inline]

Elementwise comparison of an Array2D with another array.

Parameters:

	array0	An Array2D instance.
	array1	A second Array2D instance with the same size as array0.

Returns:

An Array2D<bool> in which each element has value "true" if the corresponding element of array0 is equal to the corresponding element of array1.

Definition at line 2023 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::checkDimension(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array2D< bool > dlr::numeric::operator==	(	const Array2D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array2D with a constant.

Parameters:

	array0	An Array2D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array2D<bool> in which each element has value "true" if the corresponding element of array0 is equal to arg.

Definition at line 2011 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< bool > dlr::numeric::operator==	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

Elementwise comparison of an Array1D with another array.

Parameters:

	array0	An Array1D instance.
	array1	A second Array1D instance with the same size as array0.

Returns:

An Array1D<bool> in which each element has value "true" if the corresponding element of array0 is equal to the corresponding element of array1.

Definition at line 1579 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::checkDimension(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array1D< bool > dlr::numeric::operator==	(	const Array1D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array1D with a constant.

Parameters:

	array0	An Array1D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array1D<bool> in which each element has value "true" if the corresponding element of array0 is equal to arg.

Definition at line 1567 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array3D< bool > dlr::numeric::operator>	(	const Array3D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array3D with a constant.

Parameters:

	array0	Array3D instance.
	arg	Value to which array0 elements should be compared.

Returns:

Array3D<bool> in which each element has value "true" if the corresponding element of array0 is greater than arg.

Definition at line 1890 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< bool > dlr::numeric::operator>	(	const Array2D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array2D with a constant.

Parameters:

	array0	An Array2D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array2D<bool> in which each element has value "true" if the corresponding element of array0 is greater than arg.

Definition at line 2034 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< bool > dlr::numeric::operator>	(	const Array1D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array1D with a constant.

Parameters:

	array0	An Array1D instance.
	arg	Value to which array elements should be compared.

Returns:

An Array1D<bool> in which each element has value "true" if the corresponding element of array0 is greater than arg.

Definition at line 1591 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array3D< bool > dlr::numeric::operator>=	(	const Array3D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array3D with a constant.

Parameters:

	array0	Array3D instance.
	arg	Value to which array0 elements should be compared.

Returns:

Array3D<bool> in which each element has value "true" if the corresponding element of array0 is greater than or equal to arg.

Definition at line 1910 of file array3D.h.

References dlr::numeric::Array3D< Type >::begin(), dlr::numeric::Array3D< Type >::end(), dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type>

Array2D< bool > dlr::numeric::operator>=	(	const Array2D< Type > &	array0,
		Type	arg
	)			[inline]

Elementwise comparison of Array2D with a constant.

Parameters:

	array0	An Array2D instance.
	arg	Value to which the elements of array0 should be compared.

Returns:

An Array2D<bool> in which each element has value "true" if the corresponding element of array0 is greater than or equal to arg.

Definition at line 2052 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

template<class Type>

Array1D< bool > dlr::numeric::operator>=	(	const Array1D< Type > &	array0,
		const Type	arg
	)			[inline]

Elementwise comparison of an Array1D with a constant.

Parameters:

	array0	An Array1D instance.
	arg	Value to which array elements should be compared.

Returns:

An Array1D<bool> in which each element has value "true" if the corresponding element of array0 is greater than or equal to arg.

Definition at line 1602 of file array1D.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Vector3D &	vector0
	)

This function sets the value of a Vector3D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Vector3D&) above.

Parameters:

	stream	This argument is a reference to the the input stream from which to read.
	vector0	This argument is a reference to the Vector3D which will take the input.

Returns:

The return value is a reference to the input stream after the read has taken place.

Definition at line 108 of file vector3D.cpp.

References dlr::numeric::Vector3D::setValue().

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Vector2D &	vector0
	)

This function sets the value of a Vector2D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Vector2D&) above.

Parameters:

	stream	This argument is a reference to the the input stream from which to read.
	vector0	This argument is a reference to the Vector2D which will take the input.

Returns:

The return value is a reference to the input stream after the read has taken place.

Definition at line 89 of file vector2D.cpp.

References dlr::numeric::Vector2D::setValue().

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Transform3D &	transform0
	)

Sets the value of a Transform3D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Transform3D&) above.

Parameters:

	stream	Reference to the the input stream.
	transform0	Reference to the Transform3D which will take the input.

Returns:

Reference to the input stream.

Definition at line 433 of file transform3D.cpp.

References dlr::numeric::Transform3D::setTransform().

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Transform2D &	transform0
	)

Sets the value of a Transform2D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Transform2D&) above.

Parameters:

	stream	Reference to the the input stream.
	transform0	Reference to the Transform2D which will take the input.

Returns:

Reference to the input stream.

Definition at line 306 of file transform2D.cpp.

References dlr::numeric::Transform2D::setTransform().

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Index2D &	index0
	)

This function sets the value of an Index2D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Index2D&) above.

Parameters:

	stream	This argument is a reference to the the input stream from which to read.
	index0	This argument is a reference to the Index2D which will take the input.

Returns:

The return value is a reference to the input stream after the read has taken place.

Definition at line 102 of file index2D.cpp.

References dlr::numeric::Index2D::setValue().

template<class Type>

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Array3D< Type > &	array0
	)			[inline]

This operator sets the value of an Array3D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Array3D<Type>&) above.

Parameters:

	stream	Reference to the the input stream.
	array0	Reference to the Array3D which will take the input.

Returns:

Reference to the input stream.

Definition at line 1973 of file array3D.h.

References dlr::numeric::Array3D< Type >::readFromStream().

template<class Type>

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Array2D< Type > &	array0
	)			[inline]

Sets the value of an Array2D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Array2D<Type>&) above.

Parameters:

	stream	Reference to the the input stream.
	array0	Reference to the Array2D which will take the input.

Returns:

Reference to input stream.

Definition at line 2095 of file array2D.h.

References dlr::numeric::Array2D< Type >::readFromStream().

template<class Type>

std::istream & dlr::numeric::operator>>	(	std::istream &	stream,
		Array1D< Type > &	array0
	)			[inline]

Sets the value of an Array1D instance from a std::istream.

The input format is as described for operator<<(std::ostream&, const Array1D<Type>&) above.

Parameters:

	stream	Reference to the the input stream.
	array0	Reference to the Array1D which will take the input.

Returns:

Reference to input stream.

Definition at line 1658 of file array1D.h.

References dlr::numeric::Array1D< Type >::readFromStream().

template<class Type0, class Type1, class Type2>

Array2D< Type2 > dlr::numeric::outerProduct	(	const Array1D< Type0 > &	array0,
		const Array1D< Type1 > &	array1,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes the outer product of two input Array1D instances and allows the user to control which type is used to do the calculation.

The computation is done using the ProductType specified by the appropriate NumericTraits class. The result is Array2D instance with values such that the element in the i-th column and j-th row has a value equal to the product of the i-th element of the second input argument and the j-th element of the first input argument.

Parameters:

	array0	A 1D array, the first argument of the outer product.
	array1	A 1D array, the second argument of the outer product.
	typeTag	The third argument is a type tag indicating which type is to be used to perform the computation.

Returns:

The outer product of the two arguments.

Definition at line 3139 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), dlr::numeric::Array1D< Type >::end(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

Array2D< typename NumericTraits< Type >::ProductType > dlr::numeric::outerProduct	(	const Array1D< Type > &	array0,
		const Array1D< Type > &	array1
	)			[inline]

This function computes the outer product of two input Array1D instances.

The computation is done using the ProductType specified by the appropriate NumericTraits class. The result is Array2D instance with values such that the element in the i-th column and j-th row has a value equal to the product of the i-th element of the second input argument and the j-th element of the first input argument.

Parameters:

	array0	A 1D array, the first argument of the outer product.
	array1	A 1D array, the second argument of the outer product.

Returns:

The outer product of the two arguments.

Definition at line 3128 of file dlrNumeric/utilities.h.

std::pair< double, Vector3D > dlr::numeric::quaternionToAngleAxis

(

const Quaternion &

quaternion

)

This function converts a rotation from Quaternion representation to Angle-Axis representation.

Parameters:

quaternion

This argument specifies the rotation using a Quaternion instance. If the Quaternion is not normalized, the normalization will be done inside the function. For further information, please see the rotations.h file comment.

Returns:

The return value is a pair which specifies the Angle-Axis representation of the input rotation. For further information, please see the rotations.h file comment.

Definition at line 77 of file rotations.cpp.

References dlr::numeric::Quaternion::i(), dlr::numeric::Quaternion::j(), dlr::numeric::Quaternion::k(), magnitude(), dlr::numeric::Quaternion::normalize(), and dlr::numeric::Quaternion::s().

Referenced by rollPitchYawToAngleAxis(), and transform3DToAngleAxis().

Vector3D dlr::numeric::quaternionToRollPitchYaw

(

const Quaternion &

quaternion

)

This function converts a rotation from Quaternion representation to Roll-Pitch-Yaw representation.

Parameters:

quaternion

This argument specifies the rotation using a Quaternion instance. If the Quaternion is not normalized, the normalization will be done inside the function. For further information, please see the rotations.h file comment.

Returns:

The return value is a Vector3D instance containing roll, pitch, and yaw. For further information, please see the rotations.h file comment.

Definition at line 99 of file rotations.cpp.

References quaternionToTransform3D(), and transform3DToRollPitchYaw().

Referenced by angleAxisToRollPitchYaw().

Transform3D dlr::numeric::quaternionToTransform3D

(

const Quaternion &

quaternion

)

This function converts a rotation from Quaternion representation to Transform3D representation.

Parameters:

quaternion

This argument specifies the rotation using a Quaternion instance. If the Quaternion is not normalized, the normalization will be done inside the function. For further information, please see the rotations.h file comment.

Returns:

The return value is a Transform3D instance representing the rotation. For further information, please see the rotations.h file comment.

Definition at line 108 of file rotations.cpp.

References dlr::numeric::Quaternion::i(), dlr::numeric::Quaternion::j(), dlr::numeric::Quaternion::k(), dlr::numeric::Quaternion::normalize(), and dlr::numeric::Quaternion::s().

Referenced by angleAxisToTransform3D(), quaternionToRollPitchYaw(), and dlr::computerVision::registerPoints3D().

template<class Type>

Array1D< Type > dlr::numeric::range	(	Type	start,
		Type	stop,
		Type	stride = 1
	)			[inline]

This function returns an Array1D in which the first element has value equal to argument "start," and each subsequent element has value equal to the previous element plus argument "stride." The length of the array is equal to largest integer less than the quantity ((stop - start) / stride).

It is an error for stride to have a different sign than (stop - start). The element type of the returned array is determined by the type of the arguments. For example,

range(2, 7, 1);

will return

Array1D([2, 3, 4, 5, 6]);

and

range(2.0, -3.0, -1.5);

will return

Array1D([2.0, 0.5, -1.0, -2.5, -4.0, -5.5]);

Parameters:

	start	This argument specifies the value of the first element of the returned Array1D instance.
	stop	This argument specifies an exclusive bound for the element values of the returned array. If stride is less than 0.0, then this will be an exclusive lower bound, else it will be an exclusive upper bound.
	stride	This argument specifies the increment which will be added to each subsequent element in the output array. It is an error for stride to be equal to 0.

Returns:

The return value is an Array1D instance having regularly spaced elements progressing from start toward stop.

Definition at line 3159 of file dlrNumeric/utilities.h.

References DLR_THROW3.

Referenced by columnIndices(), and dlr::random::PseudoRandom::uniform().

template<class Type>

const Array1D<Type> dlr::numeric::ravel

(

const Array2D< Type > &

inputArray

)

[inline]

This function takes a const Array2D argument and returns a const Array1D instance which references the same data.

It is equivalent to ravel(Array2D&), but for const arrays.

Parameters:

inputArray

This argument is the Array2D instance from which to take the data.

Returns:

An Array1D instance referencing the same data as the input Array2D instance.

Definition at line 1399 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::ravel().

template<class Type>

Array1D<Type> dlr::numeric::ravel

(

Array2D< Type > &

inputArray

)

[inline]

This function takes an Array2D argument and returns an Array1D instance which references the same data.

That is, changing an element of the Array1D instance will change the corresponding element of the input Array2D instance. The elements of the returned Array1D are in native storage order for the input array. Input arrays of type Array2D happen to have their elements in row-major order. Will this always be true? Hmm...

Parameters:

inputArray

This argument is the Array2D instance from which to take the data.

Returns:

An Array1D instance referencing the same data as the input Array2D instance.

Definition at line 1384 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::ravel().

template<class Type0, class Type1>

Type1 dlr::numeric::rms	(	const Array1D< Type0 > &	array0,
		type_tag< Type1 >	typeTag
	)			[inline]

This function computes the RMS (Root Mean Square) value of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.

The computation is performed using the type specified by the second argument to the rms() function call.

Parameters:

	array0	This argument is the input array, from which the RMS value will be computed.
	typeTag	This argument specifies the type which will be used to perform the computation, and also specifies the return type of the function.

Returns:

The return is the RMS value of the elements of array0.

Definition at line 3201 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::size(), and sqrt().

template<class Type>

Type dlr::numeric::rms

(

const Array1D< Type > &

array0

)

[inline]

This function computes the RMS (Root Mean Square) value of the elements of its argument.

The computation is performed using the precision specified by NumericTraits<Type>::ProductType, but is returned as an instance of Type.

Parameters:

array0

This argument is the input array, from which the RMS value will be computed.

Returns:

The return is the RMS value of the elements of array0.

Definition at line 3188 of file dlrNumeric/utilities.h.

std::pair< double, Vector3D > dlr::numeric::rollPitchYawToAngleAxis

(

const Vector3D &

rollPitchYaw

)

This function converts a rotation from Roll-Pitch-Yaw representation to Angle-Axis representation.

Parameters:

rollPitchYaw

This argument specifies the rotation using a Vector3D instance representing Roll, Pitch, and Yaw. For further information, please see the rotations.h file comment.

Returns:

The return value is a pair which specifies the Angle-Axis representation of the input rotation. For further information, please see the rotations.h file comment.

Definition at line 133 of file rotations.cpp.

References quaternionToAngleAxis(), and rollPitchYawToQuaternion().

Quaternion dlr::numeric::rollPitchYawToQuaternion

(

const Vector3D &

rollPitchYaw

)

This function converts a rotation from Roll-Pitch-Yaw representation to Quaternion representation.

Parameters:

rollPitchYaw

This argument specifies the rotation using a Vector3D instance representing Roll, Pitch, and Yaw. For further information, please see the rotations.h file comment.

Returns:

The return value is a unit quaternion representing the specified rotation. For further information, please see the rotations.h file comment.

Definition at line 141 of file rotations.cpp.

References rollPitchYawToTransform3D(), and transform3DToQuaternion().

Referenced by rollPitchYawToAngleAxis().

Transform3D dlr::numeric::rollPitchYawToTransform3D

(

const Vector3D &

rollPitchYaw

)

This function converts a rotation from Roll-Pitch-Yaw representation to Transform3D representation.

Parameters:

rollPitchYaw

This argument specifies the rotation using a Vector3D instance representing Roll, Pitch, and Yaw. For further information, please see the rotations.h file comment.

Returns:

The return value is a Transform3D instance representing the rotation. For further information, please see the rotations.h file comment.

Definition at line 149 of file rotations.cpp.

References dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Referenced by rollPitchYawToQuaternion().

template<class Type>

Array2D< Type > dlr::numeric::rowIndices	(	size_t	rows,
		size_t	columns,
		type_tag< Type >	typeTag
	)			[inline]

rowIndices(rows, columns): Returns an Array2D in which each element contains the index of its row.

The element type of the returned array depends on the type_tag argument. For example:

rowIndices(2, 3, type_tag<int>());

will return:

Array2D<int>([[0, 0, 0], [1, 1, 1]]);

Parameters:

	rows	This argument specifies the number of rows in the returned array.
	columns	This argument specifies the number of columns in the returned array.
	typeTag	This argument specifies the element type of the returned array.

Returns:

The return value is an Array2D of the specified size and type in which all elements in the first row have value initialized to 0, all elements in the second row have value initialized to 1, and so on.

Definition at line 3215 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::data().

template<class Type0, class Type1>

bool dlr::numeric::shapeMatch	(	const Array3D< Type0 > &	array0,
		const Array3D< Type1 > &	array1
	)			[inline]

This function returns true if the two arrays have the same shape, false otherwise.

Two arrays are considered to have the same shape if their sizes are equal along each axis.

Parameters:

	array0	This argument is the first of the two arrays to be compared.
	array1	This argument is the second of the two arrays to be compared.

Returns:

The return value is true if the two arrays have matching shape, false otherwise.

Definition at line 3248 of file dlrNumeric/utilities.h.

References dlr::numeric::Array3D< Type >::shape0(), dlr::numeric::Array3D< Type >::shape1(), and dlr::numeric::Array3D< Type >::shape2().

template<class Type0, class Type1>

bool dlr::numeric::shapeMatch	(	const Array2D< Type0 > &	array0,
		const Array2D< Type1 > &	array1
	)			[inline]

This function returns true if the two arrays have the same shape, false otherwise.

Two arrays are considered to have the same shape if their sizes are equal along each axis.

Parameters:

	array0	This argument is the first of the two arrays to be compared.
	array1	This argument is the second of the two arrays to be compared.

Returns:

The return value is true if the two arrays have matching shape, false otherwise.

Definition at line 3238 of file dlrNumeric/utilities.h.

References dlr::numeric::Array2D< Type >::columns(), and dlr::numeric::Array2D< Type >::rows().

template<class Type0, class Type1>

bool dlr::numeric::shapeMatch	(	const Array1D< Type0 > &	array0,
		const Array1D< Type1 > &	array1
	)			[inline]

This function returns true if the two arrays have the same shape, false otherwise.

Two arrays are considered to have the same shape if their sizes are equal along each axis.

Parameters:

	array0	This argument is the first of the two arrays to be compared.
	array1	This argument is the second of the two arrays to be compared.

Returns:

The return value is true if the two arrays have matching shape, false otherwise.

Definition at line 3229 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::size().

template<class Type>

Array2D< Type > dlr::numeric::skewSymmetric

(

const Array1D< Type > &

vector0

)

[inline]

skewSymmetric(x): Returns a skew symmetric matrix X such that matrixMultiply(X, y) = cross(x, y)

Parameters:

vector0

An Array1D instance, which must have exactly 3 elements.

Returns:

An Array2D instance as described above.

Definition at line 3259 of file dlrNumeric/utilities.h.

References DLR_THROW, and dlr::numeric::Array1D< Type >::size().

template<class Type>

void dlr::numeric::solveQuadratic	(	Type	c0,
		Type	c1,
		Type	c2,
		Type &	root0,
		Type &	root1,
		bool &	valid,
		bool	checkValidity = true
	)			[inline]

This function computes the real roots of the quadratic polynomial c0*x^2 + c1*x + c0 = 0.

If c0, c1, and c2 are arrays, then the returned roots will be arrays of the same dimension, and will contain the roots of an array of scalar quadratic equations.

Note that the two well known versions of the quadratic formula:

x = (-c1 +|- sqrt(c1**2 - 4c0*c2)) / (2*c0)

and

x = 2*c2 / (-c1 +|- sqrt(c1**2 - 4*c0*c2))

both tend to be inaccurate when a and/or c are small, since then the quantity (-c1 +|- sqrt(c1**2 - 4*c0*c2)) gets very small and loses significance. Instead we use the form advocated by Press and Flannery (Numerical Recipes):

q = -(1/2)(c1 + sgn(c1)*sqrt(c1**2 - 4*c1*c2)) x1 = q/c0, x2 = c2/q

This is just the same as using both of the first two forms, each one for the root at which it is most numerically stable.

If checkValidity is set to zero, valid will always be set to (scalar) one, and no attempt will be made to detect whether quadratics have real roots. This will make your code run faster, but could cause problems if your quadratics don't always have real roots.

Parameters:

	c0	This argument is the quadratic coefficient of the polynomial.
	c1	This argument is the linear coefficient of the polynomial.
	c2	This argument is the constant coefficient of the polynomial.
	root0	If the polynomial has real roots, this reference argument is used to return the first root.
	root1	If the polynomial has real roots, this reference argument is used to return the second root.
	valid	If the polynomial has real roots, this reference argument is set to true. If the polynomial does not have real roots, this polynomial is set to false.
	checkValidity	The first thing solveQuadratic does is check to see if the polynomial has real roots. By setting checkValidity to false, the user can disable this check. It makes sense to do this only if the polynomial is already known to have real roots, and execution time is at a premium.

Definition at line 3287 of file dlrNumeric/utilities.h.

References sqrt().

template<class Type>

Array2D< Type > dlr::numeric::sqrt

(

const Array2D< Type > &

array0

)

[inline]

This function returns an array which is the same size as its argument, and in which the value of each element is the square root of the corresponding element of the argument.

It is really just an alias for the function squareRoot(), below.

Parameters:

array0

The square root calculation will be performed for each element of this array.

Returns:

An array of square root values.

Definition at line 1869 of file array2D.h.

References squareRoot().

Referenced by dlr::computerVision::applyCanny(), bilaterate(), dlr::optimization::OptimizerBFGS< Functor >::doBfgs(), dlr::computerVision::getEuclideanDistance(), magnitude(), dlr::numeric::Quaternion::normalize(), normalizedCorrelation(), dlr::numeric::SquareRootFunctor< Type >::operator()(), dlr::computerVision::ColorspaceConverter< FORMAT0, FORMAT1 >::operator()(), rms(), dlr::optimization::OptimizerLineSearch< Functor >::run(), dlr::optimization::OptimizerLineSearch< Functor >::setInitialStep(), solveQuadratic(), standardDeviation(), transform3DToQuaternion(), and transform3DToRollPitchYaw().

template<class Type>

Array2D< Type > dlr::numeric::squareRoot

(

const Array2D< Type > &

array0

)

[inline]

This function returns an array which is the same size as its argument, and in which the value of each element is the square root of the corresponding element of the argument.

Parameters:

array0

The square root calculation will be performed for each element of this array.

Returns:

An array of square root values.

Definition at line 1879 of file array2D.h.

References dlr::numeric::Array2D< Type >::begin(), dlr::numeric::Array2D< Type >::columns(), dlr::numeric::Array2D< Type >::end(), and dlr::numeric::Array2D< Type >::rows().

Referenced by sqrt().

template<class Type0, class Type1>

Type1 dlr::numeric::standardDeviation	(	const Array1D< Type0 > &	array0,
		type_tag< Type1 >	typeTag
	)			[inline]

This function computes the standard deviation of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.

The computation is performed using the type specified by the second argument to the standardDeviation() function call. This routine eventually calls the function mean(const Array1D&, ...). This is a little inefficient, since you are probably already calling mean(...). If this redundant computation is not OK, then we should add a class called "SignalMoments" (or something similar) which will compute both mean and standard deviation without any wasted cycles. Perhaps by the time you read this, such a class will have already been implemented.

Parameters:

	array0	This argument is the input array, from the elements of which the standard deviation will be computed.
	typeTag	This argument specifies the type which will be used to perform the computation, and also specifies the return type of the function.

Returns:

The return value is the mean of the elements of array0.

Definition at line 3328 of file dlrNumeric/utilities.h.

References sqrt(), and variance().

template<class Type>

double dlr::numeric::standardDeviation

(

const Array1D< Type > &

array0

)

[inline]

This function computes the standard deviation of a group of scalar samples.

Computation is done using double precision floats, and the result is returned as a double. This routine eventually calls the function mean(const Array1D&). This is a little inefficient, since you are probably already calling mean(...). If this redundant computation is not OK, then we should a add class called "SignalMoments" (or something similar) will compute both mean and standard deviation without any wasted cycles. Perhaps by the time you read this, such a class will have already been implemented.

Parameters:

array0

This argument is the input array, from the elements of which the standard deviation will be computed.

Returns:

The return value is the mean of the elements of array0.

Definition at line 3318 of file dlrNumeric/utilities.h.

template<class Type>

SubArray2D<Type> dlr::numeric::subArray	(	const Array2D< Type > &	source,
		const Slice &	rowSlice,
		int	column
	)			[inline]

This function is just like subArray(const Array2D<Type>&, const Slice&, const Slice&), above except that it constructs a SubArray2D instance which references only selected elements _of a particular column_ in the source array.

For example, you might use the following to copy the 3 elements at the intersections of rows [0, 2, 4] and column 2 of array1 into the elements at the intersections of rows [2, 4, 6] and column 6 array0:

subArray(array0, Slice(2, 8, 2), 6) = subArray(array1, Slice(0, 6, 2), 2);

Parameters:

	source	This argument specifies the Array2D into which to index.
	rowSlice	A slice instance indicating the target rows.
	column	An index indicating the target column.

Returns:

A SubArray2D instance referencing the elements of the source array which lie at the intersections of the selected rows and the target column.

Definition at line 358 of file subArray2D.h.

Referenced by dlr::geometry::Plane3D::Plane3D().

template<class Type>

SubArray2D<Type> dlr::numeric::subArray	(	const Array2D< Type > &	source,
		const int	row,
		const Slice &	columnSlice
	)			[inline]

This function is just like subArray(const Array2D<Type>&, const Slice&, const Slice&), above except that it constructs a SubArray2D instance which references only selected elements _of a particular row_ in the source array.

For example, you might use the following to copy the 3 elements at the intersections of row 2 and columns [1, 2, 3] of array1 into the elements at the intersections of rows 4 and columns [3, 6, 9] of array0:

subArray(array0, 6, Slice(3, 12, 3) = subArray(array1, 2, Slice(1, 4));

Parameters:

	source	This argument specifies the Array2D into which to index.
	row	An index indicating the target row.
	columnSlice	A slice instance indicating the target columns.

Returns:

A SubArray2D instance referencing the elements of the source array which lie at the intersections of the target row and the selected columns.

Definition at line 330 of file subArray2D.h.

template<class Type>

SubArray2D<Type> dlr::numeric::subArray	(	const Array2D< Type > &	source,
		const Slice &	rowSlice,
		const Slice &	columnSlice
	)			[inline]

This is a convenience function for constructing SubArray2D instances which reference only selected elements of the source array.

Use this function when you want to modify only some of the elements of an Array2D instance. For example, you might use the following to copy the 9 elements at the intersections of rows [0, 2, 4] and columns [1, 2, 3] of array1 into the elements at the intersections of rows [2, 4, 6] and columns [3, 6, 9] of array0:

subArray(array0, Slice(2, 8, 2), Slice(3, 12, 3) = subArray(array1, Slice(0, 6, 2), Slice(1, 4));

Parameters:

	source	This argument specifies the Array2D into which to index.
	rowSlice	A slice instance indicating the target rows.
	columnSlice	A slice instance indicating the target columns.

Returns:

A SubArray2D instance referencing the elements of the source array which lie at the intersections of the selected rows and columns.

Definition at line 302 of file subArray2D.h.

template<class Type>

SubArray2D<Type> dlr::numeric::subArray

(

const Array2D< Type > &

source

)

[inline]

This is a convenience function for constructing SubArray2D instances which reference every element of the source array.

Use this function when you want to modify every element of an Array2D instance. For example, you might use the following to copy the 9 elements at the intersections of rows [0, 2, 4] and columns [1, 2, 3] of array1 into an appropriately sized array0:

subArray(array0) = subArray(array1, Slice(0, 6, 2), Slice(1, 4));

Parameters:

source

This argument specifies the Array2D into which to index.

Returns:

A SubArray2D instance referencing every element of the source array.

Definition at line 277 of file subArray2D.h.

template<class Type>

SubArray1D<Type> dlr::numeric::subArray	(	const Array1D< Type > &	source,
		const Slice &	rowSlice
	)			[inline]

This is a convenience function for constructing SubArray1D instances which reference only selected elements of the source array.

Use this function when you want to modify only some of the elements of an Array1D instance. For example, you might use the following to copy the first, sixth, eleventh, and sixteenth elements of array1 into the second, sixth, tenth, and fourteenth elements of array0:

subArray(array0, Slice(1, 15, 4)) = subArray(array1, Slice(0, 16, 5));

Parameters:

	source	This argument specifies the Array1D into which to index.
	rowSlice	A slice instance indicating the target elements.

Returns:

A SubArray1D instance referencing the selected elements of the source array.

Definition at line 264 of file subArray1D.h.

template<class Type>

SubArray1D<Type> dlr::numeric::subArray

(

const Array1D< Type > &

source

)

[inline]

This is a convenience function for constructing SubArray1D instances which reference every element of the source array.

Use this function when you want to modify every element of an Array1D instance.

Parameters:

source

This argument specifies the Array1D into which to index.

Returns:

A SubArray1D instance referencing every element of the source array.

Definition at line 240 of file subArray1D.h.

Referenced by dlr::numeric::SubArray1D< Type >::operator Array1D(), dlr::numeric::SubArray2D< Type >::operator Array2D(), and operator<<().

template<class Type, class Type2>

Type2 dlr::numeric::sum	(	const Array2D< Type > &	array0,
		const Index2D &	upperLeftCorner,
		const Index2D &	lowerRightCorner,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes the sum of those elements of its argument which lie within a rectangular region of interest.

The summation is accumulated into a variable of type Type2, allowing the user to control the precision of the internal summation.

Parameters:

	array0	This argument is the array to be summed.
	upperLeftCorner	This argument specifies the upper left corner of the rectangular region to be summed. The summed region will include the array element corresponding to upperLeftCorner.
	lowerRightCorner	This argument specifies the lower right corner of the rectangular region to be summed. The summed region will stop one row/column short of lowerRightCorner.
	typeTag	This is a type_tag instance which specifies the return type.

Returns:

The summation of all the elements in the region of interest.

Definition at line 3372 of file dlrNumeric/utilities.h.

References dlr::numeric::Index2D::getColumn(), dlr::numeric::Index2D::getRow(), and dlr::numeric::Array2D< Type >::rowBegin().

Referenced by dlr::computerVision::OpticalFlow< Format >::getFlow(), and dlr::linearAlgebra::linearFit().

template<class Type>

NumericTraits< Type >::SumType dlr::numeric::sum	(	const Array2D< Type > &	array0,
		const Index2D &	upperLeftCorner,
		const Index2D &	lowerRightCorner
	)			[inline]

This function computes the sum of those elements of its argument which lie within a rectangular region of interest.

The summation is accumulated into a variable of type NumericTraits<Type>::SumType.

Parameters:

	array0	This argument is the array to be summed.
	upperLeftCorner	This argument specifies the upper left corner of the rectangular region to be summed. The summed region will include the array element corresponding to upperLeftCorner.
	lowerRightCorner	This argument specifies the lower right corner of the rectangular region to be summed. The summed region will stop one row/column short of lowerRightCorner.

Returns:

The summation of all the elements in the region of interest.

Definition at line 3359 of file dlrNumeric/utilities.h.

References sum().

template<class Type, class Type2>

Type2 dlr::numeric::sum	(	const Array1D< Type > &	array0,
		type_tag< Type2 >	typeTag
	)			[inline]

This function computes the sum of the elements of its argument.

The summation is accumulated into a variable of type Type2, allowing the user to control the precision of the internal summation.

Parameters:

	array0	This argument is the array to be summed.
	typeTag	This is a type_tag instance which specifies the return type.

Returns:

The summation of all the elements of array0.

Definition at line 3348 of file dlrNumeric/utilities.h.

References dlr::numeric::Array1D< Type >::begin(), and dlr::numeric::Array1D< Type >::end().

template<class Type>

NumericTraits< Type >::SumType dlr::numeric::sum

(

const Array1D< Type > &

array0

)

[inline]

This function computes the sum of the elements of its argument.

The summation is accumulated into a variable of type NumericTraits<Type>::SumType.

Parameters:

array0

This argument is the array to be summed.

Returns:

The summation of all the elements of array0.

Definition at line 3338 of file dlrNumeric/utilities.h.

Referenced by getGaussian1D(), mean(), normalizedCorrelation(), and sum().

std::pair< double, Vector3D > dlr::numeric::transform3DToAngleAxis

(

const Transform3D &

transform3D

)

This function converts a rotation from Transform3D representation to Angle-Axis representation.

Parameters:

transform3D

This argument specifies the rotation using a Transform3D instance. For further information, please see the rotations.h file comment.

Returns:

The return value is a pair which specifies the Angle-Axis representation of the input rotation. For further information, please see the rotations.h file comment.

Definition at line 181 of file rotations.cpp.

References quaternionToAngleAxis(), and transform3DToQuaternion().

Quaternion dlr::numeric::transform3DToQuaternion

(

const Transform3D &

transform3D

)

This function converts a rotation from Transform3D representation to Quaternion representation.

This routine draws from _On Homogeneous Transforms, Quaternions, and Computation Efficiency_, by Funda, Taylor, and Paul, IEEE R&A, June 1990.

Parameters:

transform3D

This argument specifies the rotation using a Transform3D instance. For further information, please see the rotations.h file comment.

Returns:

The return value is a unit quaternion representing the specified rotation. For further information, please see the rotations.h file comment.

Definition at line 192 of file rotations.cpp.

References dlr::common::approximatelyEqual(), dot(), sqrt(), dlr::numeric::Transform3D::value(), dlr::numeric::Vector3D::x(), dlr::numeric::Vector3D::y(), and dlr::numeric::Vector3D::z().

Referenced by rollPitchYawToQuaternion(), and transform3DToAngleAxis().

Vector3D dlr::numeric::transform3DToRollPitchYaw

(

const Transform3D &

transform3D

)

This function converts a rotation from Transform3D representation to Roll-Pitch-Yaw representation.

Parameters:

transform3D

This argument specifies the rotation using a Transform3D instance. For further information, please see the rotations.h file comment.

Returns:

The return value is a Vector3D instance containing roll, pitch, and yaw. For further information, please see the rotations.h file comment.

Definition at line 283 of file rotations.cpp.

References dlr::common::approximatelyEqual(), sqrt(), and dlr::numeric::Transform3D::value().

Referenced by quaternionToRollPitchYaw().

template<class Type0, class Type1>

Type1 dlr::numeric::variance	(	const Array1D< Type0 > &	array0,
		type_tag< Type1 >	typeTag
	)			[inline]

This function computes the variance, of the elements of its argument, and allows the user to specify the precision with which the computation is carried out.

The computation is performed using the type specified by the second argument to the variance() function call. This routine eventually calls the function mean(const Array1D&, ...). This is a little inefficient, since you are probably already calling mean(...). If this redundant computation is not OK, then we should add a class called "SignalMoments" (or something similar) which will compute both mean and variance without any wasted cycles. Perhaps by the time you read this, such a class will have already been implemented.

Parameters:

	array0	This argument is the input array, from the elements of which the variance will be computed.
	typeTag	This argument specifies the type which will be used to perform the computation, and also specifies the return type of the function.

Returns:

The return value is the mean of the elements of array0.

Definition at line 3405 of file dlrNumeric/utilities.h.

References mean(), and dlr::numeric::Array1D< Type >::size().

template<class Type>

double dlr::numeric::variance

(

const Array1D< Type > &

array0

)

[inline]

This function computes the variance of a group of scalar samples.

Computation is done using double precision floats, and the result is returned as a double. This routine eventually calls the function mean(const Array1D&). This is a little inefficient, since you are probably already calling mean(...). If this redundant computation is not OK, then we should add a class called "SignalMoments" (or something similar) which will compute both mean and variance without any wasted cycles. Perhaps by the time you read this, such a class will have already been implemented.

Parameters:

array0

This argument is the input array, from the elements of which the variance will be computed.

Returns:

The return value is the variance of the elements of array0.

Definition at line 3395 of file dlrNumeric/utilities.h.

Referenced by standardDeviation().

template<class Type>

Array3D< Type > dlr::numeric::zeros	(	size_t	shape0,
		size_t	shape1,
		size_t	shape2,
		type_tag< Type >	typeTag
	)			[inline]

This function returns an Array3D of the specified size and type in which the value of every element is zero.

Parameters:

	shape0	This argument specifies the number of slices in the returned array.
	shape1	This argument specifies the number of rows in the returned array.
	shape2	This argument specifies the number of columns in the returned array.
	typeTag	This is a type_tag instance which specifies the element type of the returned array.

Returns:

An Array3D instance in which each element is set to zero.

Definition at line 3443 of file dlrNumeric/utilities.h.

Referenced by dlr::optimization::OptimizerLM< Functor >::run().

template<class Type>

Array2D< Type > dlr::numeric::zeros	(	size_t	rows,
		size_t	columns,
		type_tag< Type >	typeTag
	)			[inline]

This function returns an Array2D of the specified size and type in which the value of every element is zero.

Parameters:

	rows	This argument specifies the number of rows in the returned array.
	columns	This argument specifies the number of columns in the returned array.
	typeTag	This is a type_tag instance which specifies the element type of the returned array.

Returns:

An Array2D instance in which each element is set to zero.

Definition at line 3431 of file dlrNumeric/utilities.h.

template<class Type>

Array1D< Type > dlr::numeric::zeros	(	size_t	size,
		type_tag< Type >	typeTag
	)			[inline]

This function returns an Array1D of the specified size and type in which the value of every element is zero.

Parameters:

	size	This argument specifies the number of elements in the returned array.
	typeTag	This is a type_tag instance which specifies the element type of the returned array.

Returns:

An Array1D instance in which each element is set to zero.

Definition at line 3420 of file dlrNumeric/utilities.h.

Referenced by equivalentMatrix(), identity(), and matrixMultiply().

---