|| ||           || Doxygen's  

---

HxMatrix.h

/*
 *  Copyright (c) 1998, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *
 *  Author(s):
 *  Dennis Koelma (koelma@wins.uva.nl)
 *  Edo Poll (poll@wins.uva.nl)
 *  Jan-Mark Geusebroek (poll@wins.uva.nl)
 */

#ifndef HxMatrix_h
#define HxMatrix_h

#include "HxStd.h"
#include "HxIo.h"
#include "HxVec3Double.h"

class L_HXBASIS HxVector;

class L_HXBASIS HxMatrix {
public:


                        HxMatrix();

                        HxMatrix(int nrow, int ncol);

                        HxMatrix(int nrow, int ncol, double a);

                        HxMatrix(int nrow, int ncol, double* data);

                        HxMatrix(const HxMatrix& m);

                        HxMatrix(const HxVector& v);

                        HxMatrix(const HxVector& v1, const HxVector& v2);

                        HxMatrix(const HxVector& v1, const HxVector& v2,
                            const HxVector& v3);

                        HxMatrix(const HxVector& v1, const HxVector& v2,
                            const HxVector& v3, const HxVector& v4);

                        HxMatrix(const HxVector& v1, const HxVector& v2,
                            const HxVector& v3, const HxVector& v4,
                            const HxVector& v5);

                        HxMatrix(const HxVector& v1, const HxVector& v2,
                            const HxVector& v3, const HxVector& v4,
                            const HxVector& v5, const HxVector& v6);

                        ~HxMatrix();


    static HxMatrix     translate2d(double x, double y);

    static HxMatrix     scale2d(double sx, double sy);

    static HxMatrix     rotate2d(double alpha);

    static HxMatrix     rotate2dDeg(double alpha);

    static HxMatrix     reflect2d(int doX, int doY);

    static HxMatrix     shear2d(double sx, double sy);

    static HxMatrix     translate3d(double x, double y, double z);

    static HxMatrix     scale3d(double sx, double sy, double sz);

    static HxMatrix     rotateX3d(double alpha);

    static HxMatrix     rotateX3dDeg(double alpha);

    static HxMatrix     rotateY3d(double alpha);

    static HxMatrix     rotateY3dDeg(double alpha);

    static HxMatrix     rotateZ3d(double alpha);

    static HxMatrix     rotateZ3dDeg(double alpha);

    static HxMatrix     reflect3d(int doX, int doY, int doZ);

    static HxMatrix     projection(double f);

    static HxMatrix     camera(double f);

    static HxMatrix     lift2dTo3dXY();


    int                 nRow() const;

    int                 nCol() const;

    int                 nElem() const;

    int                 valid() const;


    HxMatrix&           operator=(double a);

    HxMatrix&           operator=(const HxMatrix& m);


    double*             operator[](int i) const;

    HxMatrix            operator-() const;

    friend HxMatrix     operator*(const HxMatrix& a, double          b);

    friend HxMatrix             operator*(double          a, const HxMatrix& b);

    friend L_HXBASIS HxMatrix   operator*(const HxMatrix& a, const HxMatrix& b);

    friend L_HXBASIS HxVector   operator*(const HxVector& a, const HxMatrix& b);

    friend L_HXBASIS HxVector   operator*(const HxMatrix& a, const HxVector& b);

    friend HxMatrix             operator/(const HxMatrix& a, double          b);

    friend HxMatrix             operator/(double          a, const HxMatrix& b);

    friend L_HXBASIS HxMatrix   operator+(const HxMatrix& a, const HxMatrix& b);

    friend HxMatrix             operator+(const HxMatrix& a, double          b);

    friend HxMatrix             operator+(double          a, const HxMatrix& b);

    friend L_HXBASIS HxMatrix   operator-(const HxMatrix& a, const HxMatrix& b);

    friend HxMatrix             operator-(const HxMatrix& a, double          b);

    friend HxMatrix             operator-(double          a, const HxMatrix& b);

    friend L_HXBASIS int        operator==(const HxMatrix& a,const HxMatrix& b);

    friend int                  operator!=(const HxMatrix& a,const HxMatrix& b);


    friend L_HXBASIS HxVec3Double operator*(const HxVec3Double& a, const HxMatrix& b);

    friend L_HXBASIS HxVec3Double operator*(const HxMatrix& a, const HxVec3Double& b);


    HxMatrix            i() const;

    HxMatrix            t() const;

    HxMatrix            svd(HxVector& W, HxMatrix& V) const;

    HxMatrix            add(const HxMatrix& b) const;

    HxMatrix            add(const double val) const;

    HxMatrix            sub(const HxMatrix& b) const;

    HxMatrix            sub(const double val) const;

    HxMatrix            mul(const HxMatrix& b) const;

    HxMatrix            mul(const HxVector& v) const;

    HxMatrix            mul(const double val) const;

    HxMatrix            div(const double val) const;

    HxMatrix            sin() const;

    HxMatrix            cos() const;

    HxMatrix            tan() const;

    HxMatrix            sinh() const;

    HxMatrix            cosh() const;

    HxMatrix            tanh() const;

    HxMatrix            exp() const;

    HxMatrix            log() const;

    HxMatrix            sqrt() const;

    HxMatrix            abs() const;

    HxMatrix            sgn() const;

