omArrayMath.h File Reference

#include "omMathConfig.h"
#include "omScalarMath.h"
#include "omComplex.h"
#include "omVector2D.h"
#include "omVector3D.h"
#include "omVector4D.h"
#include "omMatrix2D.h"
#include "omMatrix3D.h"
#include "omMatrix4D.h"

Namespaces
	om
	The enclosing namespace for the entire Om library.
	om::math
	A namespace containing classes and functions that do fast math operations.

Functions
template<typename T >
T	om::math::sum (const T *array, Size number)
	Compute and return the sum of all of the values in the specified array. More...
template<>
Float32	om::math::sum (const Float32 *array, Size number)
template<>
Float64	om::math::sum (const Float64 *array, Size number)
template<typename T >
void	om::math::add (T *destination, const T &scalar, Size number)
	Add a scalar value to each entry in the destination array, storing the result. More...
template<>
void	om::math::add (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::add (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::add (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::add (Float64 *destination, const Float64 &scalar, Size number)
template<typename T >
void	om::math::add (Complex< T > *destination, T scalar, Size number)
template<typename T , Size size>
void	om::math::add (VectorND< T, size > *destination, T scalar, Size number)
template<typename T , Size size0, Size size1>
void	om::math::add (MatrixND< T, size0, size1 > *destination, T scalar, Size number)
template<typename T >
void	om::math::add (T *destination, const T *b, Size number)
	Add each entry of the second array to each entry in the destination array, storing the result. More...
template<>
void	om::math::add (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::add (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::add (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::add (Float64 *destination, const Float64 *b, Size number)
template<typename T >
void	om::math::add (Complex< T > *destination, const Complex< T > *b, Size number)
template<typename T , Size size>
void	om::math::add (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T , Size size0, Size size1>
void	om::math::add (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *b, Size number)
template<typename T >
void	om::math::add (T *destination, const T *a, const T *b, Size number)
	Add the entries of two arrays and store the result in the destination array. More...
template<>
void	om::math::add (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::add (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::add (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::add (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<typename T >
void	om::math::add (Complex< T > *destination, const Complex< T > *a, const Complex< T > *b, Size number)
template<typename T , Size size>
void	om::math::add (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T , Size size0, Size size1>
void	om::math::add (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *a, const MatrixND< T, size0, size1 > *b, Size number)
template<typename T >
void	om::math::add (T *destination, const T *a, const T &scalar, Size number)
	Add a scalar value to each entry in the destination array, storing the result. More...
template<>
void	om::math::add (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::add (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::add (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::add (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T >
void	om::math::add (Complex< T > *destination, const Complex< T > *a, T scalar, Size number)
template<typename T , Size size>
void	om::math::add (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T , Size size0, Size size1>
void	om::math::add (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *a, T scalar, Size number)
template<typename T >
void	om::math::negate (T *destination, Size number)
	Negate each element in the specified array, storing the result in the same array. More...
template<>
void	om::math::negate (Int32 *destination, Size number)
template<>
void	om::math::negate (Int64 *destination, Size number)
template<>
void	om::math::negate (Float32 *destination, Size number)
template<>
void	om::math::negate (Float64 *destination, Size number)
template<typename T >
void	om::math::negate (Complex< T > *destination, Size number)
template<typename T , Size size>
void	om::math::negate (VectorND< T, size > *destination, Size number)
template<typename T , Size size0, Size size1>
void	om::math::negate (MatrixND< T, size0, size1 > *destination, Size number)
template<typename T >
void	om::math::negate (T *destination, const T *a, Size number)
	Negate each element in an array, storing the result in a destination array. More...
template<>
void	om::math::negate (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::negate (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::negate (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::negate (Float64 *destination, const Float64 *b, Size number)
template<typename T >
void	om::math::negate (Complex< T > *destination, const Complex< T > *b, Size number)
template<typename T , Size size>
void	om::math::negate (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T , Size size0, Size size1>
void	om::math::negate (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *b, Size number)
template<typename T >
void	om::math::subtract (T *destination, const T &scalar, Size number)
	Subtract a scalar from each element of the destination array, storing the result in the destination. More...
template<>
void	om::math::subtract (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::subtract (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::subtract (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::subtract (Float64 *destination, const Float64 &scalar, Size number)
template<typename T >
void	om::math::subtract (Complex< T > *destination, T scalar, Size number)
template<typename T , Size size>
void	om::math::subtract (VectorND< T, size > *destination, T scalar, Size number)
template<typename T , Size size0, Size size1>
void	om::math::subtract (MatrixND< T, size0, size1 > *destination, T scalar, Size number)
template<typename T >
void	om::math::subtract (T *destination, const T *b, Size number)
	Subtract each entry of the second array from the destination array and store the result in the destination. More...
template<>
void	om::math::subtract (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::subtract (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::subtract (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::subtract (Float64 *destination, const Float64 *b, Size number)
template<typename T >
void	om::math::subtract (Complex< T > *destination, const Complex< T > *b, Size number)
template<typename T , Size size>
void	om::math::subtract (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T , Size size0, Size size1>
void	om::math::subtract (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *b, Size number)
template<typename T >
void	om::math::subtract (T *destination, const T *a, const T *b, Size number)
	Subtract an array from another and store the result in the destination array. More...
template<>
void	om::math::subtract (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::subtract (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::subtract (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::subtract (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<typename T >
void	om::math::subtract (Complex< T > *destination, const Complex< T > *a, const Complex< T > *b, Size number)
template<typename T , Size size>
void	om::math::subtract (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T , Size size0, Size size1>
void	om::math::subtract (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *a, const MatrixND< T, size0, size1 > *b, Size number)
template<typename T >
void	om::math::subtract (T *destination, const T *a, const T &scalar, Size number)
	Subtract a scalar from an array and store the result in the destination array. More...
template<>
void	om::math::subtract (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::subtract (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::subtract (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::subtract (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T >
void	om::math::subtract (Complex< T > *destination, const Complex< T > *a, T scalar, Size number)
template<typename T , Size size>
void	om::math::subtract (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T , Size size0, Size size1>
void	om::math::subtract (MatrixND< T, size0, size1 > *destination, const MatrixND< T, size0, size1 > *a, T scalar, Size number)
template<typename T >
T	om::math::product (const T *array, Size number)
	Compute and return the product of all of the values in the specified array. More...
template<>
Float32	om::math::product (const Float32 *array, Size number)
template<>
Float64	om::math::product (const Float64 *array, Size number)
template<typename T >
T	om::math::norm (const T *array, Size number)
	Compute and return the euclidean norm (length) of the specified vector. More...
template<>
Float32	om::math::norm (const Float32 *array, Size number)
template<>
Float64	om::math::norm (const Float64 *array, Size number)
template<typename T >
T	om::math::dot (const T *a, const T *b, Size number)
	Compute and return the dot product of the values in the two given arrays. More...
template<>
Float32	om::math::dot (const Float32 *a, const Float32 *b, Size number)
template<>
Float64	om::math::dot (const Float64 *a, const Float64 *b, Size number)
template<typename T >
void	om::math::multiply (T *destination, const T &scalar, Size number)
	Multiply each entry in the destination array by a scalar and store the result in the destination. More...
template<>
void	om::math::multiply (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::multiply (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::multiply (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::multiply (Float64 *destination, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::multiply (VectorND< T, size > *destination, T scalar, Size number)
template<typename T >
void	om::math::multiply (T *destination, const T *b, Size number)
	Multiply each entry in the destination array by another array entry and store the result in the destination. More...
template<>
void	om::math::multiply (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::multiply (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::multiply (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::multiply (Float64 *destination, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::multiply (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::multiply (T *destination, const T *a, const T *b, Size number)
	Multiply the elements in two arrays and store the result of each multiplication in the destination. More...
template<>
void	om::math::multiply (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::multiply (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::multiply (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::multiply (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<>
void	om::math::multiply (Complex< Float32 > *destination, const Complex< Float32 > *a, const Complex< Float32 > *b, Size number)
template<typename T , Size size>
void	om::math::multiply (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::multiply (T *destination, const T *a, const T &scalar, Size number)
	Multiply the elements in an array by a scalar and store the result in the destination array. More...
template<>
void	om::math::multiply (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::multiply (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::multiply (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::multiply (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::multiply (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T >
void	om::math::multiplyAdd (T *destination, const T &scalar, Size number)
	Multiply each entry in the destination by a scalar, then add the result to the destination array entry. More...
template<>
void	om::math::multiplyAdd (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::multiplyAdd (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::multiplyAdd (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::multiplyAdd (Float64 *destination, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::multiplyAdd (VectorND< T, size > *destination, T scalar, Size number)
template<typename T >
void	om::math::multiplyAdd (T *destination, const T *b, Size number)
	Multiply each entry in the destination by another array, then add the result to the destination entry. More...
template<>
void	om::math::multiplyAdd (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::multiplyAdd (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::multiplyAdd (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::multiplyAdd (Float64 *destination, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::multiplyAdd (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::multiplyAdd (T *destination, const T *a, const T *b, Size number)
	Multiply the enties of two arrays and add the results to the destination array entries. More...
template<>
void	om::math::multiplyAdd (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::multiplyAdd (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::multiplyAdd (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::multiplyAdd (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<>
void	om::math::multiplyAdd (Complex< Float32 > *destination, const Complex< Float32 > *a, const Complex< Float32 > *b, Size number)
template<typename T , Size size>
void	om::math::multiplyAdd (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::multiplyAdd (T *destination, const T *a, const T &scalar, Size number)
	Multiply the entries of an array by a scalar, then add the result to a destination array. More...
template<>
void	om::math::multiplyAdd (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::multiplyAdd (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::multiplyAdd (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::multiplyAdd (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::multiplyAdd (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T >
void	om::math::multiplySubtract (T *destination, const T &scalar, Size number)
	Multiply each entry in the destination by a scalar, then subtract the result from the destination array entry. More...
template<>
void	om::math::multiplySubtract (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::multiplySubtract (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::multiplySubtract (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::multiplySubtract (Float64 *destination, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::multiplySubtract (VectorND< T, size > *destination, T scalar, Size number)
template<typename T >
void	om::math::multiplySubtract (T *destination, const T *b, Size number)
	Multiply each entry in the destination by another array, then subtract the result from the destination entry. More...
template<>
void	om::math::multiplySubtract (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::multiplySubtract (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::multiplySubtract (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::multiplySubtract (Float64 *destination, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::multiplySubtract (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::multiplySubtract (T *destination, const T *a, const T *b, Size number)
	Multiply the enties of two arrays and subtract the results from the destination array entries. More...
template<>
void	om::math::multiplySubtract (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::multiplySubtract (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::multiplySubtract (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::multiplySubtract (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::multiplySubtract (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::multiplySubtract (T *destination, const T *a, const T &scalar, Size number)
	Multiply the entries of an array by a scalar, then subtract the result from a destination array. More...
template<>
void	om::math::multiplySubtract (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::multiplySubtract (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::multiplySubtract (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::multiplySubtract (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::multiplySubtract (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T >
void	om::math::divide (T *destination, const T &scalar, Size number)
	Divide each entry in the destination array by a scalar and store the result in the destination. More...
template<>
void	om::math::divide (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::divide (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::divide (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::divide (Float64 *destination, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::divide (VectorND< T, size > *destination, T scalar, Size number)
template<typename T >
void	om::math::divide (T *destination, const T *b, Size number)
	Divide each entry in the destination array by another array entry and store the result in the destination. More...
template<>
void	om::math::divide (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::divide (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::divide (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::divide (Float64 *destination, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::divide (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::divide (T *destination, const T *a, const T *b, Size number)
	Divide the elements of one array by those in another and store the result in the destination. More...
template<>
void	om::math::divide (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::divide (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::divide (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::divide (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::divide (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::divide (T *destination, const T *a, const T &scalar, Size number)
	Divide the elements in an array by a scalar and store the result in the destination array. More...
template<>
void	om::math::divide (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::divide (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::divide (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::divide (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::divide (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T >
void	om::math::divideAdd (T *destination, const T &scalar, Size number)
	Divide each entry in the destination by a scalar, then add the result to the destination array entry. More...
template<>
void	om::math::divideAdd (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::divideAdd (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::divideAdd (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::divideAdd (Float64 *destination, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::divideAdd (VectorND< T, size > *destination, T scalar, Size number)
template<typename T >
void	om::math::divideAdd (T *destination, const T *b, Size number)
	Divide each entry in the destination by another array, then add the result to the destination entry. More...
template<>
void	om::math::divideAdd (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::divideAdd (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::divideAdd (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::divideAdd (Float64 *destination, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::divideAdd (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::divideAdd (T *destination, const T *a, const T *b, Size number)
	Divide the enties of one array by another and add the results to the destination array entries. More...
template<>
void	om::math::divideAdd (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::divideAdd (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::divideAdd (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::divideAdd (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::divideAdd (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::divideAdd (T *destination, const T *a, const T &scalar, Size number)
	Divide the entries of an array by a scalar, then add the result to a destination array. More...
template<>
void	om::math::divideAdd (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::divideAdd (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::divideAdd (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::divideAdd (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::divideAdd (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T >
void	om::math::divideSubtract (T *destination, const T &scalar, Size number)
	Divide each entry in the destination by a scalar, then subtract the result from the destination array entry. More...
template<>
void	om::math::divideSubtract (Int32 *destination, const Int32 &scalar, Size number)
template<>
void	om::math::divideSubtract (Int64 *destination, const Int64 &scalar, Size number)
template<>
void	om::math::divideSubtract (Float32 *destination, const Float32 &scalar, Size number)
template<>
void	om::math::divideSubtract (Float64 *destination, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::divideSubtract (VectorND< T, size > *destination, T scalar, Size number)
template<typename T >
void	om::math::divideSubtract (T *destination, const T *b, Size number)
	Divide each entry in the destination by another array, then subtract the result from the destination entry. More...
template<>
void	om::math::divideSubtract (Int32 *destination, const Int32 *b, Size number)
template<>
void	om::math::divideSubtract (Int64 *destination, const Int64 *b, Size number)
template<>
void	om::math::divideSubtract (Float32 *destination, const Float32 *b, Size number)
template<>
void	om::math::divideSubtract (Float64 *destination, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::divideSubtract (VectorND< T, size > *destination, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::divideSubtract (T *destination, const T *a, const T *b, Size number)
	Divide the enties of one array by another and subtract the results from the destination array entries. More...
template<>
void	om::math::divideSubtract (Int32 *destination, const Int32 *a, const Int32 *b, Size number)
template<>
void	om::math::divideSubtract (Int64 *destination, const Int64 *a, const Int64 *b, Size number)
template<>
void	om::math::divideSubtract (Float32 *destination, const Float32 *a, const Float32 *b, Size number)
template<>
void	om::math::divideSubtract (Float64 *destination, const Float64 *a, const Float64 *b, Size number)
template<typename T , Size size>
void	om::math::divideSubtract (VectorND< T, size > *destination, const VectorND< T, size > *a, const VectorND< T, size > *b, Size number)
template<typename T >
void	om::math::divideSubtract (T *destination, const T *a, const T &scalar, Size number)
	Divide the entries of an array by a scalar, then subtract the result from a destination array. More...
template<>
void	om::math::divideSubtract (Int32 *destination, const Int32 *a, const Int32 &scalar, Size number)
template<>
void	om::math::divideSubtract (Int64 *destination, const Int64 *a, const Int64 &scalar, Size number)
template<>
void	om::math::divideSubtract (Float32 *destination, const Float32 *a, const Float32 &scalar, Size number)
template<>
void	om::math::divideSubtract (Float64 *destination, const Float64 *a, const Float64 &scalar, Size number)
template<typename T , Size size>
void	om::math::divideSubtract (VectorND< T, size > *destination, const VectorND< T, size > *a, T scalar, Size number)
template<typename T >
void	om::math::abs (T *destination, Size number)
	Compute the absolute value of each entry in an array and store the result in the same array. More...
template<>
void	om::math::abs (Int32 *destination, Size number)
template<>
void	om::math::abs (Float32 *destination, Size number)
template<>
void	om::math::abs (Float64 *destination, Size number)
template<typename T >
void	om::math::abs (T *destination, const T *a, Size number)
	Compute the absolute value of each entry in an array and store the result in the destination array. More...
template<>
void	om::math::abs (Int32 *destination, const Int32 *a, Size number)
template<>
void	om::math::abs (Float32 *destination, const Float32 *a, Size number)
template<>
void	om::math::abs (Float64 *destination, const Float64 *a, Size number)
template<typename T >
void	om::math::sqrt (T *destination, Size number)
	Compute the square root of each entry in an array and store the result in the same array. More...
template<>
void	om::math::sqrt (Int32 *destination, Size number)
template<>
void	om::math::sqrt (Float32 *destination, Size number)
template<>
void	om::math::sqrt (Float64 *destination, Size number)
template<typename T >
void	om::math::sqrt (T *destination, const T *a, Size number)
	Compute the square root of each entry in an array and store the result in the destination array. More...
template<>
void	om::math::sqrt (Int32 *destination, const Int32 *a, Size number)
template<>
void	om::math::sqrt (Float32 *destination, const Float32 *a, Size number)
template<>
void	om::math::sqrt (Float64 *destination, const Float64 *a, Size number)
template<typename T >
void	om::math::floor (T *destination, Size number)
	Compute the floor of each entry in an array and store the result in the same array. More...
template<>
void	om::math::floor (Float32 *destination, Size number)
template<>
void	om::math::floor (Float64 *destination, Size number)
template<typename T >
void	om::math::floor (T *destination, const T *a, Size number)
	Compute the floor of each entry in an array and store the result in the destination array. More...
template<>
void	om::math::floor (Float32 *destination, const Float32 *a, Size number)
template<>
void	om::math::floor (Float64 *destination, const Float64 *a, Size number)
template<typename T >
void	om::math::ceiling (T *destination, Size number)
	Compute the ceiling of each entry in an array and store the result in the same array. More...
template<>
void	om::math::ceiling (Float32 *destination, Size number)
template<>
void	om::math::ceiling (Float64 *destination, Size number)
template<typename T >
void	om::math::ceiling (T *destination, const T *a, Size number)
	Compute the ceiling of each entry in an array and store the result in the destination array. More...
template<>
void	om::math::ceiling (Float32 *destination, const Float32 *a, Size number)
template<>
void	om::math::ceiling (Float64 *destination, const Float64 *a, Size number)
template<typename T >
void	om::math::min (T *destination, const T *a, const T *b, Size number)
	Find the smaller of each pair of entries in two arrays and store the result in the destination. More...
template<typename T >
T	om::math::min (const T *array, Size number)
	Compute and return the minimum value in the specified array. More...
template<typename T >
void	om::math::max (T *destination, const T *a, const T *b, Size number)
	Find the larger of each pair of entries in two arrays and store the result in the destination. More...
template<typename T >
T	om::math::max (const T *array, Size number)
	Compute and return the maximum value in the specified array. More...