Templated one-dimensional, numerical array which looks like a conventional C array. Elements are accessed via the familiar A[i] notation.
Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.
The indexing and layout of this array object makes it compatible with C and C++ algorithms that utilize the familiar C[i] notation. This includes numerous textbooks, such as Numercial Recipes, and various public domain codes.
Member Typedef Documentation
template<class T>
typedef T TNT::Array1D<T>::value_type
Constructor & Destructor Documentation
template<class T>
TNT::Array1D<T>::Array1D<T> (
)
Null constructor. Creates a 0-length (NULL) array. (Reference count is also zero.)
template<class T>
TNT::Array1D<T>::Array1D<T> (
int n ) [explicit]
Create a new array (vector) of length n, WIHOUT initializing array elements. To create an initialized array of constants, see Array1D(n,value).
This version avoids the O(n) initialization overhead and is used just before manual assignment.
Parameters:
n
the dimension (length) of the new matrix.
template<class T>
TNT::Array1D<T>::Array1D<T> (
int n,
const T & a )
Create a new array of length n, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(n, 0.0).
Parameters:
n
the dimension (length) of the new matrix.
val
the constant value to set all elements of the new array to.
template<class T>
TNT::Array1D<T>::Array1D<T> (
int n,
T * a )
Create an n-length array, as a view of an existing one-dimensional C array. (Note that the storage for this pre-existing array will never be destroyed by the Aray1DRef class.)
Parameters:
n
the dimension (length) of the new matrix.
a
the one dimensional C array to use as data storage for the array.
template<class T>
TNT::Array1D<T>::Array1D<T> (
const Array1D<T> & A ) [inline]
Copy constructor. Array data is NOT copied, but shared. Thus, in Array1D B(A), subsequent changes to A will be reflected in B. For an indepent copy of A, use Array1D B(A.copy()), or B = A.copy(), instead.
template<class T>
TNT::Array1D<T>::~Array1D<T> (
)
Destructor: reclaims all memory possible associated with this array.
Member Function Documentation
template<class T>
Array1D<T> TNT::Array1D<T>::copy (
) const
Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Array1D B(A.copy()), to create a new array that does not share data.
template<class T>
int TNT::Array1D<T>::dim (
) const [inline]
Returns:
the dimension (number of elements) of the array. This is equivalent to dim1().
template<class T>
int TNT::Array1D<T>::dim1 (
) const [inline]
Returns:
the dimension (number of elements) of the array. This is equivalent to dim().
template<class T>
Array1D<T> & TNT::Array1D<T>::inject (
const Array1D<T> & A )
Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical row and column dimensions).
This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have
then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.
Parameters:
A
the array from which elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B is made.
template<class T>
TNT::Array1D<T>::operator T * (
) [inline]
Automatic conversion to a one-dimensional pointer. Useful for integrating with numerical codes that utilize pointer interface interface. Thus, if a function declared as
Automatic conversion to a const one-dimensional pointer. Useful for integrating with numerical codes that utilize pointer interface interface. Thus, if a function declared as
A[i] indexes the ith element of A. The first element is A[0]. If TNT_BOUNDS_CHECK is defined, then the index is checked that it fall within the array bounds.
template<class T>
T & TNT::Array1D<T>::operator[] (
int i ) [inline]
A[i] indexes the ith element of A. The first element is A[0]. If TNT_BOUNDS_CHECK is defined, then the index is checked that it falls within the array bounds.
template<class T>
Array1D<T> & TNT::Array1D<T>::ref (
const Array1D<T> & A ) [inline]
Create a reference (shallow assignment) to another existing array. In B.ref(A), B and A shared the same data and subsequent changes to the array elements of one will be reflected in the other.
This is what operator= calls, and B=A and B.ref(A) are equivalent operations.
Returns:
The new referenced array: in B.ref(A), it returns B.
The documentation for this class was generated from the following file:
Templated two-dimensional, numerical array which looks like a conventional C multiarray. Storage corresponds to C (row-major) ordering. Elements are accessed via A[i][j] notation.
Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.
The indexing and layout of this array object makes it compatible with C and C++ algorithms that utilize the familiar C[i][j] notation. This includes numerous textbooks, such as Numercial Recipes, and various public domain codes.
Member Typedef Documentation
template<class T>
typedef T TNT::Array2D<T>::value_type
Used to determined the data type of array entries. This is most commonly used when requiring scalar temporaries in templated algorithms that have TNT arrays as input. For example,
Create a null array. This is not the same as Array2D(0,0), which consumes some memory overhead.
template<class T>
TNT::Array2D<T>::Array2D<T> (
int m,
int n )
Copy constructor. Array data is NOT copied, but shared. Thus, in Array2D B(A), subsequent changes to A will be reflected in B. For an indepent copy of A, use Array2D B(A.copy()), or B = A.copy(), instead.
template<class T>
TNT::Array2D<T>::Array2D<T> (
int m,
int n,
T * a )
Create a new (m x n) array, WIHOUT initializing array elements. To create an initialized array of constants, see Array2D(m,n,value).
This version avoids the O(m*n) initialization overhead and is used just before manual assignment.
Parameters:
m
the first (row) dimension of the new matrix.
n
the second (column) dimension of the new matrix.
template<class T>
TNT::Array2D<T>::Array2D<T> (
int m,
int n,
const T & a )
Create a new (m x n) array, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(m, n, 0.0).
Parameters:
m
the first (row) dimension of the new matrix.
n
the second (column) dimension of the new matrix.
val
the constant value to set all elements of the new array to.
template<class T>
TNT::Array2D<T>::Array2D<T> (
const Array2D<T> & A ) [inline]
Create a new (m x n) array, as a view of an existing one-dimensional array stored in C order, i.e. right-most dimension varying fastest. (Often referred to as "row-major" ordering.) Note that the storage for this pre-existing array will never be garbage collected by the Array2D class.
Parameters:
m
the first (row) dimension of the new matrix.
n
the second (column) dimension of the new matrix.
a
the one dimensional C array to use as data storage for the array.
template<class T>
TNT::Array2D<T>::~Array2D<T> (
)
Destructor. Reclaim resouces associated with this view of the array data. Note that elements are still intact if other array views of this data exist.
Member Function Documentation
template<class T>
Array2D<T> TNT::Array2D<T>::copy (
) const
Create a new copy of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Array2D B(A.copy()), to create a new array that does not share data.
template<class T>
int TNT::Array2D<T>::dim1 (
) const [inline]
Returns:
the size of the first dimension of the array, i.e. the number of rows.
template<class T>
int TNT::Array2D<T>::dim2 (
) const [inline]
Returns:
the size of the second dimension of the array, i.e. the number of columns.
template<class T>
Array2D<T> & TNT::Array2D<T>::inject (
const Array2D<T> & A )
Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical row and column dimensions).
This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have
then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.
Parameters:
A
the array from elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B are made.
template<class T>
TNT::Array2D<T>::operator T ** (
) [inline]
Automatic conversion to a two-dimensional C array. Useful for integrating with numerical codes that utilize the A[i][j] interface. Thus, if a function declared as
Automatic conversion to a const two-dimensional C array. Useful for integrating with numerical codes that utilize the A[i][j] interface. Thus, if a function declared as
Used for A[i][j] indexing. The first [] operator returns a conventional pointer which can be dereferenced using the same [] notation.
If TNT_BOUNDS_CHECK macro is define, the left-most index (row index) is checked that it falls within the array bounds (via the assert() macro.) Note that bounds checking can occur in the row dimension, but the not column, since this is just a C pointer.
template<class T>
Array2D<T> & TNT::Array2D<T>::ref (
const Array2D<T> & A ) [inline]
Create a reference (shallow assignment) to another existing array. In B.ref(A), B and A shared the same data and subsequent changes to the array elements of one will be reflected in the other.
This is what operator= calls, and B=A and B.ref(A) are equivalent operations.
Returns:
The new referenced array: in B.ref(A), it returns B.
The documentation for this class was generated from the following file:
Tempplated three-dimensional, numerical array which looks like a conventional C multiarray. Storage corresponds to conventional C ordering. That is the right-most dimension has contiguous elements. Indexing is via the A[i][j][k] notation.
Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.
The indexing and layout of this array object makes it compatible with C and C++ algorithms that utilize the familiar C[i][j][k] notation. This includes numerous textbooks, such as Numercial Recipes, and various public domain codes.
Member Typedef Documentation
template<class T>
typedef T TNT::Array3D<T>::value_type
Constructor & Destructor Documentation
template<class T>
TNT::Array3D< T >::Array3D<T> (
)
Create a null (0x0x0) array.
template<class T>
TNT::Array3D< T >::Array3D<T> (
int m,
int n,
int k )
Create a new (m x n x k) array, WIHOUT initializing array elements. To create an initialized array of constants, see Array3D(m,n,k, value).
This version avoids the O(m*n*k) initialization overhead and is used just before manual assignment.
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
k
the third dimension of the new matrix.
template<class T>
TNT::Array3D< T >::Array3D<T> (
int m,
int n,
int k,
T * a )
Create a new (m x n x k) array, as a view of an existing one-dimensional array stored in C order, i.e. right-most dimension varying fastest. (Often referred to as "row-major" ordering.) Note that the storage for this pre-existing array will never be garbage collected by the Array3D class.
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
k
the third dimension of the new matrix.
a
the one dimensional C array to use as data storage for the array.
template<class T>
TNT::Array3D< T >::Array3D<T> (
int m,
int n,
int k,
const T & val )
Create a new (m x n x k) array, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(m, n, k, 0.0).
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
k
the third dimension of the new matrix.
val
the constant value to set all elements of the new array to.
template<class T>
TNT::Array3D< T >::Array3D<T> (
const Array3D<T> & A ) [inline]
Copy constructor. Array data is NOT copied, but shared. Thus, in Array3D B(A), subsequent changes to A will be reflected in B. For an indepent copy of A, use Array3D B(A.copy()), or B = A.copy(), instead.
template<class T>
TNT::Array3D<T>::~Array3D<T> (
)
Member Function Documentation
template<class T>
Array3D< T > TNT::Array3D< T >::copy (
) const
Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Array3D B(A.copy()), to create a new array that does not share data.
template<class T>
int TNT::Array3D< T >::dim1 (
) const [inline]
Returns:
the size of the first dimension of the array.
template<class T>
int TNT::Array3D< T >::dim2 (
) const [inline]
Returns:
the size of the second dimension of the array.
template<class T>
int TNT::Array3D< T >::dim3 (
) const [inline]
Returns:
the size of the third (right-most) dimension of the array.
template<class T>
Array3D< T > & TNT::Array3D< T >::inject (
const Array3D<T> & A )
Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical dimensions).
This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have
Array3D A(m,n,k);
Array3D C(m,n,k);
Array3D B(C); // elements of B and C are shared.
then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.
Parameters:
A
the array from elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B are made.
template<class T>
Array3D< T > & TNT::Array3D< T >::operator= (
const Array3D<T> & A ) [inline]
B = A is shorthand notation for B.ref(A).
template<class T>
Array3D< T > & TNT::Array3D< T >::operator= (
const T & a ) [inline]
Assign all elemnts of A to a constant scalar.
template<class T>
const T *const * TNT::Array3D< T >::operator[] (
int i ) const [inline]
template<class T>
T ** TNT::Array3D< T >::operator[] (
int i ) [inline]
Used for A[i][j][k] indexing. The first [] operator returns a conventional pointer which can be dereferenced using the same [] notation.
If TNT_BOUNDS_CHECK macro is define, the left-most index is checked that it falls within the array bounds (via the assert() macro.)
template<class T>
Array3D< T > & TNT::Array3D< T >::ref (
const Array3D<T> & A ) [inline]
Create a reference (shallow assignment) to another existing array. In B.ref(A), B and A shared the same data and subsequent changes to the array elements of one will be reflected in the other.
This is what operator= calls, and B=A and B.ref(A) are equivalent operations.
Returns:
The new referenced array: in B.ref(A), it returns B.
The documentation for this class was generated from the following file:
Templated one-dimensional, numerical array which looks like a conventional Fortran array. This is useful when integrating with C/C++ codes translated from Fortran. Indexing is via the A(i) notation and A(1) is the first element.
Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.
This class employs its own garbage collection via the use of reference counts. That is, whenever an internal array storage no longer has any references to it, it is destoryed.
Member Typedef Documentation
template<class T>
typedef T TNT::Fortran_Array1D<T>::value_type
Constructor & Destructor Documentation
template<class T>
TNT::Fortran_Array1D< T >::Fortran_Array1D<T> (
)
Create a null (0-length) array.
template<class T>
TNT::Fortran_Array1D< T >::Fortran_Array1D<T> (
int n )
Create a new (n) array, WIHOUT initializing array elements. To create an initialized array of constants, see Fortran_Array1D(n, value).
This version avoids the O(n) initialization overhead and is used just before manual assignment.
Parameters:
m
the dimension of the new matrix.
template<class T>
TNT::Fortran_Array1D< T >::Fortran_Array1D<T> (
int n,
T * a )
Create a new n-length array, as a view of an existing one-dimensional C array. (Note that the storage for this pre-existing array will never be garbage collected by the Fortran_Array1D class.)
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
a
the one dimensional C array to use as data storage for the array.
template<class T>
TNT::Fortran_Array1D< T >::Fortran_Array1D<T> (
int n,
const T & val )
Create a new n-length array, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(n, 0.0).
Parameters:
m
the dimension of the new matrix.
val
the constant value to set all elements of the new array to.
template<class T>
TNT::Fortran_Array1D< T >::Fortran_Array1D<T> (
const Fortran_Array1D<T> & A ) [inline]
Copy constructor. Array data is NOT copied, but shared. Thus, in Fortran_Array1D B(A), subsequent changes to A will be reflected in B. For an indepent copy of A, use Fortran_Array1D B(A.copy()), or B = A.copy(), instead.
template<class T>
TNT::Fortran_Array1D<T>::~Fortran_Array1D<T> (
)
Member Function Documentation
template<class T>
Fortran_Array1D< T > TNT::Fortran_Array1D< T >::copy (
) const
Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Fortran_Array1D B(A.copy()), to create a new array that does not share data.
template<class T>
int TNT::Fortran_Array1D< T >::dim (
) const [inline]
Returns:
the size (dimension of) the array.
template<class T>
int TNT::Fortran_Array1D< T >::dim1 (
) const [inline]
Returns:
the size (dimension of) the array.
template<class T>
Fortran_Array1D< T > & TNT::Fortran_Array1D< T >::inject (
const Fortran_Array1D<T> & A )
Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical dimensions).
This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have
then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.
Parameters:
A
the array from elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B are made.
template<class T>
const T & TNT::Fortran_Array1D< T >::operator() (
int i ) const [inline]
Read-only version of A(i,j) indexing.
If TNT_BOUNDS_CHECK macro is defined, the indices are checked that they falls within the array bounds (via the assert() macro.)
template<class T>
T & TNT::Fortran_Array1D< T >::operator() (
int i ) [inline]
Elements are accessed via A(i) indexing.
If TNT_BOUNDS_CHECK macro is defined, the indices are checked that they falls within the array bounds (via the assert() macro.)
template<class T>
Fortran_Array1D< T > & TNT::Fortran_Array1D< T >::operator= (
const Fortran_Array1D<T> & A ) [inline]
B = A is shorthand notation for B.ref(A).
template<class T>
Fortran_Array1D< T > & TNT::Fortran_Array1D< T >::operator= (
const T & a ) [inline]
Assign all elemnts of A to a constant scalar.
template<class T>
Fortran_Array1D< T > & TNT::Fortran_Array1D< T >::ref (
const Fortran_Array1D<T> & A ) [inline]
Create a reference (shallow assignment) to another existing array. In B.ref(A), B and A shared the same data and subsequent changes to the array elements of one will be reflected in the other.
This is what operator= calls, and B=A and B.ref(A) are equivalent operations.
Returns:
The new referenced array: in B.ref(A), it returns B.
template<class T>
int TNT::Fortran_Array1D<T>::ref_count (
) const [inline]
The documentation for this class was generated from the following file:
Templated two-dimensional, numerical array which looks like a conventional Fortran array. This is useful when integrating with C/C++ codes translated from Fortran. Storage corresponds to conventional Fortran ordering. That is, the left-most dimension varies fastest. Indexing is via the A(i,j) notation and A(1,1) is the first element.
Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.
This class employs its own garbage collection via the use of reference counts. That is, whenever an internal array storage no longer has any references to it, it is destoryed.
Member Typedef Documentation
template<class T>
typedef T TNT::Fortran_Array2D<T>::value_type
Constructor & Destructor Documentation
template<class T>
TNT::Fortran_Array2D< T >::Fortran_Array2D<T> (
)
Create a null (0x0x0) array.
template<class T>
TNT::Fortran_Array2D< T >::Fortran_Array2D<T> (
int m,
int n )
Create a new (m x n) array, WIHOUT initializing array elements. To create an initialized array of constants, see Fortran_Array2D(m,n, value).
This version avoids the O(m*n) initialization overhead and is used just before manual assignment.
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
template<class T>
TNT::Fortran_Array2D< T >::Fortran_Array2D<T> (
int m,
int n,
T * a )
Create a new (m x n) array, as a view of an existing one-dimensional C array, with elements stored in Fortran order, i.e. right-most dimension varying fastest. (Often referred to as "column-major" ordering.) Note that the storage for this pre-existing array will never be garbage collected by the Fortran_Array2D class.
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
a
the one dimensional C array to use as data storage for the array.
template<class T>
TNT::Fortran_Array2D< T >::Fortran_Array2D<T> (
int m,
int n,
const T & val )
Create a new (m x n ) array, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(m, n, k, 0.0).
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
val
the constant value to set all elements of the new array to.
template<class T>
TNT::Fortran_Array2D< T >::Fortran_Array2D<T> (
const Fortran_Array2D<T> & A ) [inline]
Copy constructor. Array data is NOT copied, but shared. Thus, in Fortran_Array2D B(A), subsequent changes to A will be reflected in B. For an indepent copy of A, use Fortran_Array2D B(A.copy()), or B = A.copy(), instead.
template<class T>
TNT::Fortran_Array2D<T>::~Fortran_Array2D<T> (
)
Member Function Documentation
template<class T>
Fortran_Array2D< T > TNT::Fortran_Array2D< T >::copy (
) const
Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Fortran_Array2D B(A.copy()), to create a new array that does not share data.
template<class T>
int TNT::Fortran_Array2D< T >::dim1 (
) const [inline]
Returns:
the size of the first dimension of the array.
template<class T>
int TNT::Fortran_Array2D< T >::dim2 (
) const [inline]
Returns:
the size of the second dimension of the array.
template<class T>
Fortran_Array2D< T > & TNT::Fortran_Array2D< T >::inject (
const Fortran_Array2D<T> & A )
Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical dimensions).
This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have
then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.
Parameters:
A
the array from elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B are made.
template<class T>
const T & TNT::Fortran_Array2D< T >::operator() (
int i,
int j ) const [inline]
Read-only version of A(i,j) indexing.
If TNT_BOUNDS_CHECK macro is defined, the indices are checked that they falls within the array bounds (via the assert() macro.)
template<class T>
T & TNT::Fortran_Array2D< T >::operator() (
int i,
int j ) [inline]
Elements are accessed via A(i,j) indexing.
If TNT_BOUNDS_CHECK macro is defined, the indices are checked that they falls within the array bounds (via the assert() macro.)
template<class T>
Fortran_Array2D< T > & TNT::Fortran_Array2D< T >::operator= (
const Fortran_Array2D<T> & A ) [inline]
B = A is shorthand notation for B.ref(A).
template<class T>
Fortran_Array2D< T > & TNT::Fortran_Array2D< T >::operator= (
const T & a ) [inline]
Assign all elemnts of A to a constant scalar.
template<class T>
Fortran_Array2D< T > & TNT::Fortran_Array2D< T >::ref (
const Fortran_Array2D<T> & A ) [inline]
Create a reference (shallow assignment) to another existing array. In B.ref(A), B and A shared the same data and subsequent changes to the array elements of one will be reflected in the other.
This is what operator= calls, and B=A and B.ref(A) are equivalent operations.
Returns:
The new referenced array: in B.ref(A), it returns B.
template<class T>
int TNT::Fortran_Array2D<T>::ref_count (
) const [inline]
The documentation for this class was generated from the following file:
Templated three-dimensional, numerical array which looks like a conventional Fortran array. This is useful when integrating with C/C++ codes translated from Fortran. Storage corresponds to conventional Fortran ordering. That is, the left-most dimension varies fastest. Indexing is via the A(i,j,k) notation and A(1,1,1) is the first element.
Array assignment is by reference (i.e. shallow assignment). That is, B=A implies that the A and B point to the same array, so modifications to the elements of A will be reflected in B. If an independent copy is required, then B = A.copy() can be used. Note that this facilitates returning arrays from functions without relying on compiler optimizations to eliminate extensive data copying.
This class employs its own garbage collection via the use of reference counts. That is, whenever an internal array storage no longer has any references to it, it is destoryed.
Member Typedef Documentation
template<class T>
typedef T TNT::Fortran_Array3D<T>::value_type
Constructor & Destructor Documentation
template<class T>
TNT::Fortran_Array3D< T >::Fortran_Array3D<T> (
)
Create a null (0x0x0) array.
template<class T>
TNT::Fortran_Array3D< T >::Fortran_Array3D<T> (
int m,
int n,
int k )
Create a new (m x n x k) array, WIHOUT initializing array elements. To create an initialized array of constants, see Fortran_Array3D(m,n,k, value).
This version avoids the O(m*n*k) initialization overhead and is used just before manual assignment.
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
k
the third dimension of the new matrix.
template<class T>
TNT::Fortran_Array3D< T >::Fortran_Array3D<T> (
int m,
int n,
int k,
T * a )
Create a new (m x n x k) array, as a view of an existing one-dimensional C array, with elements stored in Fortran order, i.e. right-most dimension varying fastest. (Often referred to as "column-major" ordering.) Note that the storage for this pre-existing array will never be garbage collected by the Fortran_Array3D class.
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
k
the third dimension of the new matrix.
a
the one dimensional C array to use as data storage for the array.
template<class T>
TNT::Fortran_Array3D< T >::Fortran_Array3D<T> (
int m,
int n,
int k,
const T & val )
Create a new (m x n x k) array, initializing array elements to constant specified by argument. Most often used to create an array of zeros, as in A(m, n, k, 0.0).
Parameters:
m
the first dimension of the new matrix.
n
the second dimension of the new matrix.
k
the third dimension of the new matrix.
val
the constant value to set all elements of the new array to.
template<class T>
TNT::Fortran_Array3D< T >::Fortran_Array3D<T> (
const Fortran_Array3D<T> & A ) [inline]
Copy constructor. Array data is NOT copied, but shared. Thus, in Fortran_Array3D B(A), subsequent changes to A will be reflected in B. For an indepent copy of A, use Fortran_Array3D B(A.copy()), or B = A.copy(), instead.
template<class T>
TNT::Fortran_Array3D<T>::~Fortran_Array3D<T> (
)
Member Function Documentation
template<class T>
Fortran_Array3D< T > TNT::Fortran_Array3D< T >::copy (
) const
Create a new of existing matrix. Used in B = A.copy() or in the construction of B, e.g. Fortran_Array3D B(A.copy()), to create a new array that does not share data.
template<class T>
int TNT::Fortran_Array3D< T >::dim1 (
) const [inline]
Returns:
the size of the first dimension of the array.
template<class T>
int TNT::Fortran_Array3D< T >::dim2 (
) const [inline]
Returns:
the size of the second dimension of the array.
template<class T>
int TNT::Fortran_Array3D< T >::dim3 (
) const [inline]
Returns:
the size of the third (right-most) dimension of the array.
template<class T>
Fortran_Array3D< T > & TNT::Fortran_Array3D< T >::inject (
const Fortran_Array3D<T> & A )
Copy the elements to from one array to another, in place. That is B.inject(A), both A and B must conform (i.e. have identical dimensions).
This differs from B = A.copy() in that references to B before this assignment are also affected. That is, if we have
then B.inject(A) affects both and C, while B=A.copy() creates a new array B which shares no data with C or A.
Parameters:
A
the array from elements will be copied
Returns:
an instance of the modifed array. That is, in B.inject(A), it returns B. If A and B are not conformat, no modifications to B are made.
template<class T>
const T & TNT::Fortran_Array3D< T >::operator() (
int i,
int j,
int k ) const [inline]
Read-only version of A(i,j,k) indexing.
If TNT_BOUNDS_CHECK macro is defined, the indices are checked that they falls within the array bounds (via the assert() macro.)
template<class T>
T & TNT::Fortran_Array3D< T >::operator() (
int i,
int j,
int k ) [inline]
Elements are accessed via A(i,j,k) indexing.
If TNT_BOUNDS_CHECK macro is defined, the indices are checked that they falls within the array bounds (via the assert() macro.)
template<class T>
Fortran_Array3D< T > & TNT::Fortran_Array3D< T >::operator= (
const Fortran_Array3D<T> & A ) [inline]
B = A is shorthand notation for B.ref(A).
template<class T>
Fortran_Array3D< T > & TNT::Fortran_Array3D< T >::operator= (
const T & a ) [inline]
Assign all elemnts of A to a constant scalar.
template<class T>
Fortran_Array3D< T > & TNT::Fortran_Array3D< T >::ref (
const Fortran_Array3D<T> & A ) [inline]
Create a reference (shallow assignment) to another existing array. In B.ref(A), B and A shared the same data and subsequent changes to the array elements of one will be reflected in the other.
This is what operator= calls, and B=A and B.ref(A) are equivalent operations.
Returns:
The new referenced array: in B.ref(A), it returns B.
template<class T>
int TNT::Fortran_Array3D< T >::ref_count (
) const [inline]
Returns:
the number of arrays that share the same storage area as this one. (Must be at least one.)
The documentation for this class was generated from the following file:
[Deprecatred] Value-based Matrix class from pre-1.0 TNT version. Provides a row-oriented, 0-based [i][j] and 1-based (i,j) indexing. Kept here for backward compatiblity, but should use the newer TNT::Array2D classes instead.
template<class T> class TNT::Sparse_Matrix_CompRow
Read-only view of a sparse matrix in compressed-row storage format. Neither array elements (nonzeros) nor sparsity structure can be modified. If modifications are required, create a new view.
Index values begin at 0.
Storage requirements: An (m x n) matrix with nz nonzeros requires no more than ((T+I)*nz + M*I) bytes, where T is the size of data elements and I is the size of integers.
Performance Stopwatch used for benchmarking codes. Measures seconds elapsed as a floating point number. Resolution of the clock is determined by CLOCKS_PER_SEC in time.h. Typical use is given by
[Deprecatred] Value-based vector class from pre-1.0 TNT version. Kept here for backward compatiblity, but should use the newer TNT::Array1D classes instead.
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.)
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT)
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020
00021
00022 #ifndef TNT_ARRAY2D_INTERFACE_H
00023 #define TNT_ARRAY2D_INTERFACE_H
00024
00025 #include <cstdlib>
00026 #include <iostream>
00027 #ifdef TNT_BOUNDS_CHECK
00028 #include <assert.h>
00029 #endif
00030
00031
00032 namespace TNT
00033 {
00034
00059 template <class T>
00060 class Array2D
00061 {
00062
00063
00064 private:
00065
00066 /* define private members here */
00067
00068
00069
00070
00071 public:
00072
00086 typedef T value_type;
00087
00092 Array2D();
00093
00094
00101 Array2D(int m, int n);
00102
00103
00104
00116 Array2D(int m, int n, T *a);
00117
00118
00128 Array2D(int m, int n, const T &a);
00129
00130
00131
00132
00145 inline Array2D(const Array2D &A);
00146
00147
00148
00149
00169 inline operator T**();
00170
00171
00172
00192 inline operator const T**();
00193
00194
00198 inline Array2D & operator=(const T &a);
00199
00200
00204 inline Array2D & operator=(const Array2D &A);
00205
00206
00207
00218 inline Array2D & ref(const Array2D &A);
00219
00220
00221
00228 Array2D copy() const;
00229
00230
00231
00255 Array2D & inject(const Array2D & A);
00256
00257
00269 inline T* operator[](int i);
00270 inline const T* operator[](int i) const;
00271
00276 inline int dim1() const;
00277
00278
00283 inline int dim2() const;
00284
00291 ~Array2D();
00292
00293
00294
00295
00296
00297 };
00298
00299
00300
00301
00302
00303 } /* namespace TNT */
00304
00305 #endif
00306 /* TNT_ARRAY2D_INTERFACE_H */
00307
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT)
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020
00021 #ifndef TNT_FORTRAN_ARRAY2D_UTILS_H
00022 #define TNT_FORTRAN_ARRAY2D_UTILS_H
00023
00024 #include <iostream>
00025
00026 namespace TNT
00027 {
00028
00029
00037 template <class T>
00038 std::ostream& operator<<(std::ostream &s, const Fortran_Array2D<T> &A)
00039 {
00040 int M=A.dim1();
00041 int N=A.dim2();
00042
00043 s << M << " " << N << "\n";
00044
00045 for (int i=1; i<=M; i++)
00046 {
00047 for (int j=1; j<=N; j++)
00048 {
00049 s << A(i,j) << " ";
00050 }
00051 s << "\n";
00052 }
00053
00054
00055 return s;
00056 }
00057
00074 template <class T>
00075 std::istream& operator>>(std::istream &s, Fortran_Array2D<T> &A)
00076 {
00077
00078 int M, N;
00079
00080 s >> M >> N;
00081
00082 Fortran_Array2D<T> B(M,N);
00083
00084 for (int i=1; i<=M; i++)
00085 for (int j=1; j<=N; j++)
00086 {
00087 s >> B(i,j);
00088 }
00089
00090 A = B;
00091 return s;
00092 }
00093
00094
00095
00096
00097 } // namespace TNT
00098
00099 #endif
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT): Three-dimensional Fortran numerical array
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020
00021
00022 #ifndef TNT_FORTRAN_ARRAY3D_H
00023 #define TNT_FORTRAN_ARRAY3D_H
00024
00025 #include <cstdlib>
00026 #include <iostream>
00027 #ifdef TNT_BOUNDS_CHECK
00028 #include <assert.h>
00029 #endif
00030 #include "tnt_array3d.h"
00031
00032 namespace TNT
00033 {
00034
00060 template <class T>
00061 class Fortran_Array3D
00062 {
00063
00064
00065 private:
00066
00067
00068
00069 public:
00070
00071 typedef T value_type;
00072
00073 Fortran_Array3D();
00074 Fortran_Array3D(int m, int n, int k);
00075 Fortran_Array3D(int m, int n, int k, T *a);
00076 Fortran_Array3D(int m, int n, int k, const T &a);
00077 inline Fortran_Array3D(const Fortran_Array3D &A);
00078 inline Fortran_Array3D & operator=(const T &a);
00079 inline Fortran_Array3D & operator=(const Fortran_Array3D &A);
00080 inline Fortran_Array3D & ref(const Fortran_Array3D &A);
00081 Fortran_Array3D copy() const;
00082 Fortran_Array3D & inject(const Fortran_Array3D & A);
00083 inline T& operator()(int i, int j, int k);
00084 inline const T& operator()(int i, int j, int k) const ;
00085 inline int dim1() const;
00086 inline int dim2() const;
00087 inline int dim3() const;
00088 inline int ref_count() const;
00089 ~Fortran_Array3D();
00090
00091
00092 };
00093
00097 template <class T>
00098 Fortran_Array3D<T>::Fortran_Array3D();
00099
00100
00107 template <class T>
00108 Fortran_Array3D<T>::Fortran_Array3D(const Fortran_Array3D<T> &A);
00109
00110
00111
00124 template <class T>
00125 Fortran_Array3D<T>::Fortran_Array3D(int m, int n, int k);
00126
00127
00128
00139 template <class T>
00140 Fortran_Array3D<T>::Fortran_Array3D(int m, int n, int k, const T &val) ;
00141
00142
00156 template <class T>
00157 Fortran_Array3D<T>::Fortran_Array3D(int m, int n, int k, T *a) ;
00158
00159
00160
00161
00169 template <class T>
00170 inline T& Fortran_Array3D<T>::operator()(int i, int j, int k) ;
00171
00179 template <class T>
00180 inline const T& Fortran_Array3D<T>::operator()(int i, int j, int k) const;
00181
00182
00186 template <class T>
00187 Fortran_Array3D<T> & Fortran_Array3D<T>::operator=(const T &a);
00188
00189
00196 template <class T>
00197 Fortran_Array3D<T> Fortran_Array3D<T>::copy() const;
00198
00222 template <class T>
00223 Fortran_Array3D<T> & Fortran_Array3D<T>::inject(const Fortran_Array3D &A);
00224
00225
00226
00227
00228
00239 template <class T>
00240 Fortran_Array3D<T> & Fortran_Array3D<T>::ref(const Fortran_Array3D<T> &A);
00241
00245 template <class T>
00246 Fortran_Array3D<T> & Fortran_Array3D<T>::operator=(const Fortran_Array3D<T> &A);
00247
00251 template <class T>
00252 inline int Fortran_Array3D<T>::dim1() const;
00253
00257 template <class T>
00258 inline int Fortran_Array3D<T>::dim2() const ;
00259
00263 template <class T>
00264 inline int Fortran_Array3D<T>::dim3() const ;
00265
00266
00271 template <class T>
00272 inline int Fortran_Array3D<T>::ref_count() const;
00273
00274 template <class T>
00275 Fortran_Array3D<T>::~Fortran_Array3D();
00276
00277
00278 } /* namespace TNT */
00279
00280 #endif
00281 /* TNT_FORTRAN_ARRAY3D_H */
00282
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT)
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020
00021 #ifndef TNT_FORTRAN_ARRAY3D_UTILS_H
00022 #define TNT_FORTRAN_ARRAY3D_UTILS_H
00023
00024 #include <cstdlib>
00025 #include <cassert>
00026
00027 namespace TNT
00028 {
00029
00030
00038 template <class T>
00039 std::ostream& operator<<(std::ostream &s, const Fortran_Array3D<T> &A)
00040 {
00041 int M=A.dim1();
00042 int N=A.dim2();
00043 int K=A.dim3();
00044
00045 s << M << " " << N << " " << K << "\n";
00046
00047 for (int i=1; i<=M; i++)
00048 {
00049 for (int j=1; j<=N; j++)
00050 {
00051 for (int k=1; k<=K; k++)
00052 s << A(i,j,k) << " ";
00053 s << "\n";
00054 }
00055 s << "\n";
00056 }
00057
00058
00059 return s;
00060 }
00061
00078 template <class T>
00079 std::istream& operator>>(std::istream &s, Fortran_Array3D<T> &A)
00080 {
00081
00082 int M, N, K;
00083
00084 s >> M >> N >> K;
00085
00086 Fortran_Array3D<T> B(M,N,K);
00087
00088 for (int i=1; i<=M; i++)
00089 for (int j=1; j<=N; j++)
00090 for (int k=1; k<=K; k++)
00091 s >> B(i,j,k);
00092
00093 A = B;
00094 return s;
00095 }
00096
00097
00098
00099
00100 } // namespace TNT
00101
00102 #endif
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT)
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020
00021 #ifndef TNT_SPARSE_MATRIX_CSR_H
00022 #define TNT_SPARSE_MATRIX_CSR_H
00023
00024
00025 namespace TNT
00026 {
00027
00028
00046 template <class T>
00047 class Sparse_Matrix_CompRow {
00048
00049
00050 public:
00051
00052 Sparse_Matrix_CompRow(const Sparse_Matrix_CompRow &S);
00053 Sparse_Matrix_CompRow(int M, int N, int nz, const T *val,
00054 const int *r, const int *c);
00055
00056
00057
00058 inline const T& val(int i) const;
00059 inline const int& row_ptr(int i) const;
00060 inline const int& col_ind(int i) const;
00061
00062 inline int dim1() const ;
00063 inline int dim2() const ;
00064 int NumNonzeros() const ;
00065
00066
00067 Sparse_Matrix_CompRow& operator=( const Sparse_Matrix_CompRow &R);
00068
00069
00070
00071 };
00072
00085 template <class T>
00086 Sparse_Matrix_CompRow<T>::Sparse_Matrix_CompRow(int M, int N, int nz,
00087 const T *val, const int *r, const int *c);
00088
00089
00090 }
00091 // namespace TNT
00092
00093 #endif
00001 /*
00002 *
00003 * Mathematical and Computational Sciences Division
00004 * National Institute of Technology,
00005 * Gaithersburg, MD USA
00006 *
00007 *
00008 * This software was developed at the National Institute of Standards and
00009 * Technology (NIST) by employees of the Federal Government in the course
00010 * of their official duties. Pursuant to title 17 Section 105 of the
00011 * United States Code, this software is not subject to copyright protection
00012 * and is in the public domain. NIST assumes no responsibility whatsoever for
00013 * its use by other parties, and makes no guarantees, expressed or implied,
00014 * about its quality, reliability, or any other characteristic.
00015 *
00016 */
00017
00018
00019
00020 #ifndef STOPWATCH_H
00021 #define STOPWATCH_H
00022
00023 // for clock() and CLOCKS_PER_SEC
00024 #include <time.h>
00025
00026
00027 namespace TNT
00028 {
00029
00030
00046 class Stopwatch
00047 {
00048 public:
00053 Stopwatch();
00054
00055
00059 inline void start();
00064 inline double stop();
00065
00069 inline double read();
00070
00075 inline void resume();
00076
00081 inline int running();
00082 };
00083
00084
00085 }
00086 #endif
00087
00088
00089
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT)
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020
00021 #ifndef TNT_SUBSCRPT_H
00022 #define TNT_SUBSCRPT_H
00023
00024
00025 //---------------------------------------------------------------------
00026 // This definition describes the default TNT data type used for
00027 // indexing into TNT matrices and vectors. The data type should
00028 // be wide enough to index into large arrays. It defaults to an
00029 // "int", but can be overriden at compile time redefining TNT_SUBSCRIPT_TYPE,
00030 // e.g.
00031 //
00032 // c++ -DTNT_SUBSCRIPT_TYPE='unsigned int' ...
00033 //
00034 //---------------------------------------------------------------------
00035 //
00036
00037 #ifndef TNT_SUBSCRIPT_TYPE
00038 #define TNT_SUBSCRIPT_TYPE int
00039 #endif
00040
00041 namespace TNT
00042 {
00043 typedef TNT_SUBSCRIPT_TYPE Subscript;
00044 }
00045
00046
00047 // () indexing in TNT means 1-offset, i.e. x(1) and A(1,1) are the
00048 // first elements. This offset is left as a macro for future
00049 // purposes, but should not be changed in the current release.
00050 //
00051 //
00052 #define TNT_BASE_OFFSET (1)
00053
00054 #endif
Current TNT version, represented as a charater string in the format three dot-seperated integers, "x.y.z", w here x is the major version number, y is the minor version number, and z is the subminor version number.
Can be used to conveniently display TNT version info, as in
00001 /*
00002 *
00003 * Template Numerical Toolkit (TNT)
00004 *
00005 * Mathematical and Computational Sciences Division
00006 * National Institute of Technology,
00007 * Gaithersburg, MD USA
00008 *
00009 *
00010 * This software was developed at the National Institute of Standards and
00011 * Technology (NIST) by employees of the Federal Government in the course
00012 * of their official duties. Pursuant to title 17 Section 105 of the
00013 * United States Code, this software is not subject to copyright protection
00014 * and is in the public domain. NIST assumes no responsibility whatsoever for
00015 * its use by other parties, and makes no guarantees, expressed or implied,
00016 * about its quality, reliability, or any other characteristic.
00017 *
00018 */
00019
00020 #ifndef TNT_VERSION_H
00021 #define TNT_VERSION_H
00022
00023
00024 //---------------------------------------------------------------------
00025 // current version
00026 //---------------------------------------------------------------------
00027
00028
00029
00044 #define TNT_VERSION_STRING "0.0.0"
00045
00050
00051 #define TNT_MAJOR_VERSION (0)
00052
00056 #define TNT_MINOR_VERSION (0)
00057
00058
00063 #define TNT_SUBMINOR_VERSION (0)
00064
00065
00066
00067 #endif
00068 // TNT_VERSION_H
