G3D::Matrix Class Reference

#include <Matrix.h>

Classes
class	Impl
class	SortRank

Public Types
typedef float	T

Public Member Functions
	Matrix ()
	Matrix (const Matrix3 &M)
	Matrix (const Matrix4 &M)
	Matrix (int R, int C)
int	rows () const
int	cols () const
Matrix &	operator*= (const T &B)
Matrix &	operator/= (const T &B)
Matrix &	operator+= (const T &B)
Matrix &	operator-= (const T &B)
Matrix &	operator*= (const Matrix &B)
Matrix &	operator+= (const Matrix &B)
Matrix &	operator-= (const Matrix &B)
Matrix	subMatrix (int r1, int r2, int c1, int c2) const
Matrix	operator* (const Matrix &B) const
Matrix	operator* (const T &B) const
Matrix	operator+ (const Matrix &B) const
Matrix	operator- (const Matrix &B) const
Matrix	operator+ (const T &v) const
Matrix	operator- (const T &v) const
Matrix	operator> (const T &scalar) const
Matrix	operator< (const T &scalar) const
Matrix	operator>= (const T &scalar) const
Matrix	operator<= (const T &scalar) const
Matrix	operator== (const T &scalar) const
Matrix	operator!= (const T &scalar) const
Matrix	lsub (const T &B) const
Matrix	arrayMul (const Matrix &B) const
Matrix3	toMatrix3 () const
Matrix4	toMatrix4 () const
Vector2	toVector2 () const
Vector3	toVector3 () const
Vector4	toVector4 () const
void	arrayMulInPlace (const Matrix &B)
void	arrayDivInPlace (const Matrix &B)
Matrix	operator- () const
Matrix	inverse () const
T	determinant () const
Matrix	transpose () const
void	transpose (Matrix &out) const
Matrix	adjoint () const
Matrix	pseudoInverse (float tolerance=-1) const
	Computes the Moore-Penrose pseudo inverse, equivalent to (ATA)-1AT). The SVD method is used for performance when the matrix has more than four rows or columns. More...
Matrix	svdPseudoInverse (float tolerance=-1) const
Matrix	gaussJordanPseudoInverse () const
void	svd (Matrix &U, Array< T > &d, Matrix &V, bool sort=true) const
void	set (int r, int c, T v)
void	setCol (int c, const Matrix &vec)
void	setRow (int r, const Matrix &vec)
Matrix	col (int c) const
Matrix	row (int r) const
T	get (int r, int c) const
Vector2int16	size () const
int	numElements () const
void	swapRows (int r0, int r1)
void	swapAndNegateCols (int c0, int c1)
void	mulRow (int r, const T &v)
bool	anyNonZero () const
bool	allNonZero () const
bool	allZero () const
bool	anyZero () const
void	serialize (TextOutput &t) const
std::string	toString (const std::string &name) const
std::string	toString () const
double	normSquared () const
double	norm () const

Static Public Member Functions
template<class S >
static Matrix	fromDiagonal (const Array< S > &d)
static Matrix	fromDiagonal (const Matrix &d)
static Matrix	zero (int R, int C)
static Matrix	one (int R, int C)
static Matrix	identity (int N)
static Matrix	random (int R, int C)
static const char *	svdCore (float **U, int rows, int cols, float *D, float **V)

Static Public Attributes
static int	debugNumCopyOps = 0
static int	debugNumAllocOps = 0

Private Types
typedef shared_ptr< Impl >	ImplRef

Private Member Functions
	Matrix (ImplRef i)
	Matrix (Impl *i)
Matrix	vectorPseudoInverse () const
Matrix	partitionPseudoInverse () const
Matrix	colPartPseudoInverse () const
Matrix	rowPartPseudoInverse () const
Matrix	col2PseudoInverse (const Matrix &B) const
Matrix	col3PseudoInverse (const Matrix &B) const
Matrix	col4PseudoInverse (const Matrix &B) const
Matrix	row2PseudoInverse (const Matrix &B) const
Matrix	row3PseudoInverse (const Matrix &B) const
Matrix	row4PseudoInverse (const Matrix &B) const

Private Attributes
ImplRef	impl

Detailed Description

N x M matrix.

The actual data is tracked internally by a reference counted pointer; it is efficient to pass and assign Matrix objects because no data is actually copied. This avoids the headache of pointers and allows natural math notation:

   Matrix A, B, C;
   // ...

   C = A * f(B);
   C = C.inverse();

   A = Matrix::identity(4);
   C = A;
   C.set(0, 0, 2.0); // Triggers a copy of the data so that A remains unchanged.

   // etc.

The Matrix::debugNumCopyOps and Matrix::debugNumAllocOps counters increment every time an operation forces the copy and allocation of matrices. You can use these to detect slow operations when efficiency is a major concern.

