Main Page   Namespace List   Compound List   File List   Namespace Members   Compound Members   File Members  

TNT Namespace Reference


Compounds

class  TNT::Array1D
class  TNT::Array2D
class  TNT::Array3D
class  TNT::Fortran_Array1D
class  TNT::Fortran_Array2D
class  TNT::Fortran_Array3D
class  TNT::Matrix
class  TNT::Sparse_Matrix_CompRow
class  TNT::Stopwatch
class  TNT::Vector

Typedefs

typedef TNT_SUBSCRIPT_TYPE Subscript

Functions

template<class T> std::ostream& operator<< (std::ostream &s, const Array1D< T > &A)
std::istream& operator>> (std::istream &s, Array1D< T > &A)
Array1D<T> operator+ (const Array1D< T > &A, const Array1D< T > &B)
Array1D<T> operator- (const Array1D< T > &A, const Array1D< T > &B)
Array1D<T> operator * (const Array1D< T > &A, const Array1D< T > &B)
Array1D<T> operator/ (const Array1D< T > &A, const Array1D< T > &B)
Array1D<T>& operator+= (Array1D< T > &A, const Array1D< T > &B)
Array1D<T>& operator-= (Array1D< T > &A, const Array1D< T > &B)
Array1D<T>& operator *= (Array1D< T > &A, const Array1D< T > &B)
Array1D<T>& operator/= (Array1D< T > &A, const Array1D< T > &B)
template<class T> std::ostream& operator<< (std::ostream &s, const Array2D< T > &A)
std::istream& operator>> (std::istream &s, Array2D< T > &A)
Array2D<T> operator+ (const Array2D< T > &A, const Array2D< T > &B)
Array2D<T> operator- (const Array2D< T > &A, const Array2D< T > &B)
Array2D<T> operator * (const Array2D< T > &A, const Array2D< T > &B)
Array2D<T> operator/ (const Array2D< T > &A, const Array2D< T > &B)
Array2D<T>& operator+= (Array2D< T > &A, const Array2D< T > &B)
Array2D<T>& operator-= (Array2D< T > &A, const Array2D< T > &B)
Array2D<T>& operator *= (Array2D< T > &A, const Array2D< T > &B)
Array2D<T>& operator/= (Array2D< T > &A, const Array2D< T > &B)
Array2D<T> matmult (const Array2D< T > &A, const Array2D< T > &B)
template<class T> std::ostream& operator<< (std::ostream &s, const Array3D< T > &A)
std::istream& operator>> (std::istream &s, Array3D< T > &A)
Array3D<T> operator+ (const Array3D< T > &A, const Array3D< T > &B)
Array3D<T> operator- (const Array3D< T > &A, const Array3D< T > &B)
Array3D<T> operator * (const Array3D< T > &A, const Array3D< T > &B)
Array3D<T> operator/ (const Array3D< T > &A, const Array3D< T > &B)
Array3D<T>& operator+= (Array3D< T > &A, const Array3D< T > &B)
Array3D<T>& operator-= (Array3D< T > &A, const Array3D< T > &B)
Array3D<T>& operator *= (Array3D< T > &A, const Array3D< T > &B)
Array3D<T>& operator/= (Array3D< T > &A, const Array3D< T > &B)
template<class T> std::ostream& operator<< (std::ostream &s, const Matrix< T > &A)
std::istream& operator>> (std::istream &s, Matrix< T > &A)
Matrix<T> operator+ (const Matrix< T > &A, const Matrix< T > &B)
Matrix<T> operator- (const Matrix< T > &A, const Matrix< T > &B)
Matrix<T> mult_element (const Matrix< T > &A, const Matrix< T > &B)
Matrix<T> transpose (const Matrix< T > &A)
Matrix<T> matmult (const Matrix< T > &A, const Matrix< T > &B)
Matrix<T> operator * (const Matrix< T > &A, const Matrix< T > &B)
int matmult (Matrix< T > &C, const Matrix< T > &A, const Matrix< T > &B)
Vector<T> matmult (const Matrix< T > &A, const Vector< T > &x)
Vector<T> operator * (const Matrix< T > &A, const Vector< T > &x)
template<class T> std::ostream& operator<< (std::ostream &s, const Fortran_Array1D< T > &A)
std::istream& operator>> (std::istream &s, Fortran_Array1D< T > &A)
Fortran_Array1D<T> operator+ (const Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T> operator- (const Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T> operator * (const Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T> operator/ (const Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T>& operator+= (Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T>& operator-= (Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T>& operator *= (Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
Fortran_Array1D<T>& operator/= (Fortran_Array1D< T > &A, const Fortran_Array1D< T > &B)
template<class T> std::ostream& operator<< (std::ostream &s, const Fortran_Array2D< T > &A)
std::istream& operator>> (std::istream &s, Fortran_Array2D< T > &A)
template<class T> std::ostream& operator<< (std::ostream &s, const Fortran_Array3D< T > &A)
std::istream& operator>> (std::istream &s, Fortran_Array3D< T > &A)
Real hypot (const Real &a, const Real &b)
Scalar min (const Scalar &a, const Scalar &b)
Scalar max (const Scalar &a, const Scalar &b)
Real abs (const Real &a)
template<class T> std::ostream& operator<< (std::ostream &s, const Vector< T > &A)
std::istream& operator>> (std::istream &s, Vector< T > &A)
Vector<T> operator+ (const Vector< T > &A, const Vector< T > &B)
Vector<T> operator- (const Vector< T > &A, const Vector< T > &B)
Vector<T> operator * (const Vector< T > &A, const Vector< T > &B)
dot_prod (const Vector< T > &A, const Vector< T > &B)


Typedef Documentation

typedef TNT_SUBSCRIPT_TYPE TNT::Subscript
 


Function Documentation

Real TNT::abs ( const Real & a )
 

Returns:
the absolute value of a real (no-complex) scalar.

T dot_prod ( const Vector< T > & A,
const Vector< T > & B )
 

Real TNT::hypot ( const Real & a,
const Real & b )
 

Returns:
hypotenuse of real (non-complex) scalars a and b by avoiding underflow/overflow using (a * sqrt( 1 + (b/a) * (b/a))), rather than sqrt(a*a + b*b).

Vector<T> matmult ( const Matrix< T > & A,
const Vector< T > & x )
 

int TNT::matmult ( Matrix< T > & C,
const Matrix< T > & A,
const Matrix< T > & B ) [inline]
 

Matrix< T > TNT::matmult ( const Matrix< T > & A,
const Matrix< T > & B ) [inline]
 

Array2D< T > TNT::matmult ( const Array2D< T > & A,
const Array2D< T > & B )
 

Matrix Multiply: compute C = A*B, where C[i][j] is the dot-product of row i of A and column j of B.

Parameters:
A   an (m x n) array
B   an (n x k) array
Returns:
the (m x k) array A*B, or a null array (0x0) if the matrices are non-conformant (i.e. the number of columns of A are different than the number of rows of B.)

Scalar TNT::max ( const Scalar & a,
const Scalar & b )
 

Returns:
the maximum of scalars a and b.

Scalar TNT::min ( const Scalar & a,
const Scalar & b )
 

Returns:
the minimum of scalars a and b.

Matrix<T> mult_element ( const Matrix< T > & A,
const Matrix< T > & B )
 

Vector<T> operator * ( const Vector< T > & A,
const Vector< T > & B )
 

Fortran_Array1D< T > TNT::operator * ( const Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array multiplication (element-wise) : compute C = A*B, where each C(i) is A(i) * B(i).

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A-B, or a null array (0) if the matrices are non-conformant.

Vector< T > TNT::operator * ( const Matrix< T > & A,
const Vector< T > & x ) [inline]
 

Matrix< T > TNT::operator * ( const Matrix< T > & A,
const Matrix< T > & B ) [inline]
 

Array3D< T > TNT::operator * ( const Array3D< T > & A,
const Array3D< T > & B )
 

Array multiplication (element-wise): compute C = A*B, where C[i][j][k] is the product of A[i][j][k] and B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A*B, or a null array (0x0x0) if the matrices are non-conformant.

Array2D< T > TNT::operator * ( const Array2D< T > & A,
const Array2D< T > & B )
 

Array (element-wise) multiplication: compute C = A*B, where C[i][j] is A[i][j] * B[i][j]. (Note: this is not matrix multiplcation, see Matrix<T> for linear algebra operations.)

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A*B, or a null array (0x0) if the matrices are non-conformant.

Array1D< T > TNT::operator * ( const Array1D< T > & A,
const Array1D< T > & B )
 

Array multiplication (element-wise) : compute C = A*B, where each C[i] is A[i] * B[i].

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A-B, or a null array (0) if the matrices are non-conformant.

Fortran_Array1D< T > & TNT::operator *= ( Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array element-wise multiplication (in place): compute A = A*B, where each A(i) is replaced with A(i) * B(i).

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A*=B, or the original A if if the matrices are non-conformant.

Array3D< T > & TNT::operator *= ( Array3D< T > & A,
const Array3D< T > & B )
 

Array multiplication (in place): compute A = A*B, where each A[i][j][k] is replaced by A[i][j][k] * B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A*B, or a the original array A, if they are non-conformant.

Array2D< T > & TNT::operator *= ( Array2D< T > & A,
const Array2D< T > & B )
 

Array multiplication (in place): compute A = A*B, where each A[i][j] is replaced with A[i][j] * B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A*=B, or the original A if if the matrices are non-conformant.

Array1D< T > & TNT::operator *= ( Array1D< T > & A,
const Array1D< T > & B )
 

Array element-wise multiplication (in place): compute A = A*B, where each A[i] is replaced with A[i] * B[i].

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A*=B, or the original A if if the matrices are non-conformant.

Vector<T> operator+ ( const Vector< T > & A,
const Vector< T > & B )
 

Fortran_Array1D< T > TNT::operator+ ( const Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array addition: compute C = A+B, where C(i) is the sum of A(i) and B(i).

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A+B, or a null array (0) if the matrices are non-conformant.

Matrix<T> operator+ ( const Matrix< T > & A,
const Matrix< T > & B )
 

Array3D< T > TNT::operator+ ( const Array3D< T > & A,
const Array3D< T > & B )
 

Array addition: compute C = A+B, where C[i][j][k] is the sum of A[i][j][k] and B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A+B, or a null array (0x0x0) if the matrices are non-conformant.

Array2D< T > TNT::operator+ ( const Array2D< T > & A,
const Array2D< T > & B )
 

Array addition: compute C = A+B, where C[i][j] is the sum of A[i][j] and B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A+B, or a null array (0x0) if the matrices are non-conformant.

Array1D< T > TNT::operator+ ( const Array1D< T > & A,
const Array1D< T > & B )
 

Array addition: compute C = A+B, where C[i] is the sum of A[i] and B[i].

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A+B, or a null array (0) if the matrices are non-conformant.

Fortran_Array1D< T > & TNT::operator+= ( Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array addition (in place): compute A = A+B, where each A(i) is replaced with A(i) + B(i).

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A+=B, or the original A if if the matrices are non-conformant.

Array3D< T > & TNT::operator+= ( Array3D< T > & A,
const Array3D< T > & B )
 

Array addition (in place): compute A = A+B, where each A[i][j][k] is replaced by A[i][j][k] + B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A+B, or a the original array A, if they are non-conformant.

Array2D< T > & TNT::operator+= ( Array2D< T > & A,
const Array2D< T > & B )
 

Array addition (in place): compute A = A+B, where each A[i][j] is replaced with A[i][j] + B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A+=B, or the original A if if the matrices are non-conformant.

Array1D< T > & TNT::operator+= ( Array1D< T > & A,
const Array1D< T > & B )
 

Array addition (in place): compute A = A+B, where each A[i] is replaced with A[i] + B[i].

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A+=B, or the original A if if the matrices are non-conformant.

Vector<T> operator- ( const Vector< T > & A,
const Vector< T > & B )
 

Fortran_Array1D< T > TNT::operator- ( const Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array subtraction: compute C = A-B, where each C(i) is A(i) - B(i).

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A-B, or a null array (0) if the matrices are non-conformant.

Matrix<T> operator- ( const Matrix< T > & A,
const Matrix< T > & B )
 

Array3D< T > TNT::operator- ( const Array3D< T > & A,
const Array3D< T > & B )
 

Array subtraction: compute C = A-B, where C[i][j][k] is the sum of A[i][j][k] and B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A-B, or a null array (0x0x0) if the matrices are non-conformant.

Array2D< T > TNT::operator- ( const Array2D< T > & A,
const Array2D< T > & B )
 

Array subtraction: compute C = A-B, where C[i][j] is A[i][j] - B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A-B, or a null array (0x0) if the matrices are non-conformant.

Array1D< T > TNT::operator- ( const Array1D< T > & A,
const Array1D< T > & B )
 

Array subtraction: compute C = A-B, where each C[i] is A[i] - B[i].

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A-B, or a null array (0) if the matrices are non-conformant.

Fortran_Array1D< T > & TNT::operator-= ( Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array subtraction (in place): compute A = A-B, where each A(i) is replaced with A(i) - B(i).

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A-=B, or the original A if if the matrices are non-conformant.

Array3D< T > & TNT::operator-= ( Array3D< T > & A,
const Array3D< T > & B )
 

Array subtraction (in place): compute A = A-B, where each A[i][j][k] is replaced by A[i][j][k] - B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A-B, or a the original array A, if they are non-conformant.

Array2D< T > & TNT::operator-= ( Array2D< T > & A,
const Array2D< T > & B )
 

Array subtraction (in place): compute A = A-B, where each A[i][j] is replaced with A[i][j] - B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A-=B, or the original A if if the matrices are non-conformant.

Array1D< T > & TNT::operator-= ( Array1D< T > & A,
const Array1D< T > & B )
 

Array subtraction (in place): compute A = A-B, where each A[i] is replaced with A[i] - B[i].

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A-=B, or the original A if if the matrices are non-conformant.

Fortran_Array1D< T > TNT::operator/ ( const Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array division (element-wise) : compute C = A*B, where each C(i) is A(i) / B(i).

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A-B, or a null array (0) if the matrices are non-conformant.

Array3D< T > TNT::operator/ ( const Array3D< T > & A,
const Array3D< T > & B )
 

Array division (element-wise): compute C = A/B, where C[i][j][k] is the A[i][j][k] / B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A/B, or a null array (0x0x0) if the matrices are non-conformant.

Array2D< T > TNT::operator/ ( const Array2D< T > & A,
const Array2D< T > & B )
 

Array (element-wise) division: compute C = A/B, where C[i][j] is A[i][j] / B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A/B, or a null array (0x0) if the matrices are non-conformant.

Array1D< T > TNT::operator/ ( const Array1D< T > & A,
const Array1D< T > & B )
 

Array division (element-wise) : compute C = A*B, where each C[i] is A[i] / B[i].

Parameters:
A   an array of n elements
B   an array of n elements
Returns:
the n array A-B, or a null array (0) if the matrices are non-conformant.

Fortran_Array1D< T > & TNT::operator/= ( Fortran_Array1D< T > & A,
const Fortran_Array1D< T > & B )
 

Array element-wise division (in place): compute A = A/B, where each A(i) is replaced with A(i) / B(i).

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A/=B, or the original A if if the matrices are non-conformant.

Array3D< T > & TNT::operator/= ( Array3D< T > & A,
const Array3D< T > & B )
 

Array division (in place): compute A = A/B, where each A[i][j][k] is replaced by A[i][j][k] / B[i][j][k].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A/B, or a the original array A, if they are non-conformant.

Array2D< T > & TNT::operator/= ( Array2D< T > & A,
const Array2D< T > & B )
 

Array divsion (in place): compute A = A/B, where each A[i][j] is replaced with A[i][j] / B[i][j].

Parameters:
A   an (m x n) array
B   an (m x n) array
Returns:
the (m x n) array A/=B, or the original A if if the matrices are non-conformant.

Array1D< T > & TNT::operator/= ( Array1D< T > & A,
const Array1D< T > & B )
 

Array element-wise division (in place): compute A = A/B, where each A[i] is replaced with A[i] / B[i].

Parameters:
A   an array of length n
B   an array of length n
Returns:
the n-length array A/=B, or the original A if if the matrices are non-conformant.

template<class T>
std::ostream& operator<< ( std::ostream & s,
const Vector< T > & A )
 

template<class T>
std::ostream & TNT::operator<< ( std::ostream & s,
const Fortran_Array3D< T > & A )
 

Write an array to a character outstream. Output format is one that can be read back in via the in-stream operator: three integers denoting the array dimensions (m x n x k), followed by m (n x k) arrays in "row-major" order.

template<class T>
std::ostream & TNT::operator<< ( std::ostream & s,
const Fortran_Array2D< T > & A )
 

Write an array to a character outstream. Output format is one that can be read back in via the in-stream operator: two integers denoting the array dimensions (m x n), followed by m lines of n elements.

template<class T>
std::ostream & TNT::operator<< ( std::ostream & s,
const Fortran_Array1D< T > & A )
 

Write an array to a character outstream. Output format is one that can be read back in via the in-stream operator: one integer denoting the array dimension (n), followed by n elements, one per line.

template<class T>
std::ostream& operator<< ( std::ostream & s,
const Matrix< T > & A )
 

template<class T>
std::ostream & TNT::operator<< ( std::ostream & s,
const Array3D< T > & A )
 

Write an array to a character outstream. Output format is one that can be read back in via the in-stream operator: three integers denoting the array dimensions (m x n x k), followed by m (n x k) arrays.

template<class T>
std::ostream & TNT::operator<< ( std::ostream & s,
const Array2D< T > & A )
 

Write an array to a character outstream. Output format is one that can be read back in via the in-stream operator: two integers denoting the array dimensions (m x n), followed by m lines of n elements.

template<class T>
std::ostream & TNT::operator<< ( std::ostream & s,
const Array1D< T > & A )
 

Write an array to a character outstream. Output format is one that can be read back in via the in-stream operator: one integer denoting the array dimension (n), followed by n elements, one per line.

std::istream& operator>> ( std::istream & s,
Vector< T > & A )
 

std::istream & TNT::operator>> ( std::istream & s,
Fortran_Array3D< T > & A )
 

Read an array from a character stream. Input format is three integers, denoting the dimensions (m x n x k), followed by m*n*k whitespace-separated elments in "row-major" order (i.e. right-most dimension varying fastest.) Newlines are ignored.

Note: the array being read into references new memory storage. If the intent is to fill an existing conformant array, use cin >> B; A.inject(B) ); instead or read the elements in one-a-time by hand.

Parameters:
s   the charater to read from (typically std::in)
A   the array to read into.

std::istream & TNT::operator>> ( std::istream & s,
Fortran_Array2D< T > & A )
 

Read an array from a character stream. Input format is two integers, denoting the dimensions (m x n), followed by m*n whitespace-separated elments in "row-major" order (i.e. right-most dimension varying fastest.) Newlines are ignored.

Note: the array being read into references new memory storage. If the intent is to fill an existing conformant array, use cin >> B; A.inject(B) ); instead or read the elements in one-a-time by hand.

Parameters:
s   the charater to read from (typically std::in)
A   the array to read into.

std::istream & TNT::operator>> ( std::istream & s,
Fortran_Array1D< T > & A )
 

Read an array from a character stream. Input format is one integer, denoting the dimension (n), followed by n whitespace-separated elments. Newlines are ignored

Note: the array being read into references new memory storage. If the intent is to fill an existing conformant array, use cin >> B; A.inject(B) ); instead or read the elements in one-a-time by hand.

Parameters:
s   the charater to read from (typically std::in)
A   the array to read into.

std::istream& operator>> ( std::istream & s,
Matrix< T > & A )
 

std::istream & TNT::operator>> ( std::istream & s,
Array3D< T > & A )
 

Read an array from a character stream. Input format is three integers, denoting the dimensions (m x n x k), followed by m*n*k whitespace-separated elments in "row-major" order (i.e. right-most dimension varying fastest.) Newlines are ignored.

Note: the array being read into references new memory storage. If the intent is to fill an existing conformant array, use cin >> B; A.inject(B) ); instead or read the elements in one-a-time by hand.

Parameters:
s   the charater to read from (typically std::in)
A   the array to read into.

std::istream & TNT::operator>> ( std::istream & s,
Array2D< T > & A )
 

Read an array from a character stream. Input format is two integers, denoting the dimensions (m x n), followed by m*n whitespace-separated elments in "row-major" order (i.e. right-most dimension varying fastest.) Newlines are ignored.

Note: the array being read into references new memory storage. If the intent is to fill an existing conformant array, use cin >> B; A.inject(B) ); instead or read the elements in one-a-time by hand.

Parameters:
s   the charater to read from (typically std::in)
A   the array to read into.

std::istream & TNT::operator>> ( std::istream & s,
Array1D< T > & A )
 

Read an array from a character stream. Input format is one integer, denoting the dimension (n), followed by n whitespace-separated elments. Newlines are ignored

Note: the array being read into references new memory storage. If the intent is to fill an existing conformant array, use cin >> B; A.inject(B) ); instead or read the elements in one-a-time by hand.

Parameters:
s   the charater to read from (typically std::in)
A   the array to read into.

Matrix<T> transpose ( const Matrix< T > & A )
 


Generated at Thu Jun 26 17:26:25 2003 for Template Numerical Toolkit (TNT) by doxygen1.2.5 written by Dimitri van Heesch, © 1997-2001