SXMath.h

#ifndef _SX_MATH_H_
#define _SX_MATH_H_

#include <export/Export.h>

namespace sx {

    const float Pi =  3.1415926535f;

    const float Tau = 6.2831853072f;

    const float Exp = 2.7182818285f;

    class Matrix;
    class DMatrix;
    class DVector;

    class Vector {
    public:

        float *elements;

        EXPA Vector();

        EXPA Vector(float v);

        EXPA Vector(float x,float y);

        EXPA Vector(float x,float y,float z);

        EXPA Vector(float x,float y,float z,float w);

        EXPA Vector(const float *v);

        EXPA Vector(const DVector &vector);

        EXPA Vector(const Vector &vector);

        EXPA Vector &operator = (const Vector &v);

        EXPA virtual ~Vector();

        EXPA float &operator [] (unsigned int index);

        EXPA float operator [] (unsigned int index) const;

        EXPA Vector &operator << (const Vector &v);

        EXPA Vector &operator << (const float *v);

        EXPA const Vector &operator >> (Vector &v) const;

        EXPA const Vector &operator >> (float *v) const;

        EXPA Vector &add(const Vector &v);

        EXPA Vector &add(float x);

        EXPA friend Vector operator +(const Vector &v1, const Vector &v2);

        EXPA friend Vector operator +(const Vector &v, float x);

        EXPA friend Vector operator +(float x, const Vector &v);

        EXPA Vector &crossmult(const Vector &v);

        EXPA friend Vector operator %(const Vector &v1, const Vector &v2);

        EXPA Vector &scalarmult(float s);

        EXPA friend Vector operator *(const Vector &v, float x);

        EXPA friend Vector operator *(float x, const Vector &v);

        EXPA friend Vector operator -- (const Vector &v);

        EXPA float innerprod(const Vector &v) const;

        EXPA friend float operator *(const Vector &v1, const Vector &v2);

        EXPA Vector &leftmult(const Matrix &m);

        EXPA Vector &rightmult(const Matrix &m);

        EXPA friend Vector operator *(const Matrix &m, const Vector &v);

        EXPA friend Vector operator *(const Vector &v, const Matrix &m);

        EXPA Vector &normalize();

        EXPA float distance(const Vector &v) const;

        EXPA float length() const;

        EXPA Vector &random();

        EXPA Vector &homogenize();

        EXPA bool equals(const Vector &v) const;

        EXPA bool equals(const Vector &v, float epsilon) const;

    };

    class Matrix {
    public:

        float *elements;

        EXPA Matrix();

        EXPA Matrix(float m);

        EXPA Matrix(
            float m00, float m01,
            float m10, float m11);

        EXPA Matrix(
            float m00, float m01, float m02,
            float m10, float m11, float m12,
            float m20, float m21, float m22);

        EXPA Matrix(
            float m00, float m01, float m02, float m03,
            float m10, float m11, float m12, float m13,
            float m20, float m21, float m22, float m23,
            float m30, float m31, float m32, float m33);

        EXPA Matrix(const Vector &m0, const Vector &m1, const Vector &m2, const Vector &m3);

        EXPA Matrix(const float *m);

        EXPA Matrix(const DMatrix &m);

        EXPA Matrix(const Matrix &m);

        EXPA Matrix &operator = (const Matrix &m);

        EXPA virtual ~Matrix();

        EXPA float &operator [] (unsigned int index);

        EXPA float operator [] (unsigned int index) const;

        EXPA Matrix &operator << (const Matrix &m);

        EXPA Matrix &operator << (const float *m);

        EXPA const Matrix &operator >> (Matrix &m) const;

        EXPA const Matrix &operator >> (float *m) const;

        EXPA Matrix &add(const Matrix &m);

        EXPA Matrix &add(float m);

        EXPA friend Matrix operator + (const Matrix &m1, const Matrix &m2);

        EXPA friend Matrix operator + (const Matrix &m, float x);

        EXPA friend Matrix operator + (float x, const Matrix &m);

        EXPA Matrix &leftmult(const Matrix &m);

        EXPA Matrix &rightmult(const Matrix &m);

        EXPA Matrix &scalarmult(float s);

        EXPA friend Matrix operator * (const Matrix &m1, const Matrix &m2);

        EXPA friend Matrix operator * (const Matrix &m, float s);

        EXPA friend Matrix operator * (float s, const Matrix &m);

        EXPA friend Matrix operator - (const Matrix &m);

        EXPA Matrix &transpose();

        EXPA friend Matrix operator ! (const Matrix &m);

        EXPA Matrix &identity();

        EXPA Matrix &inverse();

        EXPA friend Matrix operator ^ (const Matrix &m, int power);

        EXPA float determinant() const;

        EXPA float cofactor(unsigned int row, unsigned int column) const;

        EXPA Matrix &random();

        EXPA Matrix &rotate(const Vector &m, float angle);

        EXPA Matrix &translate(const Vector &v);

        EXPA Matrix &scale(const Vector &v);

        EXPA Matrix &shear(const Vector &v);

        EXPA Matrix &submatrix();

        EXPA Matrix &normalMatrix();

        EXPA Matrix &viewMatrix(const Vector &position, const Vector &view, const Vector &up);

        EXPA Matrix &perspectiveMatrix(float angle, float width, float height, float znear, float zfar);
        
        EXPA Matrix &orthographicPerspeciveMatrix(float left, float right, float bottom, float top, float znear, float zfar);

        EXPA bool equals(const Matrix &m) const;

