# Intrepid::RealSpaceTools< Scalar > Class Template Reference

Implementation of basic linear algebra functionality in Euclidean space. More...

`#include <Intrepid_RealSpaceTools.hpp>`

List of all members.

## Static Public Member Functions

static void absval (Scalar *absArray, const Scalar *inArray, const int size)
Computes absolute value of contiguous input data inArray of size size.
static void absval (Scalar *inoutArray, const int size)
Computes absolute value of contiguous data inoutAbsArray of size size in place.
template<class ArrayAbs , class ArrayIn >
static void absval (ArrayAbs &absArray, const ArrayIn &inArray)
Computes absolute value of an array.
template<class ArrayInOut >
static void absval (ArrayInOut &inoutAbsArray)
Computes, in place, absolute value of an array.
static Scalar vectorNorm (const Scalar *inVec, const int dim, const ENorm normType)
Computes norm (1, 2, infinity) of the vector inVec of size dim.
template<class ArrayIn >
static Scalar vectorNorm (const ArrayIn &inVec, const ENorm normType)
Computes norm (1, 2, infinity) of a single vector stored in an array of rank 1.
template<class ArrayNorm , class ArrayIn >
static void vectorNorm (ArrayNorm &normArray, const ArrayIn &inVecs, const ENorm normType)
Computes norms (1, 2, infinity) of vectors stored in a array of total rank 2 (array of vectors), indexed by (i0, D), or 3 (array of arrays of vectors), indexed by (i0, i1, D).
static void transpose (Scalar *transposeMat, const Scalar *inMat, const int dim)
Computes transpose of the square matrix inMat of size dim by dim.
template<class ArrayTranspose , class ArrayIn >
static void transpose (ArrayTranspose &transposeMats, const ArrayIn &inMats)
Computes transposes of square matrices stored in an array of total rank 2 (single matrix), indexed by (D, D), 3 (array of matrices), indexed by (i0, D, D), or 4 (array of arrays of matrices), indexed by (i0, i1, D, D).
static void inverse (Scalar *inverseMat, const Scalar *inMat, const int dim)
Computes inverse of the square matrix inMat of size dim by dim.
template<class ArrayInverse , class ArrayIn >
static void inverse (ArrayInverse &inverseMats, const ArrayIn &inMats)
Computes inverses of nonsingular matrices stored in an array of total rank 2 (single matrix), indexed by (D, D), 3 (array of matrices), indexed by (i0, D, D), or 4 (array of arrays of matrices), indexed by (i0, i1, D, D).
static Scalar det (const Scalar *inMat, const int dim)
Computes determinant of the square matrix inMat of size dim by dim.
template<class ArrayIn >
static Scalar det (const ArrayIn &inMat)
Computes determinant of a single square matrix stored in an array of rank 2.
template<class ArrayDet , class ArrayIn >
static void det (ArrayDet &detArray, const ArrayIn &inMats)
Computes determinants of matrices stored in an array of total rank 3 (array of matrices), indexed by (i0, D, D), or 4 (array of arrays of matrices), indexed by (i0, i1, D, D).
static void add (Scalar *sumArray, const Scalar *inArray1, const Scalar *inArray2, const int size)
Adds contiguous data inArray1 and inArray2 of size size:
sumArray = inArray1 + inArray2.
static void add (Scalar *inoutSumArray, const Scalar *inArray, const int size)
Adds, in place, contiguous data inArray into inoutSumArray of size size:
inoutSumArray = inoutSumArray + inArray.
template<class ArraySum , class ArrayIn1 , class ArrayIn2 >
static void add (ArraySum &sumArray, const ArrayIn1 &inArray1, const ArrayIn2 &inArray2)
sumArray = inArray1 + inArray2.
template<class ArraySum , class ArrayIn >
static void add (ArraySum &inoutSumArray, const ArrayIn &inArray)
Adds, in place, inArray into inoutSumArray:
inoutSumArray = inoutSumArray + inArray.
static void subtract (Scalar *diffArray, const Scalar *inArray1, const Scalar *inArray2, const int size)
Subtracts contiguous data inArray2 from inArray1 of size size:
diffArray = inArray1 - inArray2.
static void subtract (Scalar *inoutDiffArray, const Scalar *inArray, const int size)
Subtracts, in place, contiguous data inArray from inoutDiffArray of size size:
inoutDiffArray = inoutDiffArray - inArray.
template<class ArrayDiff , class ArrayIn1 , class ArrayIn2 >
static void subtract (ArrayDiff &diffArray, const ArrayIn1 &inArray1, const ArrayIn2 &inArray2)
Subtracts inArray2 from inArray1:
diffArray = inArray1 - inArray2.
template<class ArrayDiff , class ArrayIn >
static void subtract (ArrayDiff &inoutDiffArray, const ArrayIn &inArray)
Subtracts, in place, inArray from inoutDiffArray:
inoutDiffArray = inoutDiffArray - inArray.
static void scale (Scalar *scaledArray, const Scalar *inArray, const int size, const Scalar scalar)
Multiplies contiguous data inArray of size size by a scalar (componentwise):
scaledArray = scalar * inArray.
static void scale (Scalar *inoutScaledArray, const int size, const Scalar scalar)
Multiplies, in place, contiguous data inoutScaledArray of size size by a scalar (componentwise):
inoutScaledArray = scalar * inoutScaledArray.
template<class ArrayScaled , class ArrayIn >
static void scale (ArrayScaled &scaledArray, const ArrayIn &inArray, const Scalar scalar)
Multiplies array inArray by the scalar scalar (componentwise):
scaledArray = scalar * inArray.
template<class ArrayScaled >
static void scale (ArrayScaled &inoutScaledArray, const Scalar scalar)
Multiplies, in place, array inoutScaledArray by the scalar scalar (componentwise):
inoutScaledArray = scalar * inoutScaledArray.
static Scalar dot (const Scalar *inArray1, const Scalar *inArray2, const int size)
Computes dot product of contiguous data inArray1 and inArray2 of size size.
template<class ArrayVec1 , class ArrayVec2 >
static Scalar dot (const ArrayVec1 &inVec1, const ArrayVec2 &inVec2)
Computes dot product of two vectors stored in arrays of rank 1.
template<class ArrayDot , class ArrayVec1 , class ArrayVec2 >
static void dot (ArrayDot &dotArray, const ArrayVec1 &inVecs1, const ArrayVec2 &inVecs2)
Computes dot product of vectors stored in an array of total rank 2 (array of vectors), indexed by (i0, D), or 3 (array of arrays of vectors), indexed by (i0, i1, D).
static void matvec (Scalar *matVec, const Scalar *inMat, const Scalar *inVec, const int dim)
Matrix-vector left multiply using contiguous data:
matVec = inMat * inVec.
template<class ArrayMatVec , class ArrayMat , class ArrayVec >
static void matvec (ArrayMatVec &matVecs, const ArrayMat &inMats, const ArrayVec &inVecs)
Matrix-vector left multiply using multidimensional arrays:
matVec = inMat * inVec.
template<class ArrayVecProd , class ArrayIn1 , class ArrayIn2 >
static void vecprod (ArrayVecProd &vecProd, const ArrayIn1 &inLeft, const ArrayIn2 &inRight)
Vector product using multidimensional arrays:
vecProd = inVecLeft x inVecRight