Some methods accept an output argument instead of returning a value. For example, A = B.transpose() can also be invoked as B.transpose(A). The latter may be more efficient, since Matrix may be able to re-use the storage of A (if it has approximatly the right size and isn't currently shared with another matrix).

See also

G3D::Matrix3, G3D::Matrix4, G3D::Vector2, G3D::Vector3, G3D::Vector4, G3D::CoordinateFrame

Member Typedef Documentation

typedef shared_ptr<Impl> G3D::Matrix::ImplRef

private

typedef float G3D::Matrix::T

Internal precision. Currently float, but this may become a templated class in the future to allow operations like Matrix<double> and Matrix<ComplexFloat>.

Not necessarily a plain-old-data type (e.g., could ComplexFloat), but must be something with no constructor, that can be safely memcpyd, and that has a bit pattern of all zeros when zero.

Constructor & Destructor Documentation

G3D::Matrix::Matrix ( ImplRef  i )

inlineprivate

: impl(i) {}

G3D::Matrix::Matrix ( Impl *  i )

inlineprivate

: impl(ImplRef(i)) {}

G3D::Matrix::Matrix ( )

inline

: impl(new Impl(0, 0)) {}

Here is the caller graph for this function:

G3D::Matrix::Matrix ( const Matrix3 &  M )

inline

: impl(new Impl(M)) {}

G3D::Matrix::Matrix ( const Matrix4 &  M )

inline

: impl(new Impl(M)) {}

G3D::Matrix::Matrix ( int  R, int  C  )

inline

Returns a new matrix that is all zero.

 : impl(new Impl(R, C)) {
 impl->setZero();
 }

Member Function Documentation

Matrix G3D::Matrix::adjoint ( ) const

inline

 {
 Impl* A = new Impl(cols(), rows());
 impl->adjoint(*A);
 return Matrix(A);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Matrix::allNonZero

(

)

const

Returns true if all elements are non-zero

 {
 return impl->allNonZero();
}

Here is the caller graph for this function:

bool G3D::Matrix::allZero ( ) const

inline

 {
 return !anyNonZero();
 }

Here is the call graph for this function:

bool G3D::Matrix::anyNonZero

(

)

const

Returns true if any element is non-zero

 {
 return impl->anyNonZero();
}

Here is the caller graph for this function:

bool G3D::Matrix::anyZero ( ) const

inline

 {
 return !allNonZero();
 }

Here is the call graph for this function:

void G3D::Matrix::arrayDivInPlace

(

const Matrix &

B

)

Mutates this

 {
 const Impl& B = *_B.impl;
 INPLACE(arrayDiv)
}

Matrix G3D::Matrix::arrayMul ( const Matrix &  B ) const

inline

 {
 Matrix C(impl->R, impl->C);
 impl->arrayMul(*B.impl, *C.impl);
 return C;
 }

Here is the caller graph for this function:

void G3D::Matrix::arrayMulInPlace

(

const Matrix &

B

)

Mutates this

 {
 const Impl& B = *_B.impl;
 INPLACE(arrayMul)
}

Here is the call graph for this function:

Matrix G3D::Matrix::col

(

int

c

)

const

 {
 debugAssert(c >= 0);
 debugAssert(c < cols());
 Matrix out(rows(), 1);

 T* outData = out.impl->data;
 // Get a pointer to the first element in the column
 const T* inElt = &(impl->elt[0][c]);
 int R = rows();
 int C = cols();
 for (int r = 0; r < R; ++r) {
 outData[r] = *inElt;
 // Skip around to the next row
 inElt += C;
 }

 return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::col2PseudoInverse ( const Matrix &  B ) const

private

 {

 Matrix A = *this;
 int m = rows();
 int n = cols();
 (void)n;

 // Row-major 2x2 matrix
 const float B2[2][2] = 
 {{B.get(0,0), B.get(0,1)}, 
 {B.get(1,0), B.get(1,1)}};

 float det = (B2[0][0]*B2[1][1]) - (B2[0][1]*B2[1][0]);

 if (fuzzyEq(det, T(0))) {
 
 // Matrix was singular; the block matrix pseudo-inverse can't
 // handle that, so fall back to the old case
 return svdPseudoInverse();

 } else {
 // invert using formula at http://www.netsoc.tcd.ie/~jgilbert/maths_site/applets/algebra/matrix_inversion.html

 // Multiply by Binv * A'
 Matrix X(cols(), rows());

 T** Xelt = X.impl->elt;
 T** Aelt = A.impl->elt;
 float binv00 = B2[1][1]/det, binv01 = -B2[1][0]/det;
 float binv10 = -B2[0][1]/det, binv11 = B2[0][0]/det;
 for (int j = 0; j < m; ++j) {
 const T* Arow = Aelt[j];
 float a0 = Arow[0];
 float a1 = Arow[1];
 Xelt[0][j] = binv00 * a0 + binv01 * a1;
 Xelt[1][j] = binv10 * a0 + binv11 * a1;
 }
 return X;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::col3PseudoInverse ( const Matrix &  B ) const

private

 {
 Matrix A = *this;
 int m = rows();
 int n = cols();

 Matrix3 B3 = B.toMatrix3(); 
 if (fuzzyEq(B3.determinant(), (T)0.0)) {

 // Matrix was singular; the block matrix pseudo-inverse can't
 // handle that, so fall back to the old case
 return svdPseudoInverse();

 } else {
 Matrix3 B3inv = B3.inverse();

 // Multiply by Binv * A'
 Matrix X(cols(), rows());

 T** Xelt = X.impl->elt;
 T** Aelt = A.impl->elt;
 for (int i = 0; i < n; ++i) {
 T* Xrow = Xelt[i];
 for (int j = 0; j < m; ++j) {
 const T* Arow = Aelt[j];
 T sum = 0;
 const float* Binvrow = B3inv[i];
 for (int k = 0; k < n; ++k) {
 sum += Binvrow[k] * Arow[k];
 }
 Xrow[j] = sum;
 }
 }
 return X;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::col4PseudoInverse ( const Matrix &  B ) const

private

 {
 Matrix A = *this;
 int m = rows();
 int n = cols();

 Matrix4 B4 = B.toMatrix4(); 
 if (fuzzyEq(B4.determinant(), (T)0.0)) {

 // Matrix was singular; the block matrix pseudo-inverse can't
 // handle that, so fall back to the old case
 return svdPseudoInverse();

 } else {
 Matrix4 B4inv = B4.inverse();

 // Multiply by Binv * A'
 Matrix X(cols(), rows());

 T** Xelt = X.impl->elt;
 T** Aelt = A.impl->elt;
 for (int i = 0; i < n; ++i) {
 T* Xrow = Xelt[i];
 for (int j = 0; j < m; ++j) {
 const T* Arow = Aelt[j];
 T sum = 0;
 const float* Binvrow = B4inv[i];
 for (int k = 0; k < n; ++k) {
 sum += Binvrow[k] * Arow[k];
 }
 Xrow[j] = sum;
 }
 }
 return X;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::colPartPseudoInverse ( ) const

private

 {
 int m = rows();
 int n = cols();
 alwaysAssertM((m>=n),"Column-partitioned block matrix pseudoinverse requires R>C");
 // TODO: Put each of the individual cases in its own helper function
 // TODO: Push the B computation down into the individual cases
 // B = A' * A
 Matrix A = *this;
 Matrix B = Matrix(n, n);
 T** Aelt = A.impl->elt;
 T** Belt = B.impl->elt;
 for (int i = 0; i < n; ++i) {
 for (int j = 0; j < n; ++j) {
 T sum = 0;
 for (int k = 0; k < m; ++k) {
 sum += Aelt[k][i] * Aelt[k][j];
 }
 Belt[i][j] = sum;
 }
 }

 // B has size n x n
 switch (n) {
 case 2:
 return col2PseudoInverse(B);

 case 3:
 return col3PseudoInverse(B);

 case 4:
 return col4PseudoInverse(B);

 default:
 alwaysAssertM(false, "G3D internal error: Should have used the vector or general case!");
 return Matrix();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::Matrix::cols ( ) const

inline

Number of columns

 {
 return impl->C;
 }

Here is the caller graph for this function:

T G3D::Matrix::determinant ( ) const

inline

 {
 return impl->determinant();
 }

Here is the caller graph for this function:

template<class S >

static Matrix G3D::Matrix::fromDiagonal ( const Array< S > &  d )

inlinestatic

 {
 Matrix D = zero(d.length(), d.length());
 for (int i = 0; i < d.length(); ++i) {
 D.set(i, i, d[i]);
 }
 return D;
 }

Here is the call graph for this function:

Matrix G3D::Matrix::fromDiagonal ( const Matrix &  d )

static

 {
 debugAssert((d.rows() == 1) || (d.cols() == 1));

 int n = d.numElements();
 Matrix D = zero(n, n);
 for (int i = 0; i < n; ++i) {
 D.set(i, i, d.impl->data[i]);
 }

 return D;
}

Here is the call graph for this function:

Matrix G3D::Matrix::gaussJordanPseudoInverse ( ) const

inline

(A^TA)^-1A^T) computed using Gauss-Jordan elimination.

 {
 Matrix trans = transpose();
 return (trans * (*this)).inverse() * trans;
 }

Here is the call graph for this function:

Matrix::T G3D::Matrix::get	(	int	r,
		int	c
	)		const

 {
 return impl->get(r, c);
}

Here is the caller graph for this function:

Matrix G3D::Matrix::identity ( int  N )

static

Returns a new identity matrix

 {
 Impl* m = new Impl(N, N);
 m->setZero();
 for (int i = 0; i < N; ++i) {
 m->elt[i][i] = 1.0;
 }
 return Matrix(m);
}

Here is the call graph for this function:

Matrix G3D::Matrix::inverse ( ) const

inline

A^-1 computed using the Gauss-Jordan algorithm, for square matrices. Run time is O(R³), where R is the number of rows.

 {
 Impl* A = new Impl(*impl);
 A->inverseInPlaceGaussJordan();
 return Matrix(A);
 }

Here is the call graph for this function:

Matrix G3D::Matrix::lsub ( const T &  B ) const

inline

scalar B - this

 {
 Matrix C(impl->R, impl->C);
 impl->lsub(B, *C.impl);
 return C;
 }

Here is the caller graph for this function:

void G3D::Matrix::mulRow	(	int	r,
		const T &	v
	)

 {
 debugAssert(r >= 0 && r < rows());

 if (! impl.unique()) {
 impl.reset(new Impl(*impl));
 }

 impl->mulRow(r, v);
}

double G3D::Matrix::norm

(

)

const

2-norm (sqrt(sum(squares))

 {
 return sqrt(normSquared());
}

Here is the call graph for this function:

double G3D::Matrix::normSquared

(

)

const

2-norm squared: sum(squares). (i.e., dot product with itself)

 {
 int R = rows();
 int C = cols();
 int N = R * C;

 double sum = 0.0;

 const T* raw = impl->data;
 for (int i = 0; i < N; ++i) {
 sum += square(raw[i]);
 }

 return sum;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::Matrix::numElements ( ) const

inline

 {
 return rows() * cols();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::one ( int  R, int  C  )

static

Returns a new matrix that is all one.

 {
 Impl* A = new Impl(R, C);
 for (int i = R * C - 1; i >= 0; --i) {
 A->data[i] = 1.0;
 }
 return Matrix(A);
}

Here is the call graph for this function:

Matrix G3D::Matrix::operator!=

(

const T &

scalar

)

const

Matrix G3D::Matrix::operator* ( const Matrix &  B ) const

inline

Matrix multiplication. To perform element-by-element multiplication, see arrayMul.

 {
 Matrix C(impl->R, B.impl->C);
 impl->mul(*B.impl, *C.impl);
 return C;
 }

Matrix G3D::Matrix::operator* ( const T &  B ) const

inline

See also A *= B, which is more efficient in many cases

 {
 Matrix C(impl->R, impl->C);
 impl->mul(B, *C.impl);
 return C;
 }

Matrix & G3D::Matrix::operator*=

(

const T &

B

)

Generally more efficient than A * B

 {
 INPLACE(mul)
 return *this;
}

Here is the call graph for this function:

Matrix & G3D::Matrix::operator*=

(

const Matrix &

B

)

No performance advantage over A * B because matrix multiplication requires intermediate storage.

 {
 // We can't optimize this one
 *this = *this * B;
 return *this;
}

Matrix G3D::Matrix::operator+ ( const Matrix &  B ) const

inline

See also A += B, which is more efficient in many cases

 {
 Matrix C(impl->R, impl->C);
 impl->add(*B.impl, *C.impl);
 return C;
 }

Matrix G3D::Matrix::operator+ ( const T &  v ) const

inline

See also A += B, which is more efficient in many cases

 {
 Matrix C(impl->R, impl->C);
 impl->add(v, *C.impl);
 return C;
 }

Matrix & G3D::Matrix::operator+=

(

const T &

B

)

Generally more efficient than A + B

 {
 INPLACE(add)
 return *this;
}

Matrix & G3D::Matrix::operator+=

(

const Matrix &

B

)

Generally more efficient than A + B

 {
 const Impl& B = *_B.impl;
 INPLACE(add)
 return *this;
}

Matrix G3D::Matrix::operator- ( const Matrix &  B ) const

inline

See also A -= B, which is more efficient in many cases

 {
 Matrix C(impl->R, impl->C);
 impl->sub(*B.impl, *C.impl);
 return C;
 }

Matrix G3D::Matrix::operator- ( const T &  v ) const

inline

See also A -= B, which is more efficient in many cases

 {
 Matrix C(impl->R, impl->C);
 impl->sub(v, *C.impl);
 return C;
 }

Matrix G3D::Matrix::operator- ( ) const

inline

 {
 return negate();
 }

Here is the call graph for this function:

Matrix & G3D::Matrix::operator-=

(

const T &

B

)

Generally more efficient than A - B

 {
 INPLACE(sub)
 return *this;
}

Matrix & G3D::Matrix::operator-=

(

const Matrix &

B

)

Generally more efficient than A - B

 {
 const Impl& B = *_B.impl;
 INPLACE(sub)
 return *this;
}

Matrix & G3D::Matrix::operator/=

(

const T &

B

)

Generally more efficient than A / B

 {
 INPLACE(div)
 return *this;
}

Matrix G3D::Matrix::operator<

(

const T &

scalar

)

const

Matrix G3D::Matrix::operator<=

(

const T &

scalar

)

const

Matrix G3D::Matrix::operator==

(

const T &

scalar

)

const

Matrix G3D::Matrix::operator>

(

const T &

scalar

)

const

Matrix G3D::Matrix::operator>=

(

const T &

scalar

)

const

Matrix G3D::Matrix::partitionPseudoInverse ( ) const

private

 {

 // Logic:
 // A^-1 = (A'A)^-1 A'
 // A has few (n) columns, so A'A is small (n x n) and fast to invert
 
 int m = rows();
 int n = cols();

 if (m < n) {
 // TODO: optimize by pushing through the transpose
 //return transpose().partitionPseudoInverse().transpose();
 return rowPartPseudoInverse();

 } else {
 return colPartPseudoInverse();
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::pseudoInverse

(

float

tolerance = -1

)

const

Computes the Moore-Penrose pseudo inverse, equivalent to (A^TA)^-1A^T). The SVD method is used for performance when the matrix has more than four rows or columns.

[http://en.wikipedia.org/wiki/Moore]E2%80%93Penrose_pseudoinverse

Parameters

tolerance

Use -1 for automatic tolerance.

 {
 if ((cols() == 1) || (rows() == 1)) {
 return vectorPseudoInverse();
 } else if ((cols() <= 4) || (rows() <= 4)) {
 return partitionPseudoInverse();
 } else {
 return svdPseudoInverse(tolerance);
 }
}

Here is the call graph for this function:

Matrix G3D::Matrix::random ( int  R, int  C  )

static

Uniformly distributed values between zero and one.

 {
 Impl* A = new Impl(R, C);
 for (int i = R * C - 1; i >= 0; --i) {
 A->data[i] = G3D::uniformRandom(0.0, 1.0);
 }
 return Matrix(A);
}

Here is the call graph for this function:

Matrix G3D::Matrix::row

(

int

r

)

const

 {
 debugAssert(r >= 0);
 debugAssert(r < rows());
 Matrix out(1, cols());
 out.impl->setRow(1, impl->elt[r]);
 return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::row2PseudoInverse ( const Matrix &  B ) const

private

 {

 Matrix A = *this;
 int m = rows();
 int n = cols();
 (void)m;

 // Row-major 2x2 matrix
 const float B2[2][2] = 
 {{B.get(0,0), B.get(0,1)}, 
 {B.get(1,0), B.get(1,1)}};

 float det = (B2[0][0]*B2[1][1]) - (B2[0][1]*B2[1][0]);

 if (fuzzyEq(det, T(0))) {
 
 // Matrix was singular; the block matrix pseudo-inverse can't
 // handle that, so fall back to the old case
 return svdPseudoInverse();

 } else {
 // invert using formula at http://www.netsoc.tcd.ie/~jgilbert/maths_site/applets/algebra/matrix_inversion.html

 // Multiply by Binv * A'
 Matrix X(cols(), rows());

 T** Xelt = X.impl->elt;
 T** Aelt = A.impl->elt;
 float binv00 = B2[1][1]/det, binv01 = -B2[1][0]/det;
 float binv10 = -B2[0][1]/det, binv11 = B2[0][0]/det;
 for (int j = 0; j < n; ++j) {
 Xelt[j][0] = Aelt[0][j] * binv00 + Aelt[1][j] * binv10;
 Xelt[j][1] = Aelt[0][j] * binv01 + Aelt[1][j] * binv11;
 }
 return X;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::row3PseudoInverse ( const Matrix &  B ) const

private

 {

 Matrix A = *this;
 int m = rows();
 int n = cols();

 Matrix3 B3 = B.toMatrix3(); 
 if (fuzzyEq(B3.determinant(), (T)0.0)) {

 // Matrix was singular; the block matrix pseudo-inverse can't
 // handle that, so fall back to the old case
 return svdPseudoInverse();

 } else {
 Matrix3 B3inv = B3.inverse();

 // Multiply by Binv * A'
 Matrix X(cols(), rows());

 T** Xelt = X.impl->elt;
 T** Aelt = A.impl->elt;
 for (int i = 0; i < n; ++i) {
 T* Xrow = Xelt[i];
 for (int j = 0; j < m; ++j) {
 T sum = 0;
 for (int k = 0; k < m; ++k) {
 sum += Aelt[k][i] * B3inv[j][k];
 }
 Xrow[j] = sum;
 }
 }
 return X;
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::row4PseudoInverse ( const Matrix &  B ) const

private

                                                      {

    Matrix A = *this;
    int m = rows();
    int n = cols();

    Matrix4 B4 = B.toMatrix4(); 
    if (fuzzyEq(B4.determinant(), (T)0.0)) {

        // Matrix was singular; the block matrix pseudo-inverse can't
        // handle that, so fall back to the old case
        return svdPseudoInverse();

    } else {
        Matrix4 B4inv = B4.inverse();

        // Multiply by Binv * A'
        Matrix X(cols(), rows());

        T** Xelt = X.impl->elt;
        T** Aelt = A.impl->elt;
        for (int i = 0; i < n; ++i) {
            T* Xrow = Xelt[i];
            for (int j = 0; j < m; ++j) {
                T sum = 0;
                for (int k = 0; k < m; ++k) {
                    sum += Aelt[k][i] * B4inv[j][k];
                }
                Xrow[j] = sum;
            }
        }
        return X;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::rowPartPseudoInverse ( ) const

private

                                         {
    int m = rows();
    int n = cols();
    alwaysAssertM((m<=n),"Row-partitioned block matrix pseudoinverse requires R<C");

    // B = A * A'
    Matrix A = *this;
    Matrix B = Matrix(m,m);

    T** Aelt = A.impl->elt;
    T** Belt = B.impl->elt;
    for (int i = 0; i < m; ++i) {
        const T* Arow = Aelt[i];
        for (int j = 0; j < m; ++j) {
            const T* Brow = Aelt[j];
            T sum = 0;
            for (int k = 0; k < n; ++k) {
                sum += Arow[k] * Brow[k];
            }
            Belt[i][j] = sum;
        }
    }
    
    // B has size m x m
    switch (m) {
    case 2:
        return row2PseudoInverse(B);

    case 3:
        return row3PseudoInverse(B);

    case 4:
        return row4PseudoInverse(B);

    default:
        alwaysAssertM(false, "G3D internal error: Should have used the vector or general case!");
        return Matrix();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::Matrix::rows ( ) const

inline

The number of rows

                            {
        return impl->R;
    }

Here is the caller graph for this function:

void G3D::Matrix::serialize

(

TextOutput &

t

)

const

Serializes in Matlab source format

                                          {
    t.writeSymbol("%");
    t.writeNumber(rows());
    t.writeSymbol("x");
    t.writeNumber(cols());
    t.pushIndent();
    t.writeNewline();

    t.writeSymbol("[");
    for (int r = 0; r < rows(); ++r) {
        for (int c = 0; c < cols(); ++c) {
            t.writeNumber(impl->get(r, c));
            if (c < cols() - 1) {
                t.writeSymbol(",");
            } else {
                if (r < rows() - 1) {
                    t.writeSymbol(";");
                    t.writeNewline();
                }
            }
        }
    }
    t.writeSymbol("]");
    t.popIndent();
    t.writeNewline();
}

Here is the call graph for this function:

void G3D::Matrix::set	(	int	r,
		int	c,
		T	v
	)

                                  {
    if (! impl.unique()) {
        // Copy the data before mutating; this object is shared
        impl.reset(new Impl(*impl));
    }
    impl->set(r, c, v);
}

Here is the caller graph for this function:

void G3D::Matrix::setCol	(	int	c,
		const Matrix &	vec
	)

                                            {
    debugAssertM(vec.rows() == rows(),
        "A column must be set to a vector of the same size.");
    debugAssertM(vec.cols() == 1,
        "A column must be set to a column vector.");

    debugAssert(c >= 0);

    debugAssert(c < cols());

    if (! impl.unique()) {
        // Copy the data before mutating; this object is shared
        impl.reset(new Impl(*impl));
    }
    impl->setCol(c, vec.impl->data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Matrix::setRow	(	int	r,
		const Matrix &	vec
	)

                                            {
    debugAssertM(vec.cols() == cols(),
        "A row must be set to a vector of the same size.");
    debugAssertM(vec.rows() == 1,
        "A row must be set to a row vector.");

    debugAssert(r >= 0);
    debugAssert(r < rows());

    if (! impl.unique()) {
        // Copy the data before mutating; this object is shared
        impl.reset(new Impl(*impl));
    }
    impl->setRow(r, vec.impl->data);
}

Here is the call graph for this function:

Vector2int16 G3D::Matrix::size ( ) const

inline

                              {
        return Vector2int16(rows(), cols());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::subMatrix	(	int	r1,
		int	r2,
		int	c1,
		int	c2
	)		const

Returns a new matrix that is a subset of this one, from r1:r2 to c1:c2, inclusive.

                                                             {
    debugAssert(r2>=r1);
    debugAssert(c2>=c1);
    debugAssert(c2<cols());
    debugAssert(r2<rows());
    debugAssert(r1>=0);
    debugAssert(c1>=0);

    Matrix X(r2 - r1 + 1, c2 - c1 + 1);

    for (int r = 0; r < X.rows(); ++r) {
        for (int c = 0; c < X.cols(); ++c) {
            X.set(r, c, get(r + r1, c + c1));
        }
    }

    return X;
}

Here is the call graph for this function:

void G3D::Matrix::svd	(	Matrix &	U,
		Array< T > &	d,
		Matrix &	V,
		bool	sort = true
	)		const

Singular value decomposition. Factors into three matrices such that this = U * fromDiagonal(d) * V.transpose().

The matrix must have at least as many rows as columns.

Run time is O(C²*R).

Parameters

sort	If true (default), the singular values are arranged so that D is sorted from largest to smallest.

                                                                   {
    debugAssert(rows() >= cols());
    debugAssertM(&U != &V, "Arguments to SVD must be different matrices");
    debugAssertM(&U != this, "Arguments to SVD must be different matrices");
    debugAssertM(&V != this, "Arguments to SVD must be different matrices");

    int R = rows();
    int C = cols();

    // Make sure we don't overwrite a shared matrix
    if (! V.impl.unique()) {
        V = Matrix::zero(C, C);
    } else {
        V.impl->setSize(C, C);
    }

    if (&U != this || ! impl.unique()) {
        // Make a copy of this for in-place SVD
        U.impl.reset(new Impl(*impl));
    }

    d.resize(C);
    const char* ret = svdCore(U.impl->elt, R, C, d.getCArray(), V.impl->elt);

    debugAssertM(ret == NULL, ret);
    (void)ret;

    if (sort) {
        // Sort the singular values from greatest to least

        Array<SortRank> rank;
        rank.resize(C);
        for (int c = 0; c < C; ++c) {
            rank[c].col   = c;
            rank[c].value = d[c];
        }

        rank.sort(SORT_INCREASING);

        Matrix Uold = U;
        Matrix Vold = V;

        U = Matrix(U.rows(), U.cols());
        V = Matrix(V.rows(), V.cols());

        // Now permute U, d, and V appropriately
        for (int c0 = 0; c0 < C; ++c0) {
            const int c1 = rank[c0].col;

            d[c0] = rank[c0].value;
            U.setCol(c0, Uold.col(c1));
            V.setCol(c0, Vold.col(c1));
        }

    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * G3D::Matrix::svdCore ( float **  U, int  rows, int  cols, float *  D, float **  V  )

static

Low-level SVD functionality. Useful for applications that do not want to construct a Matrix but need to perform the SVD operation.

this = U * D * V'

Assumes that rows >= cols

Returns

NULL on success, a string describing the error on failure.

Parameters

U	rows x cols matrix to be decomposed, gets overwritten with U, a rows x cols matrix with orthogonal columns.
D	vector of singular values of a (diagonal of the D matrix). Length cols.
V	returns the right orthonormal transformation matrix, size cols x cols

[Based] on Dianne Cook's implementation, which is adapted from svdecomp.c in XLISP-STAT 2.1, which is code from Numerical Recipes adapted by Luke Tierney and David Betz. The Numerical Recipes code is adapted from Forsythe et al, who based their code on Golub and Reinsch's original implementation.

                                                                              {
    const int MAX_ITERATIONS = 30;

    int flag, i, its, j, jj, k, l = 0, nm = 0;
    double c, f, h, s, x, y, z;
    double anorm = 0.0, g = 0.0, scale = 0.0;

    // Temp row vector
    double* rv1;
  
    debugAssertM(rows >= cols, "Must have more rows than columns");
  
    rv1 = (double*)System::alignedMalloc(cols * sizeof(double), 16);
    debugAssert(rv1);

    // Householder reduction to bidiagonal form
    for (i = 0; i < cols; ++i) {
        
        // Left-hand reduction
        l = i + 1;
        rv1[i] = scale * g;
        g = s = scale = 0.0;
        
        if (i < rows) {

            for (k = i; k < rows; ++k) {
                scale += fabs((double)U[k][i]);
            }

            if (scale) {
                for (k = i; k < rows; ++k) {
                    U[k][i] = (float)((double)U[k][i]/scale);
                    s += ((double)U[k][i] * (double)U[k][i]);
                }

                f = (double)U[i][i];

                g = -sign(f)*(sqrt(s));
                h = f * g - s;
                U[i][i] = (float)(f - g);
                
                if (i != cols - 1) {
                    for (j = l; j < cols; ++j) {

                        for (s = 0.0, k = i; k < rows; ++k) {
                            s += ((double)U[k][i] * (double)U[k][j]);
                        }

                        f = s / h;
                        for (k = i; k < rows; ++k) {
                            U[k][j] += (float)(f * (double)U[k][i]);
                        }
                    }
                }
                for (k = i; k < rows; ++k) {
                    U[k][i] = (float)((double)U[k][i]*scale);
                }
            }
        }
        D[i] = (float)(scale * g);
    
        // right-hand reduction
        g = s = scale = 0.0;
        if (i < rows && i != cols - 1) {
            for (k = l; k < cols; ++k) {
                scale += fabs((double)U[i][k]);
            }

            if (scale) {
                for (k = l; k < cols; ++k) {
                    U[i][k] = (float)((double)U[i][k]/scale);
                    s += ((double)U[i][k] * (double)U[i][k]);
                }

                f = (double)U[i][l];
                g = -SIGN(sqrt(s), f);
                h = f * g - s;
                U[i][l] = (float)(f - g);

                for (k = l; k < cols; ++k) {
                    rv1[k] = (double)U[i][k] / h;
                }

                if (i != rows - 1) {

                    for (j = l; j < rows; ++j) {
                        for (s = 0.0, k = l; k < cols; ++k) {
                            s += ((double)U[j][k] * (double)U[i][k]);
                        }

                        for (k = l; k < cols; ++k) { 
                            U[j][k] += (float)(s * rv1[k]);
                        }
                    }
                }

                for (k = l; k < cols; ++k) {
                    U[i][k] = (float)((double)U[i][k]*scale);
                }
            }
        }

        anorm = max(anorm, fabs((double)D[i]) + fabs(rv1[i]));
    }
  
    // accumulate the right-hand transformation
    for (i = cols - 1; i >= 0; --i) {
        if (i < cols - 1) {
            if (g) {
                for (j = l; j < cols; ++j) {
                    V[j][i] = (float)(((double)U[i][j] / (double)U[i][l]) / g);
                }

                // double division to avoid underflow 
                for (j = l; j < cols; ++j) {
                    for (s = 0.0, k = l; k < cols; ++k) {
                        s += ((double)U[i][k] * (double)V[k][j]);
                    }

                    for (k = l; k < cols; ++k) {
                        V[k][j] += (float)(s * (double)V[k][i]);
                    }
                }
            }

            for (j = l; j < cols; ++j) {
                V[i][j] = V[j][i] = 0.0;
            }
        }

        V[i][i] = 1.0;
        g = rv1[i];
        l = i;
    }
  
    // accumulate the left-hand transformation
    for (i = cols - 1; i >= 0; --i) {
        l = i + 1;
        g = (double)D[i];
        if (i < cols - 1) {
            for (j = l; j < cols; ++j) {
                U[i][j] = 0.0;
            }
        }

        if (g) {
            g = 1.0 / g;
            if (i != cols - 1) {
                for (j = l; j < cols; ++j) {
                    for (s = 0.0, k = l; k < rows; ++k) {
                        s += ((double)U[k][i] * (double)U[k][j]);
                    }

                    f = (s / (double)U[i][i]) * g;
                    
                    for (k = i; k < rows; ++k) {
                        U[k][j] += (float)(f * (double)U[k][i]);
                    }
                }
            }

            for (j = i; j < rows; ++j) {
                U[j][i] = (float)((double)U[j][i]*g);
            }
        
        } else {
            for (j = i; j < rows; ++j) {
                U[j][i] = 0.0;
            }
        }
        ++U[i][i];
    }

    // diagonalize the bidiagonal form
    for (k = cols - 1; k >= 0; --k) {
        // loop over singular values 
        for (its = 0; its < MAX_ITERATIONS; ++its) {
            // loop over allowed iterations
            flag = 1;
            
            for (l = k; l >= 0; --l) {
                // test for splitting 
                nm = l - 1;
                if (fabs(rv1[l]) + anorm == anorm) {
                    flag = 0;
                    break;
                }

                if (fabs((double)D[nm]) + anorm == anorm) {
                    break;
                }
            }

            if (flag) {
                c = 0.0;
                s = 1.0;
                for (i = l; i <= k; ++i) {
                    f = s * rv1[i];
                    if (fabs(f) + anorm != anorm) {
                        g = (double)D[i];
                        h = pythag(f, g);
                        D[i] = (float)h; 
                        h = 1.0 / h;
                        c = g * h;
                        s = (- f * h);
                        for (j = 0; j < rows; ++j) {
                            y = (double)U[j][nm];
                            z = (double)U[j][i];
                            U[j][nm] = (float)(y * c + z * s);
                            U[j][i] = (float)(z * c - y * s);
                        }
                    }
                }
            }

            z = (double)D[k];
            if (l == k) {
                // convergence
                if (z < 0.0) {
                    // make singular value nonnegative 
                    D[k] = (float)(-z);

                    for (j = 0; j < cols; ++j) {
                        V[j][k] = (-V[j][k]);
                    }
                }
                break;
            }

            if (its >= MAX_ITERATIONS) {
                free(rv1);
                rv1 = NULL;
                return "Failed to converge.";
            }
    
            // shift from bottom 2 x 2 minor
            x = (double)D[l];
            nm = k - 1;
            y = (double)D[nm];
            g = rv1[nm];
            h = rv1[k];
            f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y);
            g = pythag(f, 1.0);
            f = ((x - z) * (x + z) + h * ((y / (f + SIGN(g, f))) - h)) / x;
          
            // next QR transformation 
            c = s = 1.0;
            for (j = l; j <= nm; ++j) {
                i = j + 1;
                g = rv1[i];
                y = (double)D[i];
                h = s * g;
                g = c * g;
                z = pythag(f, h);
                rv1[j] = z;
                c = f / z;
                s = h / z;
                f = x * c + g * s;
                g = g * c - x * s;
                h = y * s;
                y = y * c;

                for (jj = 0; jj < cols; ++jj) {
                    x = (double)V[jj][j];
                    z = (double)V[jj][i];
                    V[jj][j] = (float)(x * c + z * s);
                    V[jj][i] = (float)(z * c - x * s);
                }
                z = pythag(f, h);
                D[j] = (float)z;
                if (z) {
                    z = 1.0 / z;
                    c = f * z;
                    s = h * z;
                }
                f = (c * g) + (s * y);
                x = (c * y) - (s * g);
                for (jj = 0; jj < rows; ++jj) {
                    y = (double)U[jj][j];
                    z = (double)U[jj][i];
                    U[jj][j] = (float)(y * c + z * s);
                    U[jj][i] = (float)(z * c - y * s);
                }
            }
            rv1[l] = 0.0;
            rv1[k] = f;
            D[k] = (float)x;
        }
    }

    System::alignedFree(rv1);
    rv1 = NULL;

    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::svdPseudoInverse

(

float

tolerance = -1

)

const

Called from pseudoInverse when the matrix has size > 4 along some dimension.

                                                     {
    if (cols() > rows()) {
        return transpose().svdPseudoInverse(tolerance).transpose();
    }

    // Matrices from SVD
    Matrix U, V;

    // Diagonal elements
    Array<T> d;

    svd(U, d, V);

    if (rows() == 1) {
        d.resize(1, false);
    }

    if (tolerance < 0) {
        // TODO: Should be eps(d[0]), which is the largest diagonal
        tolerance = G3D::max(rows(), cols()) * 0.0001f;
    }

    Matrix X;
    
    int r = 0;
    for (int i = 0; i < d.size(); ++i) {
        if (d[i] > tolerance) {
            d[i] = Matrix::T(1) / d[i];
            ++r;
        }
    }
    
    if (r == 0) {
        // There were no non-zero elements
        X = zero(cols(), rows());
    } else {
        // Use the first r columns
        
        // Test code (the rest is below)
        /*
        d.resize(r);
        Matrix testU = U.subMatrix(0, U.rows() - 1, 0, r - 1);
        Matrix testV = V.subMatrix(0, V.rows() - 1, 0, r - 1);
        Matrix testX = testV * Matrix::fromDiagonal(d) * testU.transpose();
        X = testX;
        */
        

        // We want to do this:
        //
        //   d.resize(r);
        //   U = U.subMatrix(0, U.rows() - 1, 0, r - 1);
        //   X = V * Matrix::fromDiagonal(d) * U.transpose();
        //
        // but creating a large diagonal matrix and then
        // multiplying by it is wasteful.  So we instead
        // explicitly perform A = (D * U')' = U * D, and 
        // then multiply X = V * A'.

        Matrix A = Matrix(U.rows(), r);

        const T* dPtr = d.getCArray();
        for (int i = 0; i < A.rows(); ++i) {
            const T* Urow = U.impl->elt[i];
            T* Arow = A.impl->elt[i];
            const int Acols = A.cols();
            for (int j = 0; j < Acols; ++j) {
                // A(i,j) = U(i,:) * D(:,j)
                // This is non-zero only at j = i because D is diagonal
                // A(i,j) = U(i,j) * D(j,j)
                Arow[j] = Urow[j] * dPtr[j];
            }
        }

        //
        // Compute X = V.subMatrix(0, V.rows() - 1, 0, r - 1) * A.transpose()
        // 
        // Avoid the explicit subMatrix call, and by storing A' instead of A, avoid
        // both the transpose and the memory incoherence of striding across memory
        // in big steps.

        alwaysAssertM(A.cols() == r, 
            "Internal dimension mismatch during pseudoInverse()");
        alwaysAssertM(V.cols() >= r, 
            "Internal dimension mismatch during pseudoInverse()");

        X = Matrix(V.rows(), A.rows());
        T** Xelt = X.impl->elt;
        for (int i = 0; i < X.rows(); ++i) {
            const T* Vrow = V.impl->elt[i];
            for (int j = 0; j < X.cols(); ++j) {
                const T* Arow = A.impl->elt[j];
                T sum = 0;
                for (int k = 0; k < r; ++k) {
                    sum += Vrow[k] * Arow[k];
                }
                Xelt[i][j] = sum;
            }
        }

        /*
        // Test that results are the same after optimizations:
        Matrix diff = X - testX;
        T n = diff.norm();
        debugAssert(n < 0.0001);
        */
    }

    return X;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Matrix::swapAndNegateCols	(	int	c0,
		int	c1
	)

Swaps columns c0 and c1 and negates both

                                             {
    debugAssert(c0 >= 0 && c0 < cols());
    debugAssert(c1 >= 0 && c1 < cols());

    if (c0 == c1) {
        return;
    }

    if (! impl.unique()) {
        impl.reset(new Impl(*impl));
    }

    impl->swapAndNegateCols(c0, c1);
}

Here is the call graph for this function:

void G3D::Matrix::swapRows	(	int	r0,
		int	r1
	)

                                    {
    debugAssert(r0 >= 0 && r0 < rows());
    debugAssert(r1 >= 0 && r1 < rows());

    if (r0 == r1) {
        return;
    }

    if (! impl.unique()) {
        impl.reset(new Impl(*impl));
    }

    impl->swapRows(r0, r1);
}

Here is the call graph for this function:

Matrix3 G3D::Matrix::toMatrix3

(

)

const

                                {
    debugAssert(impl->R == 3);
    debugAssert(impl->C == 3);
    return Matrix3(
        impl->get(0,0), impl->get(0,1), impl->get(0,2),
        impl->get(1,0), impl->get(1,1), impl->get(1,2),
        impl->get(2,0), impl->get(2,1), impl->get(2,2));
}

Here is the caller graph for this function:

Matrix4 G3D::Matrix::toMatrix4

(

)

const

                                {
    debugAssert(impl->R == 4);
    debugAssert(impl->C == 4);
    return Matrix4(
        impl->get(0,0), impl->get(0,1), impl->get(0,2), impl->get(0,3),
        impl->get(1,0), impl->get(1,1), impl->get(1,2), impl->get(1,3),
        impl->get(2,0), impl->get(2,1), impl->get(2,2), impl->get(2,3),
        impl->get(3,0), impl->get(3,1), impl->get(3,2), impl->get(3,3));
}

Here is the caller graph for this function:

std::string G3D::Matrix::toString

(

const std::string &

name

)

const

                                                      {
    std::string s;

    if (name != "") {
        s += format("%s = \n", name.c_str());
    }

    s += "[";
    for (int r = 0; r < rows(); ++r) {
        for (int c = 0; c < cols(); ++c) {
            double v = impl->get(r, c);

            if (::fabs(v) < 0.00001) {
                // Don't print "negative zero"
                s += format("% 10.04g", 0.0);
            } else if (v == iRound(v)) {
                // Print integers nicely
                s += format("% 10.04g", v);
            } else {
                s += format("% 10.04f", v);
            }

            if (c < cols() - 1) {
                s += ",";
            } else if (r < rows() - 1) {
                s += ";\n ";
            } else {
                s += "]\n";
            }
        }
    }
    return s;
}

Here is the call graph for this function:

std::string G3D::Matrix::toString ( ) const

inline

                               {
        static const std::string name = "";
        return toString(name);
    }

Vector2 G3D::Matrix::toVector2

(

)

const

                                {
    debugAssert(impl->R * impl->C == 2);
    if (impl->R > impl->C) {
        return Vector2(impl->get(0,0), impl->get(1,0));
    } else {
        return Vector2(impl->get(0,0), impl->get(0,1));
    }
}

Vector3 G3D::Matrix::toVector3

(

)

const

                                {
    debugAssert(impl->R * impl->C == 3);
    if (impl->R > impl->C) {
        return Vector3(impl->get(0,0), impl->get(1,0), impl->get(2, 0));
    } else {
        return Vector3(impl->get(0,0), impl->get(0,1), impl->get(0, 2));
    }
}

Vector4 G3D::Matrix::toVector4

(

)

const

                                {
    debugAssert(
        ((impl->R == 4) && (impl->C == 1)) || 
        ((impl->R == 1) && (impl->C == 4)));
    
    if (impl->R > impl->C) {
        return Vector4(impl->get(0,0), impl->get(1,0), impl->get(2, 0), impl->get(3,0));
    } else {
        return Vector4(impl->get(0,0), impl->get(0,1), impl->get(0, 2), impl->get(0,3));
    }
}

Matrix G3D::Matrix::transpose ( ) const

inline

A^T

                                    {
        Impl* A = new Impl(cols(), rows());
        impl->transpose(*A);
        return Matrix(A);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Matrix::transpose

(

Matrix &

out

)

const

Transpose in place; more efficient than transpose

                                        {
    if ((out.impl == impl) && impl.unique() && (impl->R == impl->C)) {
        // In place
        impl->transpose(*out.impl);
    } else {
        out = this->transpose();
    }
}

Here is the call graph for this function:

Matrix G3D::Matrix::vectorPseudoInverse ( ) const

private

                                         {
    // If vector A has nonzero elements: transpose A, then divide each elt. by the squared norm
    // If A is zero vector: transpose A
    double x = 0.0;

    if (anyNonZero()) {
        x = 1.0 / normSquared();
    }

    Matrix A(cols(), rows());
    T** Aelt = A.impl->elt;
    for (int r = 0; r < rows(); ++r) {
        const T* MyRow = impl->elt[r];
        for (int c = 0; c < cols(); ++c) {
            Aelt[c][r] = T(MyRow[c] * x); 
        }
    }
    return Matrix(A);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix G3D::Matrix::zero ( int  R, int  C  )

static

Returns a new matrix that is all zero.

                                {
    Impl* A = new Impl(R, C);
    A->setZero();
    return Matrix(A);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

int G3D::Matrix::debugNumAllocOps = 0

static

Incremented every time a new matrix object is allocated. Useful for profiling your own code that uses Matrix to determine when it is slow due to allocation.

int G3D::Matrix::debugNumCopyOps = 0

static

Incremented every time the elements of a matrix are copied. Useful for profiling your own code that uses Matrix to determine when it is slow due to copying.

ImplRef G3D::Matrix::impl

private

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Matrix.h
• dep/g3dlite/source/Matrix.cpp