Matrix3.h

Go to the documentation of this file.

/*
 * Copyright 2015 Jaroslaw Glowacki
 * jarek (dot) glowacki (at) gmail (dot) com
 *
 * This file is part of algebra3d.
 *
 * algebra3d is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * algebra3d is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with algebra3d.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _MATRIX_H_
#define _MATRIX_H_

#include<algebra3d/global.h>

namespace algebra3d {

/* Forward declarations */
template<class fpType>
class Vector3;
template<class fpType>
class Quaternion;

template<class fpType>
class Matrix3 {
    // Friendship declarations
    template<class fpT>
    friend std::istream& operator>>(std::istream &stream, Matrix3<fpT> &mat);

protected:
    static const int ADJUGATE_INDICES[3][3][4][2];

    fpType data[3][3];

protected:
    virtual void initialize(bool identity = false);

public:
    Matrix3(bool identity = false);

    Matrix3(const fpType(&data)[3][3]);

    Matrix3(const fpType *data);

    Matrix3(const Vector3<fpType> &col1, const Vector3<fpType> &col2,
            const Vector3<fpType> &col3);

    Matrix3(fpType m11, fpType m12, fpType m13, //
            fpType m21, fpType m22, fpType m23, //
            fpType m31, fpType m32, fpType m33);

    Matrix3(const Matrix3<fpType> &mat);

    Matrix3(const Vector3<fpType> &cvec);

    Matrix3(Vector3<fpType> axis, fpType angle);

    Matrix3(const Quaternion<fpType> &quat);

    virtual ~Matrix3();

    virtual void set(const fpType data[3][3]);

    virtual void set(const Vector3<fpType> &col1, const Vector3<fpType> &col2,
            const Vector3<fpType> &col3);

    virtual void get(fpType storage[3][3]) const;

    virtual void get(fpType * const col1, fpType * const col2,
            fpType * const col3) const;

    virtual void setColumn(int index, const Vector3<fpType> &col);

    virtual void getColumn(int index, fpType * const &col);

    virtual Vector3<fpType> getColumn(int index);

    fpType getTrace() const;

    virtual void transpose();

    virtual Matrix3 getTranspose() const;

    Vector3<fpType> getAxis() const;

    fpType getAngle() const;

    virtual void invert();

    virtual Matrix3 getInverse() const;

    virtual fpType det();

    virtual bool isOrthogonal();

    virtual void operator=(const Matrix3 &mat);

    virtual const fpType (&operator[](int i1) const)[3];

virtual fpType (&operator[](int i1))[3];

    virtual bool compare(const Matrix3<fpType> &mat, const fpType &precision =
            PRECISION) const;

    virtual bool operator==(const Matrix3 &mat) const;

    virtual bool operator!=(const Matrix3 &mat) const;

    virtual void operator+=(const Matrix3 &mat);

    virtual Matrix3 operator+(const Matrix3 &mat) const;

    virtual Matrix3 operator-() const;

    virtual void operator-=(const Matrix3 &mat);

    virtual Matrix3 operator-(const Matrix3 &mat) const;

    virtual void operator*=(const Matrix3 &mat);

    virtual Matrix3 operator*(const Matrix3 &mat) const;

    virtual Vector3<fpType> operator*(const Vector3<fpType> &vec) const;

    virtual void operator*=(const fpType &scale);

    virtual Matrix3 operator*(const fpType &scale) const;

    virtual void operator/=(const fpType &scale);

    virtual Matrix3 operator/(const fpType &scale) const;
};

template<class fpType>
Matrix3<fpType> operator*(const double &scale, const Matrix3<fpType> &mat);

template<class fpType>
Matrix3<fpType> operator*(const float &scale, const Matrix3<fpType> &mat);

template<class fpType>
std::ostream& operator<<(std::ostream &stream, const Matrix3<fpType> &mat);

template<class fpType>
std::istream& operator>>(std::istream &stream, Matrix3<fpType> &mat);

typedef Matrix3<double> Matrix3D;

typedef Matrix3<float> Matrix3F;

} /* namespace algebra3d */

#endif /* _MATRIX_H_ */