## Detailed Description

### template<class Scalar> class Intrepid::RealSpaceTools< Scalar >

Implementation of basic linear algebra functionality in Euclidean space.

Definition at line 49 of file Intrepid_RealSpaceTools.hpp.

## Member Function Documentation

template<class Scalar >
template<class ArrayInOut >
 void Intrepid::RealSpaceTools< Scalar >::absval ( ArrayInOut & inoutAbsArray ) ` [inline, static]`

Computes, in place, absolute value of an array.

Parameters:
 inoutAbsArray [in/out] - input/output array

Definition at line 81 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayAbs , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::absval ( ArrayAbs & absArray, const ArrayIn & inArray ) ` [inline, static]`

Computes absolute value of an array.

Parameters:
 outArray [out] - output array inArray [in] - input array
Note:
Requirements (checked at runtime, in debug mode):
• rank(absArray) == rank(inArray)
• dimensions(absArray) == dimensions(inArray)

Definition at line 60 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::absval ( Scalar * inoutArray, const int size ) ` [inline, static]`

Computes absolute value of contiguous data inoutAbsArray of size size in place.

Parameters:
 inoutAbsArray [in/out] - input/output data size [in] - size

Definition at line 50 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::absval ( Scalar * absArray, const Scalar * inArray, const int size ) ` [inline, static]`

