UT/UT_Matrix2.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-366-4607
 */

#ifndef __UT_Matrix2_h__
#define __UT_Matrix2_h__

#include <iostream.h>
#include <SYS/SYS_Math.h>
#include "UT_Assert.h"

class UT_IStream;
class UT_Vector2;
class UT_Matrix3;

template <typename T> class UT_TMatrix2;

typedef UT_TMatrix2<float>  UT_Matrix2;
typedef UT_TMatrix2<double> UT_DMatrix2;

// Free floating operators that return a UT_TMatrix2<T> object. 
template <typename T>
UT_TMatrix2<T>  operator+(const UT_TMatrix2<T> &m1, const UT_TMatrix2<T> &m2);
template <typename T>
UT_TMatrix2<T>  operator+(const UT_TMatrix2<T> &m, const UT_Vector2 &v);
template <typename T>
UT_TMatrix2<T>  operator+(const UT_Vector2 &v, const UT_TMatrix2<T> &m);
template <typename T>
UT_TMatrix2<T>  operator+(const UT_TMatrix2<T> &mat, T sc);
template <typename T>
UT_TMatrix2<T>  operator+(T sc, const UT_TMatrix2<T> &mat);

template <typename T>
UT_TMatrix2<T>  operator-(const UT_TMatrix2<T> &m1, const UT_TMatrix2<T> &m2);
template <typename T>
UT_TMatrix2<T>  operator-(const UT_TMatrix2<T> &m, const UT_Vector2 &v);
template <typename T>
UT_TMatrix2<T>  operator-(const UT_Vector2 &v, const UT_TMatrix2<T> &m);
template <typename T>
UT_TMatrix2<T>  operator-(const UT_TMatrix2<T> &mat, T sc);
template <typename T>
UT_TMatrix2<T>  operator-(T sc, const UT_TMatrix2<T> &mat);

template <typename T>
UT_TMatrix2<T>  operator*(const UT_TMatrix2<T> &m1, const UT_TMatrix2<T> &m2);
template <typename T>
UT_TMatrix2<T>  operator*(const UT_TMatrix2<T> &mat, T sc);
template <typename T>
UT_TMatrix2<T>  operator*(T sc, const UT_TMatrix2<T> &mat);

template <typename T>
UT_TMatrix2<T>  operator/(const UT_TMatrix2<T> &mat, T sc);
template <typename T>
UT_TMatrix2<T>  operator/(T sc, const UT_TMatrix2<T> &mat);