        EXPA bool equals(const Matrix &m, float epsilon) const;
    };

    class DVector {
    public:

        double *elements;

        EXPA DVector();

        EXPA DVector(double v);

        EXPA DVector(double x,double y);

        EXPA DVector(double x,double y,double z);

        EXPA DVector(double x,double y,double z,double w);

        EXPA DVector(const double *v);

        EXPA DVector(const Vector &vector);

        EXPA DVector(const DVector &vector);

        EXPA DVector &operator = (const DVector &v);

        EXPA virtual ~DVector();

        EXPA double &operator [] (unsigned int index);

        EXPA double operator [] (unsigned int index) const;

        EXPA DVector &operator << (const DVector &v);

        EXPA DVector &operator << (const double *v);

        EXPA const DVector &operator >> (DVector &v) const;

        EXPA const DVector &operator >> (double *v) const;

        EXPA DVector &add(const DVector &v);

        EXPA DVector &add(double x);

        EXPA friend DVector operator +(const DVector &v1, const DVector &v2);

        EXPA friend DVector operator +(const DVector &v, double x);

        EXPA friend DVector operator +(double x, const DVector &v);

        EXPA DVector &crossmult(const DVector &v);

        EXPA friend DVector operator %(const DVector &v1, const DVector &v2);

        EXPA DVector &scalarmult(double s);

        EXPA friend DVector operator *(const DVector &v, double x);

        EXPA friend DVector operator *(double x, const DVector &v);

        EXPA friend DVector operator -- (const DVector &v);

        EXPA double innerprod(const DVector &v) const;

        EXPA friend double operator *(const DVector &v1, const DVector &v2);

        EXPA DVector &leftmult(const DMatrix &m);

        EXPA DVector &rightmult(const DMatrix &m);

        EXPA friend DVector operator *(const DMatrix &m, const DVector &v);

        EXPA friend DVector operator *(const DVector &v, const DMatrix &m);

        EXPA DVector &normalize();

        EXPA double distance(const DVector &v) const;

        EXPA double length() const;

        EXPA DVector &random();

        EXPA DVector &homogenize();

        EXPA bool equals(const DVector &v) const;

        EXPA bool equals(const DVector &v, double epsilon) const;

    };

    class DMatrix {
    public:

        double *elements;

        EXPA DMatrix();

        EXPA DMatrix(double m);

        EXPA DMatrix(
            double m00, double m01,
            double m10, double m11);

        EXPA DMatrix(
            double m00, double m01, double m02,
            double m10, double m11, double m12,
            double m20, double m21, double m22);

        EXPA DMatrix(
            double m00, double m01, double m02, double m03,
            double m10, double m11, double m12, double m13,
            double m20, double m21, double m22, double m23,
            double m30, double m31, double m32, double m33);

        EXPA DMatrix(const DVector &m0, const DVector &m1, const DVector &m2, const DVector &m3);

        EXPA DMatrix(const double *m);

        EXPA DMatrix(const Matrix &m);

        EXPA DMatrix(const DMatrix &m);

        EXPA DMatrix &operator = (const DMatrix &m);

        EXPA virtual ~DMatrix();

        EXPA double &operator [] (unsigned int index);

        EXPA double operator [] (unsigned int index) const;

        EXPA DMatrix &operator << (const DMatrix &m);

        EXPA DMatrix &operator << (const double *m);

        EXPA const DMatrix &operator >> (DMatrix &m) const;

        EXPA const DMatrix &operator >> (double *m) const;

        EXPA DMatrix &add(const DMatrix &m);

        EXPA DMatrix &add(double m);

        EXPA friend DMatrix operator + (const DMatrix &m1, const DMatrix &m2);

        EXPA friend DMatrix operator + (const DMatrix &m, double x);

        EXPA friend DMatrix operator + (double x, const DMatrix &m);

        EXPA DMatrix &leftmult(const DMatrix &m);

        EXPA DMatrix &rightmult(const DMatrix &m);

        EXPA DMatrix &scalarmult(double s);

        EXPA friend DMatrix operator * (const DMatrix &m1, const DMatrix &m2);

        EXPA friend DMatrix operator * (const DMatrix &m, double s);

        EXPA friend DMatrix operator * (double s, const DMatrix &m);

        EXPA friend DMatrix operator - (const DMatrix &m);

        EXPA DMatrix &transpose();

        EXPA friend DMatrix operator ! (const DMatrix &m);

        EXPA DMatrix &identity();

        EXPA DMatrix &inverse();

        EXPA friend DMatrix operator ^ (const DMatrix &m, int power);

        EXPA double determinant() const;

        EXPA double cofactor(unsigned int row, unsigned int column) const;

        EXPA DMatrix &random();

        EXPA DMatrix &rotate(const DVector &m, double angle);

        EXPA DMatrix &translate(const DVector &v);

        EXPA DMatrix &scale(const DVector &v);

        EXPA DMatrix &shear(const DVector &v);

        EXPA DMatrix &submatrix();

        EXPA DMatrix &normalMatrix();

        EXPA DMatrix &viewMatrix(const DVector &position, const DVector &view, const DVector &up);

        EXPA DMatrix &perspectiveMatrix(double angle, double width, double height, double znear, double zfar);
        
        EXPA DMatrix &orthographicPerspeciveMatrix(double left, double right, double bottom, double top, double znear, double zfar);

        EXPA bool equals(const DMatrix &m) const;

        EXPA bool equals(const DMatrix &m, double epsilon) const;
    };

}

#endif