Computes absolute value of contiguous input data inArray of size size.

Parameters:
 absArray [out] - output data inArray [in] - input data size [in] - size

Definition at line 41 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArraySum , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::add ( ArraySum & inoutSumArray, const ArrayIn & inArray ) ` [inline, static]`

Adds, in place, inArray into inoutSumArray:
inoutSumArray = inoutSumArray + inArray.

Parameters:
 inoutSumArray [in/out] - sum/first summand inArray [in] - second summand
Note:
Requirements (checked at runtime, in debug mode):
• rank(inoutSumArray) == rank(inArray)
• dimensions(inoutSumArray) == dimensions(inArray)

Definition at line 935 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArraySum , class ArrayIn1 , class ArrayIn2 >
 void Intrepid::RealSpaceTools< Scalar >::add ( ArraySum & sumArray, const ArrayIn1 & inArray1, const ArrayIn2 & inArray2 ) ` [inline, static]`

sumArray = inArray1 + inArray2.

Parameters:
 sumArray [out] - sum inArray1 [in] - first summand inArray2 [in] - second summand
Note:
Requirements (checked at runtime, in debug mode):
• rank(sumArray) == rank(inArray1) == rank(inArray2)
• dimensions(sumArray) == dimensions(inArray1) == dimensions(inArray2)

Definition at line 914 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::add ( Scalar * inoutSumArray, const Scalar * inArray, const int size ) ` [inline, static]`

Adds, in place, contiguous data inArray into inoutSumArray of size size:
inoutSumArray = inoutSumArray + inArray.

Parameters:
 inoutSumArray [in/out] - sum / first summand inArray [in] - second summand size [in] - size of input/output data

Definition at line 904 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::add ( Scalar * sumArray, const Scalar * inArray1, const Scalar * inArray2, const int size ) ` [inline, static]`

Adds contiguous data inArray1 and inArray2 of size size:
sumArray = inArray1 + inArray2.

Parameters:
 sumArray [out] - sum inArray1 [in] - first summand inArray2 [in] - second summand size [in] - size of input/output data

Definition at line 895 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayDet , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::det ( ArrayDet & detArray, const ArrayIn & inMats ) ` [inline, static]`

Computes determinants of matrices stored in an array of total rank 3 (array of matrices), indexed by (i0, D, D), or 4 (array of arrays of matrices), indexed by (i0, i1, D, D).

Parameters:
 detArray [out] - array of determinants indexed by (i0) or (i0, i1) inMats [in] - array of matrices indexed by (i0, D, D) or (i0, i1, D, D)
Note:
Requirements (checked at runtime, in debug mode):
• rank(detArray) == rank(inMats) - 2
• rank(inMats) == 3 or 4
• dimensions i0, i1 of detArray and inMats must agree
• matrix dimensions are limited to 1, 2, and 3

Definition at line 766 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayIn >
 Scalar Intrepid::RealSpaceTools< Scalar >::det ( const ArrayIn & inMat ) ` [inline, static]`

Computes determinant of a single square matrix stored in an array of rank 2.

Parameters:
 inMat [in] - array representing a single matrix, indexed by (D, D)
Note:
Requirements (checked at runtime, in debug mode):
• rank(inMats) == 2
• matrix dimension is limited to 1, 2, and 3

Definition at line 683 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 Scalar Intrepid::RealSpaceTools< Scalar >::det ( const Scalar * inMat, const int dim ) ` [inline, static]`

Computes determinant of the square matrix inMat of size dim by dim.

Parameters:
 inMat [in] - matrix dim [in] - matrix dimension

Definition at line 615 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayDot , class ArrayVec1 , class ArrayVec2 >
 void Intrepid::RealSpaceTools< Scalar >::dot ( ArrayDot & dotArray, const ArrayVec1 & inVecs1, const ArrayVec2 & inVecs2 ) ` [inline, static]`

Computes dot product of vectors stored in an array of total rank 2 (array of vectors), indexed by (i0, D), or 3 (array of arrays of vectors), indexed by (i0, i1, D).