/// This class implements a 2x2 matrix in row-major order.
///
/// Most of Houdini operates with row vectors that are left-multiplied with
/// matrices. e.g.,   z = v * M
template <typename T> class UT_TMatrix2
{
public:
    /// Construct uninitialized matrix.
    UT_TMatrix2()
    {
        UT_ASSERT_COMPILETIME(sizeof(UT_TMatrix2<T>) == 4 * sizeof(T));
    }
    /// Construct identity matrix, multipled by scalar.
    explicit UT_TMatrix2(T val)
    {
        matx[0][0] = val; matx[0][1] = 0;
        matx[1][0] = 0; matx[1][1] = val;
    }
    /// Construct a deep copy of the input row-major data.
    // @{
    explicit UT_TMatrix2(const fpreal32 m[2][2])
    {
        matx[0][0]=m[0][0]; matx[0][1]=m[0][1];
        matx[1][0]=m[1][0]; matx[1][1]=m[1][1];
    }
    explicit UT_TMatrix2(const fpreal64 m[2][2])
    {
        matx[0][0]=m[0][0]; matx[0][1]=m[0][1];
        matx[1][0]=m[1][0]; matx[1][1]=m[1][1];
    }
    // @}

    /// This constructor is for convenience; in many situations, it's less
    /// efficient than the array-based constructors.
    UT_TMatrix2(T val00, T val01,
               T val10, T val11)
    {
        matx[0][0] = val00; matx[0][1] = val01;
        matx[1][0] = val10; matx[1][1] = val11;
    }

    // Default copy constructor is fine.
    // UT_TMatrix2<T>(const UT_TMatrix2<T> &m);

    // Default assignment operator is fine.
    //UT_TMatrix2<T>    &operator=(const UT_TMatrix2<T> &m);

    /// Conversion operator that returns a 2x2 from a 3x3 matrix by ignoring the
    /// last row and last column.
    UT_TMatrix2<T>      &operator=(const UT_Matrix3 &m);

    UT_TMatrix2<T>      &operator+=(const UT_TMatrix2<T> &m)
                        {
                            matx[0][0]+=m.matx[0][0]; matx[0][1]+=m.matx[0][1];
                            matx[1][0]+=m.matx[1][0]; matx[1][1]+=m.matx[1][1];
                            return *this;
                        }
    UT_TMatrix2<T>      &operator-=(const UT_TMatrix2<T> &m)
                        {
                            matx[0][0]-=m.matx[0][0]; matx[0][1]-=m.matx[0][1];
                            matx[1][0]-=m.matx[1][0]; matx[1][1]-=m.matx[1][1];
                            return *this;
                        }
    UT_TMatrix2<T>      &operator*=(const UT_TMatrix2<T> &m);

    unsigned    operator==(const UT_TMatrix2<T> &m) const;
    unsigned    operator!=(const UT_TMatrix2<T> &m) const
                {
                    return !(*this == m);
                }       

    UT_TMatrix2<T>  &operator=(T val)
                    {
                        matx[0][0] = val; matx[0][1] = 0;
                        matx[1][0] = 0;   matx[1][1] = val;
                        return *this;
                    }
    UT_TMatrix2<T>  &operator+=(T scalar)
                    {
                        matx[0][0]+=scalar; matx[0][1]+=scalar;
                        matx[1][0]+=scalar; matx[1][1]+=scalar;
                        return *this;
                    }
    UT_TMatrix2<T>  &operator-=(T scalar)
                    {
                        return operator+=(-scalar);
                    }
    UT_TMatrix2<T>  &operator*=(T scalar)
                    {
                        matx[0][0]*=scalar; matx[0][1]*=scalar;
                        matx[1][0]*=scalar; matx[1][1]*=scalar;
                        return *this;
                    }
    UT_TMatrix2<T>  &operator/=(T scalar)
                    {
                        return operator*=( 1.0f/scalar );
                    }

    // Vector2 operators:
    inline
    UT_TMatrix2<T>  &operator=(const UT_Vector2 &vec);
    inline
    UT_TMatrix2<T>  &operator+=(const UT_Vector2 &vec);
    inline
    UT_TMatrix2<T>  &operator-=(const UT_Vector2 &vec);

    T           determinant() const
                {
                    return matx[0][0]*matx[1][1] - matx[0][1]*matx[1][0];
                }
    T           trace() const
                { return matx[0][0] + matx[1][1]; }

    /// Returns eigenvalues of this matrix
    int         eigenvalues(UT_Vector2 &r, UT_Vector2 &i) const;

    /// Invert this matrix and return 0 if OK, 1 if singular.
    int         invert();
    /// Invert the matrix and return 0 if OK, 1 if singular.
    /// Puts the inverted matrix in m, and leaves this matrix unchanged.
    int         invert(UT_TMatrix2<T> &m) const;

    /// Returns the tolerance of our class.
    T           tolerance() const;

    // Solve a 2x2 system of equations Ax=b, where A is this matrix, b is
    // given and x is unknown. The method returns 0 if the determinant is not
    // 0, and 1 otherwise.
    int         solve(const UT_Vector2 &b, UT_Vector2 &x) const;

    // Transpose this matrix or return its transpose.
    void        transpose(void)
                {
                    T tmp;
                    tmp=matx[0][1];  matx[0][1]=matx[1][0];  matx[1][0]=tmp;
                }
    UT_TMatrix2<T>      transpose(void) const;

    /// Set the matrix to identity
    void        identity()
                {
                    matx[0][0]=(T)1;matx[0][1]=(T)0;
                    matx[1][0]=(T)0;matx[1][1]=(T)1;
                }

    /// Initialize this matrix to zero.
    void        initialize()
                {
                    matx[0][0]=matx[0][1]= (T)0;
                    matx[1][0]=matx[1][1]= (T)0;
                }

    /// Return a matrix entry. No bounds checking on subscripts.
    // @{
    T           &operator()(unsigned row, unsigned col)
                 {
                     UT_ASSERT_P(row < 2 && col < 2);
                     return matx[row][col];
                 }
    T            operator()(unsigned row, unsigned col) const
                 {
                     UT_ASSERT_P(row < 2 && col < 2);
                     return matx[row][col];
                 }
    // @}

    /// Return a matrix row. No bounds checking on subscript.
    // @{
    T           *operator()(unsigned row)
                 {
                     UT_ASSERT_P(row < 2);
                     return matx[row];
                 }
    const T     *operator()(unsigned row) const
                 {
                     UT_ASSERT_P(row < 2);
                     return matx[row];
                 }
    inline
    UT_Vector2   operator[](unsigned row) const;
    // @}
        
    /// Euclidean or Frobenius norm of a matrix.
    /// Does sqrt(sum(a_ij ^2))
    T            getEuclideanNorm() const
                 { return SYSsqrt(getEuclideanNorm2()); }
    /// Euclidean norm squared.
    T            getEuclideanNorm2() const;

    // I/O methods.  Return 0 if read/write successful, -1 if unsuccessful.
    int                  save(ostream &os, int binary) const;
    bool                 load(UT_IStream &is);

    void                 outAsciiNoName(ostream &os) const;

    // I/O friends:
    friend ostream      &operator<<(ostream &os, const UT_TMatrix2<T> &v)
                        {
                            os << className() << ' ';
                            v.outAsciiNoName(os);
                            return os;
                        }
private:
    static const char   *className(void);

    T    matx[2][2];
};