    HxMatrix            map(double (*f)(double)) const;

    STD_OSTREAM&        put(STD_OSTREAM& os) const;
private:
    friend class HxVector;

    int                 _nr; // number of rows
    int                 _nc; // number of columns
    double*             _data;  // data pointer
};

#include "HxVector.h"


inline
HxMatrix::HxMatrix()
{
    _nr = 0;
    _nc = 0;
    _data = 0;
}

inline
HxMatrix::HxMatrix(int nRow, int nCol)
{
    _nr = nRow;
    _nc = nCol;
    _data = new double[_nr * _nc];
}
    
inline
HxMatrix::HxMatrix(int nRow, int nCol, double a)
{
    _nr = nRow;
    _nc = nCol;
    _data = new double[_nr * _nc];

    double* t = _data;
    int i = nElem();
    while (--i >= 0)
        *t++ = a;
}

inline
HxMatrix::HxMatrix(int nRow, int nCol, double *data)
{
    _nr = nRow;
    _nc = nCol;
    _data = data;
}

inline HxMatrix::HxMatrix(const HxMatrix& m)
{
    _nr = m.nRow();
    _nc = m.nCol();
    _data = new double[_nr * _nc];

    double* t = m._data;
    double* u = _data;
    int i = m.nElem();
    while (--i >= 0)
        *u++ = *t++;
}

inline HxMatrix::~HxMatrix()
{
    delete [] _data;
}

inline int
HxMatrix::nRow() const
{
    return _nr;
}

inline int
HxMatrix::nCol() const
{
    return _nc;
}

inline int
HxMatrix::nElem() const
{
    return _nr * _nc;
}

inline int
HxMatrix::valid() const
{
    return ((_nc != 0) && (_nr != 0));
}

inline HxMatrix&
HxMatrix::operator=(double a)
{
    int i = nElem();
    double *t = _data;
    while (--i >= 0)
        *t++ = a;
    return *this;
}

inline HxMatrix&
HxMatrix::operator=(const HxMatrix& m)
{
    if (this != &m) {
        delete [] _data;
        _nr = m.nRow();
        _nc = m.nCol();
        _data = new double [_nr * _nc];
        double *t = _data;
        double *u = m._data;
        int i = m.nElem();
        while (--i >= 0)
            *t++ = *u++;
    }
    return *this;
}

inline double*
HxMatrix::operator[](int i) const
{
    return &_data[i*_nc];
}

inline HxMatrix
HxMatrix::operator-() const
{
    HxMatrix m(*this);
    double* t = m._data;
    double* u = _data;
    int i = nElem();
    while (--i >= 0)
        *t++ = -(*u++);
    return m;
}

inline HxMatrix
operator*(const HxMatrix& a, double b)
{
    HxMatrix m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ * b;
    return m;
}

inline HxMatrix 
operator*(double a, const HxMatrix &b)
{
    HxMatrix m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
    *t++ = a * *u++;
    return m;
}

inline HxMatrix 
operator/(const HxMatrix &a, double b)
{
    HxMatrix m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ / b;
    return m;
}

inline HxMatrix 
operator/(double a, const HxMatrix &b)
{
    HxMatrix m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
        *t++ = a / *u++;
    return m;
}

inline HxMatrix 
operator+(const HxMatrix &a, double b)
{
    HxMatrix m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ + b;
    return m;
}

inline HxMatrix 
operator+(double a, const HxMatrix &b)
{
    HxMatrix m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
        *t++ = a + *u++;
    return m;
}

inline HxMatrix 
operator-(const HxMatrix &a, double b)
{
    HxMatrix m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ - b;
    return m;
}

inline HxMatrix 
operator-(double a, const HxMatrix &b)
{
    HxMatrix m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
        *t++ = a - *u++;
    return m;
}

inline int 
operator!=(const HxMatrix &a, const HxMatrix &b)
{
    return !(a == b);
}

inline HxMatrix
HxMatrix::t() const
{
    HxMatrix m(nCol(), nRow());
    int i, j;
    for (i=0 ; i<nRow() ; i++)
        for (j=0 ; j<nCol() ; j++)
            m[j][i] = (*this)[i][j];
    return m;
}

inline STD_OSTREAM&
operator<<(STD_OSTREAM& os, const HxMatrix v)
{
    return v.put(os);
}

inline HxMatrix
HxMatrix::map(double (*f)(double)) const
{
    HxMatrix m(*this);
    double* t = m._data;
    double* u = _data;
    int i = nElem();
    while (--i >= 0)
            *t++ = f(*u++);
    return m;
}

L_HXBASIS HxMatrix     operator*(const HxMatrix& a, const HxMatrix& b);
L_HXBASIS HxVector     operator*(const HxVector& a, const HxMatrix& b);
L_HXBASIS HxVector     operator*(const HxMatrix& a, const HxVector& b);
L_HXBASIS HxMatrix     operator+(const HxMatrix& a, const HxMatrix& b);
L_HXBASIS HxMatrix     operator-(const HxMatrix& a, const HxMatrix& b);
L_HXBASIS int          operator==(const HxMatrix& a, const HxMatrix& b);
L_HXBASIS HxVec3Double operator*(const HxVec3Double& a, const HxMatrix& b);
L_HXBASIS HxVec3Double operator*(const HxMatrix& a, const HxVec3Double& b);

#endif

---