Parameters:
 dotArray [out] - dot product array indexed by (i0) or (i0, i1) inVecs1 [in] - first array of vectors indexed by (i0, D) or (i0, i1, D) inVecs2 [in] - second array of vectors indexed by (i0, D) or (i0, i1, D)
Note:
Requirements (checked at runtime, in debug mode):
• rank(dotArray) == rank(inVecs1) - 1 == rank(inVecs2) - 1
• rank(inVecs1) == 2 or 3
• dimensions i0, i1 of dotArray and inVecs1 / inVecs2 must agree

Definition at line 1100 of file Intrepid_RealSpaceToolsDef.hpp.

References Intrepid::RealSpaceTools< Scalar >::dot().

template<class Scalar >
template<class ArrayVec1 , class ArrayVec2 >
 Scalar Intrepid::RealSpaceTools< Scalar >::dot ( const ArrayVec1 & inVec1, const ArrayVec2 & inVec2 ) ` [inline, static]`

Computes dot product of two vectors stored in arrays of rank 1.

Parameters:
 inVec1 [in] - first vector inVec2 [in] - second vector
Note:
Requirements (checked at runtime, in debug mode):
• rank(inVec1) == rank(inVec2) == 1
• inVec1 and inVec2 have same dimension

Definition at line 1078 of file Intrepid_RealSpaceToolsDef.hpp.

References Intrepid::RealSpaceTools< Scalar >::dot().

template<class Scalar >
 Scalar Intrepid::RealSpaceTools< Scalar >::dot ( const Scalar * inArray1, const Scalar * inArray2, const int size ) ` [inline, static]`

Computes dot product of contiguous data inArray1 and inArray2 of size size.

Parameters:
 inArray1 [in] - first array inArray2 [in] - second array size [in] - size of input arrays

Definition at line 1066 of file Intrepid_RealSpaceToolsDef.hpp.

Referenced by Intrepid::RealSpaceTools< Scalar >::dot().

template<class Scalar >
template<class ArrayInverse , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::inverse ( ArrayInverse & inverseMats, const ArrayIn & inMats ) ` [inline, static]`

Computes inverses of nonsingular matrices stored in an array of total rank 2 (single matrix), indexed by (D, D), 3 (array of matrices), indexed by (i0, D, D), or 4 (array of arrays of matrices), indexed by (i0, i1, D, D).

Parameters:
 inverseMats [out] - array of inverses indexed by (D, D), (i0, D, D) or (i0, i1, D, D) inMats [in] - array of matrices indexed by (D, D), (i0, D, D) or (i0, i1, D, D)
Note:
Requirements (checked at runtime, in debug mode):
• rank(inverseMats) == rank(inMats)
• rank(inMats) == 3 or 4
• dimensions(inverseMats) == dimensions(inMats)
• matrices must be square
• matrix dimensions are limited to 1, 2, and 3

Definition at line 444 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::inverse ( Scalar * inverseMat, const Scalar * inMat, const int dim ) ` [inline, static]`

Computes inverse of the square matrix inMat of size dim by dim.

Parameters:
 inverseMat [out] - matrix inverse inMat [in] - matrix dim [in] - matrix dimension

Definition at line 338 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayMatVec , class ArrayMat , class ArrayVec >
 void Intrepid::RealSpaceTools< Scalar >::matvec ( ArrayMatVec & matVecs, const ArrayMat & inMats, const ArrayVec & inVecs ) ` [inline, static]`

Matrix-vector left multiply using multidimensional arrays:
matVec = inMat * inVec.

An array (rank 1, 2 or 3) of "column" vectors, indexed by (D), (i0, D) or (i0, i1, D), is multiplied on the left by an array (rank 2, 3 or 4) of square matrices, indexed by (D, D), (i0, D, D) or (i0, i1, D, D).

Parameters:
 matVec [out] - matrix-vector product indexed by (D), (i0, D) or (i0, i1, D) inMat [in] - the matrix argument indexed by (D, D), (i0, D, D) or (i0, i1, D, D) inVec [in] - the vector argument indexed by (D), (i0, D) or (i0, i1, D)
Note:
Requirements (checked at runtime, in debug mode):
• rank(matVec) == rank(inVec) == rank(inMat) - 1
• dimensions(matVec) == dimensions(inVec)
• matrix and vector dimensions D, i0 and i1 must agree
• matrices are square