#include "UT_Vector2.h"

template <>
inline
float   UT_TMatrix2<float>::tolerance() const
{
    return 1e-5f;
}

template <>
inline
double  UT_TMatrix2<double>::tolerance() const
{
    return 1e-11;
}

template <typename T>
inline 
UT_TMatrix2<T>  &UT_TMatrix2<T>::operator=(const UT_Vector2 &vec)
{
    matx[0][0] = matx[0][1] = vec.x();
    matx[1][0] = matx[1][1] = vec.y();
    return *this;
}

template <typename T>
inline
UT_TMatrix2<T>  &UT_TMatrix2<T>::operator+=(const UT_Vector2 &vec)
{
    matx[0][0]+=vec.x(); matx[0][1]+=vec.x();
    matx[1][0]+=vec.y(); matx[1][1]+=vec.y();
    return *this;
}

template <typename T>
inline
UT_TMatrix2<T>  &UT_TMatrix2<T>::operator-=(const UT_Vector2 &vec)
{
    matx[0][0]-=vec.x(); matx[0][1]-=vec.x();
    matx[1][0]-=vec.y(); matx[1][1]-=vec.y();
    return *this;
}

template <typename T>
inline
UT_Vector2       UT_TMatrix2<T>::operator[](unsigned row) const
{
    UT_ASSERT_P(row < 2);
    return UT_Vector2(matx[row]);
}


// Free floating functions:
template <typename T>
inline
UT_TMatrix2<T>      operator+(const UT_Vector2 &vec, const UT_TMatrix2<T> &mat)
{
    return mat+vec;
}

template <typename T>
inline
UT_TMatrix2<T>      operator+(T sc, const UT_TMatrix2<T> &m1)
{
    return m1+sc;
}

template <typename T>
inline
UT_TMatrix2<T>      operator-(const UT_TMatrix2<T> &m1, T sc)
{
    return m1+(-sc);
}

template <typename T>
inline
UT_TMatrix2<T>      operator*(T sc, const UT_TMatrix2<T> &m1)
{
    return m1*sc;
}

template <typename T>
inline
UT_TMatrix2<T>      operator/(const UT_TMatrix2<T> &m1, T scalar)
{
    return m1 * (1.0f/scalar);
}

#if defined( WIN32 ) || defined( LINUX ) || defined(MBSD) || defined(GAMEOS)
    #include "UT_Matrix2.C"
#endif

#endif

---