Definition at line 1174 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::matvec ( Scalar * matVec, const Scalar * inMat, const Scalar * inVec, const int dim ) ` [inline, static]`

Matrix-vector left multiply using contiguous data:
matVec = inMat * inVec.

A single "column" vector inVec of size dim is multiplied on the left by a square matrix inMat of size dim by dim.

Parameters:
 matVec [out] - matrix-vector product inMat [in] - the matrix argument inVec [in] - the vector argument dim [in] - matrix/vector dimension

Definition at line 1160 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayScaled >
 void Intrepid::RealSpaceTools< Scalar >::scale ( ArrayScaled & inoutScaledArray, const Scalar scalar ) ` [inline, static]`

Multiplies, in place, array inoutScaledArray by the scalar scalar (componentwise):
inoutScaledArray = scalar * inoutScaledArray.

Parameters:
 inoutScaledArray [in/out] - input/output array scalar [in] - multiplier

Definition at line 1056 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayScaled , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::scale ( ArrayScaled & scaledArray, const ArrayIn & inArray, const Scalar scalar ) ` [inline, static]`

Multiplies array inArray by the scalar scalar (componentwise):
scaledArray = scalar * inArray.

Parameters:
 scaledArray [out] - scaled array inArray [in] - input array scalar [in] - multiplier
Note:
Requirements (checked at runtime, in debug mode):
• rank(scaledArray) == rank(inArray)
• dimensions(scaledArray) == dimensions(inArray)

Definition at line 1035 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::scale ( Scalar * inoutScaledArray, const int size, const Scalar scalar ) ` [inline, static]`

Multiplies, in place, contiguous data inoutScaledArray of size size by a scalar (componentwise):
inoutScaledArray = scalar * inoutScaledArray.

Parameters:
 inoutScaledArray [in/out] - input/scaled array size [in] - size of array scalar [in] - multiplier

Definition at line 1025 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::scale ( Scalar * scaledArray, const Scalar * inArray, const int size, const Scalar scalar ) ` [inline, static]`

Multiplies contiguous data inArray of size size by a scalar (componentwise):
scaledArray = scalar * inArray.

Parameters:
 scaledArray [out] - scaled array inArray [in] - input array size [in] - size of the input array scalar [in] - multiplier

Definition at line 1016 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayDiff , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::subtract ( ArrayDiff & inoutDiffArray, const ArrayIn & inArray ) ` [inline, static]`

Subtracts, in place, inArray from inoutDiffArray:
inoutDiffArray = inoutDiffArray - inArray.

Parameters:
 inoutDiffArray [in/out] - difference/minuend inArray [in] - subtrahend
Note:
Requirements (checked at runtime, in debug mode):
• rank(inoutDiffArray) == rank(inArray)
• dimensions(inoutDiffArray) == dimensions(inArray)

Definition at line 995 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayDiff , class ArrayIn1 , class ArrayIn2 >
 void Intrepid::RealSpaceTools< Scalar >::subtract ( ArrayDiff & diffArray, const ArrayIn1 & inArray1, const ArrayIn2 & inArray2 ) ` [inline, static]`

Subtracts inArray2 from inArray1:
diffArray = inArray1 - inArray2.

Parameters:
 diffArray [out] - difference inArray1 [in] - minuend inArray2 [in] - subtrahend
Note:
Requirements (checked at runtime, in debug mode):
• rank(sumArray) == rank(inArray1) == rank(inArray2)
• dimensions(sumArray) == dimensions(inArray1) == dimensions(inArray2)

Definition at line 974 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::subtract ( Scalar * inoutDiffArray, const Scalar * inArray, const int size ) ` [inline, static]`

Subtracts, in place, contiguous data inArray from inoutDiffArray of size size:
inoutDiffArray = inoutDiffArray - inArray.

Parameters:
 inoutDiffArray [in/out] - difference/minuend inArray [in] - subtrahend size [in] - size of input/output data

Definition at line 964 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::subtract ( Scalar * diffArray, const Scalar * inArray1, const Scalar * inArray2, const int size ) ` [inline, static]`

Subtracts contiguous data inArray2 from inArray1 of size size:
diffArray = inArray1 - inArray2.

Parameters:
 diffArray [out] - difference inArray1 [in] - minuend inArray2 [in] - subtrahend size [in] - size of input/output data

Definition at line 955 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayTranspose , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::transpose ( ArrayTranspose & transposeMats, const ArrayIn & inMats ) ` [inline, static]`

Computes transposes of square matrices stored in an array of total rank 2 (single matrix), indexed by (D, D), 3 (array of matrices), indexed by (i0, D, D), or 4 (array of arrays of matrices), indexed by (i0, i1, D, D).

Parameters:
 transposeMats [out] - array of transposes indexed by (D, D), (i0, D, D) or (i0, i1, D, D) inMats [in] - array of matrices indexed by (D, D), (i0, D, D) or (i0, i1, D, D)
Note:
Requirements (checked at runtime, in debug mode):
• rank(transposeMats) == rank(inMats)
• rank(inMats) == 3 or 4
• dimensions(transposeMats) == dimensions(inMats)
• matrices must be square

Definition at line 279 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 void Intrepid::RealSpaceTools< Scalar >::transpose ( Scalar * transposeMat, const Scalar * inMat, const int dim ) ` [inline, static]`

Computes transpose of the square matrix inMat of size dim by dim.

Parameters:
 transposeMat [out] - matrix transpose inMat [in] - matrix dim [in] - matrix dimension

Definition at line 265 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayVecProd , class ArrayIn1 , class ArrayIn2 >
 void Intrepid::RealSpaceTools< Scalar >::vecprod ( ArrayVecProd & vecProd, const ArrayIn1 & inLeft, const ArrayIn2 & inRight ) ` [inline, static]`

Vector product using multidimensional arrays:
vecProd = inVecLeft x inVecRight

Vector multiplication of two "column" vectors stored in arrays (rank 1, 2, or 3) indexed by (D), (i0, D) or (i0, i1, D).

Parameters:
 vecProd [in] - vector product indexed by (D), (i0, D) or (i0, i1, D) inLeft [in] - left vector argument indexed by (D), (i0, D) or (i0, i1, D) inRight [in] - right vector argument indexed by (D), (i0, D) or (i0, i1, D)
Todo:
Need to decide on how to handle vecprod in 2D: is the result a vector, i.e., there's dimension D or a scalar?

Definition at line 1240 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayNorm , class ArrayIn >
 void Intrepid::RealSpaceTools< Scalar >::vectorNorm ( ArrayNorm & normArray, const ArrayIn & inVecs, const ENorm normType ) ` [inline, static]`

Computes norms (1, 2, infinity) of vectors stored in a array of total rank 2 (array of vectors), indexed by (i0, D), or 3 (array of arrays of vectors), indexed by (i0, i1, D).

Parameters:
 normArray [out] - norm array indexed by (i0) or (i0, i1) inVecs [in] - array of vectors indexed by (i0, D) or (i0, i1, D) normType [in] - norm type
Note:
Requirements (checked at runtime, in debug mode):
• rank(normArray) == rank(inVecs) - 1
• rank(inVecs) == 2 or 3
• dimensions i0, i1 of normArray and inVecs must agree

Definition at line 165 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
template<class ArrayIn >
 Scalar Intrepid::RealSpaceTools< Scalar >::vectorNorm ( const ArrayIn & inVec, const ENorm normType ) ` [inline, static]`

Computes norm (1, 2, infinity) of a single vector stored in an array of rank 1.

Parameters:
 inVec [in] - array representing a single vector normType [in] - norm type
Note:
Requirements (checked at runtime, in debug mode):
• rank(inVec) == 1

Definition at line 123 of file Intrepid_RealSpaceToolsDef.hpp.

template<class Scalar >
 Scalar Intrepid::RealSpaceTools< Scalar >::vectorNorm ( const Scalar * inVec, const int dim, const ENorm normType ) ` [inline, static]`

Computes norm (1, 2, infinity) of the vector inVec of size dim.

Parameters:
 inVec [in] - vector dim [in] - vector dimension normType [in] - norm type

Definition at line 90 of file Intrepid_RealSpaceToolsDef.hpp.

The documentation for this class was generated from the following files:
Generated on Mon Jan 31 09:55:49 2011 for Intrepid by  1.6.3