matrix and vector; tests

TheGame/TheGame.pro

 TARGET = TheGame
 TEMPLATE = app
 
+CONFIG += c++11
 
 SOURCES += main.cpp\
         mainwindow.cpp \

UGameEngine/UGameEngine.pro

 TARGET = UGameEngine
 TEMPLATE = lib
 
+CONFIG += c++11
+
 DEFINES += UGAMEENGINE_LIBRARY
 
 SOURCES += engine/ugameengine.cpp \

UGameEngine/utils/matrixmxn.h

 
     bool equal(const T& other) const;
 
+    T& fill(double k);
+    T& fill(double scalars[M][N]);
+
     T& add(double k);
     T& add(double scalars[M][N]);
     T& add(const T& other);
     T& sub(const T& other);
 
     T& mult(double k);
-    uge_gm_tmpl_p MatrixMxN<M, P> mult(double scalars[N][P]);
-    uge_gm_tmpl_p MatrixMxN<M, P> mult(const MatrixMxN<N, P>& other);
+    T& mult(double scalars[M][N]);
+    T& mult(const T& other);
+    uge_gm_tmpl_p MatrixMxN<M, P> multMatrix(double scalars[N][P]);
+    uge_gm_tmpl_p MatrixMxN<M, P> multMatrix(const MatrixMxN<N, P>& other);
 
     T& div(double k);
     T& div(double scalars[M][N]);
     T& div(const T& other);
 
+    T operator+() const;
+    T operator+(const double& k) const;
+    T& operator+=(const double& k);
+    T operator+(const T& other) const;
+    T& operator+=(const T& other);
+
+    T operator-() const;
+    T operator-(const double& k) const;
+    T& operator-=(const double& k);
+    T operator-(const T& other) const;
+    T& operator-=(const T& other);
+
+    T operator*(const double& k) const;
+    T& operator*=(const double& k);
+    T operator*(const T& other) const;
+    T& operator*=(const T& other);
+
+    T operator/(const double& k) const;
+    T& operator/=(const double& k);
+    T operator/(const T& other) const;
+    T& operator/=(const T& other);
+
+    bool operator==(const T& other) const;
+    bool operator!=(const T& other) const;
+
+    bool operator!() const;
+    operator bool() const;
+
 protected:
     double _scalars[M][N];
 

UGameEngine/utils/matrixmxn.hxx

 
 uge_gm_tmpl_mn MatrixMxN<M, N>::MatrixMxN()
 {
-    for (int i = 0; i < M; ++i) {
-        for (int j = 0; j < N; ++j) {
-            _scalars[i][j] = 0;
-        }
-    }
+    this->fill(0.0);
 }
 
 uge_gm_tmpl_mn MatrixMxN<M, N>::MatrixMxN(double k)
 {
-    for (int i = 0; i < M; ++i) {
-        for (int j = 0; j < N; ++j) {
-            _scalars[i][j] = k;
-        }
-    }
+    this->fill(k);
 }
 
 uge_gm_tmpl_mn MatrixMxN<M, N>::MatrixMxN(double scalars[M][N])
 {
-    for (int i = 0; i < M; ++i) {
-        for (int j = 0; j < N; ++j) {
-            _scalars[i][j] = scalars[i][j];
-        }
-    }
+    this->fill(scalars);
 }
 
 uge_gm_tmpl_mn MatrixMxN<M, N>::~MatrixMxN()
     return _scalars[i][j];
 }
 
-uge_gm_tmpl_mnt T *GenericMatrix<M, N, T>::getThis() const
-{
-    return (T*)this;
-}
-
 uge_gm_tmpl_mnt bool GenericMatrix<M, N, T>::isNull() const
 {
     return equal(T());
     return true;
 }
 
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::fill(double k)
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] = k;
+        }
+    }
+    return *getThis();
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::fill(double scalars[M][N])
+{
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] = scalars[i][j];
+        }
+    }
+    return *getThis();
+}
+
 uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::add(double k)
 {
     return add(T(k));
     return *getThis();
 }
 
-uge_gm_tmpl_mnt uge_gm_tmpl_p MatrixMxN<M, P> GenericMatrix<M, N, T>::mult(double scalars[N][P])
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::mult(double scalars[M][N])
+{
+    return mult(T(scalars));
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::mult(const T &other)
 {
-    return mult(MatrixMxN<N, P>(scalars));
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < N; ++j) {
+            _scalars[i][j] *= other._scalars[i][j];
+        }
+    }
+    return *getThis();
 }
 
-uge_gm_tmpl_mnt uge_gm_tmpl_p MatrixMxN<M, P> GenericMatrix<M, N, T>::mult(const MatrixMxN<N, P>& other)
+uge_gm_tmpl_mnt uge_gm_tmpl_p
+MatrixMxN<M, P> GenericMatrix<M, N, T>::multMatrix(double scalars[N][P])
 {
-    MatrixMxN<N, P> m;
+    return multMatrix(MatrixMxN<N, P>(scalars));
+}
+
+uge_gm_tmpl_mnt uge_gm_tmpl_p
+MatrixMxN<M, P> GenericMatrix<M, N, T>::multMatrix(const MatrixMxN<N, P>& other)
+{
+    MatrixMxN<M, P> m;
+    for (int i = 0; i < M; ++i) {
+        for (int j = 0; j < P; ++j) {
+            double t = 0;
+            for (int k = 0; k < N; ++k) {
+                t += _scalars[i][k] * other._scalars[k][j];
+            }
+            m._scalars[i][j] = t;
+        }
+    }
     return m;
 }
 
     }
     return *getThis();
 }
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator+() const
+{
+    return *getThis();
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator+(const double &k) const
+{
+    return T(*getThis()).add(k);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator+=(const double &k)
+{
+    return add(k);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator+(const T &other) const
+{
+    return T(*getThis()).add(other);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator+=(const T &other)
+{
+    return add(other);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator-() const
+{
+    return T() - (*getThis());
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator-(const double &k) const
+{
+    return T(*getThis()).sub(k);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator-=(const double &k)
+{
+    return sub(k);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator-(const T &other) const
+{
+    return T(*getThis()).sub(other);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator-=(const T &other)
+{
+    return sub(other);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator*(const double &k) const
+{
+    return T(*getThis()).mult(k);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator*=(const double &k)
+{
+    return mult(k);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator*(const T &other) const
+{
+    return T(*getThis()).mult(other);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator*=(const T &other)
+{
+    return mult(other);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator/(const double &k) const
+{
+    return T(*getThis()).div(k);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator/=(const double &k)
+{
+    return div(k);
+}
+
+uge_gm_tmpl_mnt T GenericMatrix<M, N, T>::operator/(const T &other) const
+{
+    return T(*getThis()).div(other);
+}
+
+uge_gm_tmpl_mnt T &GenericMatrix<M, N, T>::operator/=(const T &other)
+{
+    return div(other);
+}
+
+uge_gm_tmpl_mnt bool GenericMatrix<M, N, T>::operator==(const T &other) const
+{
+    return equal(other);
+}
+
+uge_gm_tmpl_mnt bool GenericMatrix<M, N, T>::operator!=(const T &other) const
+{
+    return !equal(other);
+}
+
+uge_gm_tmpl_mnt bool GenericMatrix<M, N, T>::operator!() const
+{
+    return isNull();
+}
+
+uge_gm_tmpl_mnt GenericMatrix<M, N, T>::operator bool() const
+{
+    return !isNull();
+}
+
+uge_gm_tmpl_mnt T *GenericMatrix<M, N, T>::getThis() const
+{
+    return (T*)this;
+}

UGameEngine/utils/vector2d.cpp

 #include "vector2d.h"
 
-VectorXD<2>::VectorXD()
+Vector2D::MatrixMxN()
 {
-    _scalars[0] = 0.0;
-    _scalars[1] = 0.0;
+    _scalars[0][0] = 0.0;
+    _scalars[1][0] = 0.0;
 }
 
-VectorXD<2>::VectorXD(const double scalars[2])
+Vector2D::MatrixMxN(const double scalars[2])
 {
-    _scalars[0] = scalars[0];
-    _scalars[1] = scalars[1];
+    _scalars[0][0] = scalars[0];
+    _scalars[1][0] = scalars[1];
 }
 
-Vector2D::VectorXD(double x, double y)
+Vector2D::MatrixMxN(double x, double y)
 {
-    _scalars[0] = x;
-    _scalars[1] = y;
+    _scalars[0][0] = x;
+    _scalars[1][0] = y;
 }
 
-Vector2D::VectorXD(const VectorXD<2> &other)
+Vector2D::MatrixMxN(const Vector2D &other)
 {
-    _scalars[0] = other._scalars[0];
-    _scalars[1] = other._scalars[1];
+    _scalars[0][0] = other._scalars[0][0];
+    _scalars[1][0] = other._scalars[1][0];
 }
 
-Vector2D::~VectorXD()
+Vector2D::~MatrixMxN()
 {
 }
 
 double Vector2D::getX() const
 {
-    return _scalars[0];
+    return _scalars[0][0];
 }
 
 Vector2D& Vector2D::setX(double x)
 {
-    _scalars[0] = x;
+    _scalars[0][0] = x;
     return *this;
 }
 double Vector2D::getY() const
 {
-    return _scalars[1];
+    return _scalars[1][0];
 }
 
 Vector2D& Vector2D::setY(double y)
 {
-    _scalars[1] = y;
+    _scalars[1][0] = y;
     return *this;
 }
 

UGameEngine/utils/vector2d.h

 
 #include "vectorxd.h"
 
-typedef VectorXD<2> Vector2D;
+typedef MatrixMxN<2, 1> Vector2D;
 
-template<> class VectorXD<2> : public GenericVector<2, VectorXD<2> >
+template<> class MatrixMxN<2, 1> : public GenericVector<2, Vector2D>
 {
 public:
-    VectorXD<2>();
-    VectorXD<2>(const double scalars[2]);
-    VectorXD<2>(double x, double y);
-    VectorXD<2>(const VectorXD<2>& other);
-    virtual ~VectorXD<2>();
+    MatrixMxN<2, 1>();
+    MatrixMxN<2, 1>(const double scalars[2]);
+    MatrixMxN<2, 1>(double x, double y);
+    MatrixMxN<2, 1>(const Vector2D& other);
+    virtual ~MatrixMxN<2, 1>();
 
     double getX() const;
     Vector2D& setX(double x);
     double getY() const;
     Vector2D& setY(double y);
 
-    using GenericVector<2, VectorXD<2> >::add;
+    using GenericVector<2, Vector2D>::add;
     Vector2D& add(double x, double y);
 
-    using GenericVector<2, VectorXD<2> >::sub;
+    using GenericVector<2, Vector2D>::sub;
     Vector2D& sub(double x, double y);
 
-    using GenericVector<2, VectorXD<2> >::dotProduct;
+    using GenericVector<2, Vector2D>::dotProduct;
     double dotProduct(double x, double y) const;
 };
 

UGameEngine/utils/vector3d.cpp

 #include "vector3d.h"
 #include <math.h>
 
-Vector3D::VectorXD()
+Vector3D::MatrixMxN()
 {
-    _scalars[0] = 0.0;
-    _scalars[1] = 0.0;
-    _scalars[2] = 0.0;
+    this->fill(0.0);
 }
 
-Vector3D::VectorXD(const double scalars[3])
+Vector3D::MatrixMxN(double k)
 {
-    _scalars[0] = scalars[0];
-    _scalars[1] = scalars[1];
-    _scalars[2] = scalars[2];
+    this->fill(k);
 }
 
-Vector3D::VectorXD(double x, double y, double z)
+Vector3D::MatrixMxN(const double scalars[3])
 {
-    _scalars[0] = x;
-    _scalars[1] = y;
-    _scalars[2] = z;
+    _scalars[0][0] = scalars[0];
+    _scalars[1][0] = scalars[1];
+    _scalars[2][0] = scalars[2];
 }
 
-Vector3D::VectorXD(const Vector3D &other)
+Vector3D::MatrixMxN(double x, double y, double z)
 {
-    _scalars[0] = other._scalars[0];
-    _scalars[1] = other._scalars[1];
-    _scalars[2] = other._scalars[2];
+    _scalars[0][0] = x;
+    _scalars[1][0] = y;
+    _scalars[2][0] = z;
 }
 
-Vector3D::~VectorXD()
+Vector3D::MatrixMxN(const Vector3D &other)
+{
+    _scalars[0][0] = other._scalars[0][0];
+    _scalars[1][0] = other._scalars[1][0];
+    _scalars[2][0] = other._scalars[2][0];
+}
+
+Vector3D::~MatrixMxN()
 {
 }
 
 double Vector3D::getX() const
 {
-    return _scalars[0];
+    return _scalars[0][0];
 }
 
 Vector3D& Vector3D::setX(double x)
 {
-    _scalars[0] = x;
+    _scalars[0][0] = x;
     return *this;
 }
 double Vector3D::getY() const
 {
-    return _scalars[1];
+    return _scalars[1][0];
 }
 
 Vector3D& Vector3D::setY(double y)
 {
-    _scalars[1] = y;
+    _scalars[1][0] = y;
     return *this;
 }
 double Vector3D::getZ() const
 {
-    return _scalars[2];
+    return _scalars[2][0];
 }
 
 Vector3D& Vector3D::setZ(double z)
 {
-    _scalars[2] = z;
+    _scalars[2][0] = z;
     return *this;
 }
 
 Vector3D &Vector3D::add(double x, double y, double z)
 {
-    _scalars[0] += x;
-    _scalars[1] += y;
-    _scalars[2] += z;
+    _scalars[0][0] += x;
+    _scalars[1][0] += y;
+    _scalars[2][0] += z;
     return *this;
 }
 
 Vector3D &Vector3D::sub(double x, double y, double z)
 {
-    _scalars[0] -= x;
-    _scalars[1] -= y;
-    _scalars[2] -= z;
+    _scalars[0][0] -= x;
+    _scalars[1][0] -= y;
+    _scalars[2][0] -= z;
     return *this;
 }
 

UGameEngine/utils/vector3d.h

 
 #include "vectorxd.h"
 
-typedef VectorXD<3> Vector3D;
+typedef MatrixMxN<3, 1> Vector3D;
 
-template<> class VectorXD<3>: public GenericVector<3, VectorXD<3> >
+template<> class MatrixMxN<3, 1>: public GenericVector<3, Vector3D>
 {
 public:
-    VectorXD<3>();
-    VectorXD<3>(const double scalars[3]);
-    VectorXD<3>(double x, double y, double z);
-    VectorXD<3>(const Vector3D& other);
-    virtual ~VectorXD<3>();
+    MatrixMxN<3, 1>();
+    MatrixMxN<3, 1>(double k);
+    MatrixMxN<3, 1>(const double scalars[3]);
+    MatrixMxN<3, 1>(double x, double y, double z);
+    MatrixMxN<3, 1>(const Vector3D& other);
+    virtual ~MatrixMxN<3, 1>();
 
     double getX() const;
     Vector3D& setX(double x);
     double getZ() const;
     Vector3D& setZ(double z);
 
-    using GenericVector<3, VectorXD<3> >::add;
+    using GenericVector<3, Vector3D>::add;
     Vector3D& add(double x, double y, double z);
 
-    using GenericVector<3, VectorXD<3> >::sub;
+    using GenericVector<3, Vector3D>::sub;
     Vector3D& sub(double x, double y, double z);
 
-    using GenericVector<3, VectorXD<3> >::dotProduct;
+    using GenericVector<3, Vector3D>::dotProduct;
     double dotProduct(double x, double y, double z) const;
 };
 

UGameEngine/utils/vectorxd.h

 #define VECTORXD_H
 
 #include <QDebug>
+#include "matrixmxn.h"
 
 #define tmplx template<unsigned X>
 #define tmpl template<unsigned X, class T>
 
-tmpl class GenericVector
+tmpl class GenericVector: public GenericMatrix<X, 1, T >
 {
 public:
 
+    using GenericMatrix<X, 1, T >::setScalar;
     T& setScalar(unsigned i, double value);
+    using GenericMatrix<X, 1, T >::getScalar;
     double getScalar(unsigned i) const;
 
-    bool isNull() const;
-
-    bool equal(const T& other) const;
-
-    T& add(double k);
-    T& add(double scalars[X]);
-    T& add(const T& other);
-
-    T& sub(double k);
-    T& sub(double scalars[X]);
-    T& sub(const T& other);
-
-    T& mult(double k);
-    T& mult(double scalars[X]);
-    T& mult(const T& other);
-
-    T& div(double k);
-    T& div(double scalars[X]);
-    T& div(const T& other);
-
     double dotProduct(const T& other) const;
 
     T& crossProduct(const T& other);
 
     double norm() const;
 
-    T operator+() const;
-    T operator+(const double& k) const;
-    T& operator+=(const double& k);
-    T operator+(const T& other) const;
-    T& operator+=(const T& other);
-
-    T operator-() const;
-    T operator-(const double& k) const;
-    T& operator-=(const double& k);
-    T operator-(const T& other) const;
-    T& operator-=(const T& other);
-
-    T operator*(const double& k) const;
-    T& operator*=(const double& k);
-    T operator*(const T& other) const;
-    T& operator*=(const T& other);
-
-    T operator/(const double& k) const;
-    T& operator/=(const double& k);
-
-    bool operator==(const T& other) const;
-    bool operator!=(const T& other) const;
-
     double operator[](unsigned i) const;
 
-    bool operator!() const;
-    operator bool() const;
-
 protected:
-    double _scalars[X];
+    using GenericMatrix<X, 1, T >::_scalars;
 
 private:
     T* getThis() const;
 };
 
-tmplx class VectorXD: public GenericVector<X, VectorXD<X> >
+tmplx using VectorXD = MatrixMxN<X, 1>;
+
+tmplx class MatrixMxN<X, 1>: public GenericVector<X, VectorXD<X>>
 {
 public:
-    VectorXD();
-    VectorXD(const double scalars[X]);
-    VectorXD(const VectorXD<X>& other);
+    MatrixMxN();
+    MatrixMxN(double k);
+    MatrixMxN(const double scalars[X]);
+    MatrixMxN(const VectorXD<X>& other);
 
 protected:
-    using GenericVector<X, VectorXD<X> >::_scalars;
+    using GenericMatrix<X, 1, VectorXD<X>>::_scalars;
 };
 
-tmplx QDebug operator<<(QDebug dbg, const VectorXD<X>& v);
+//tmplx QDebug operator<<(QDebug dbg, const VectorXD<X>& v);
 
 #include "vectorxd.hxx"
 
 #endif // VECTORXD_H
+
+
+
+
+
+

UGameEngine/utils/vectorxd.hxx

 #define tmplx template<unsigned X>
 #define tmpl template<unsigned X, class T>
 
-tmplx VectorXD<X>::VectorXD()
+tmplx VectorXD<X>::MatrixMxN()
 {
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] = 0;
-    }
-}
-
-tmplx VectorXD<X>::VectorXD(const double scalars[X])
-{
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] = scalars[i];
-    }
-}
-
-tmplx VectorXD<X>::VectorXD(const VectorXD<X>& other)
-{
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] = other._scalars[i];
-    }
-}
-
-tmpl T& GenericVector<X, T>::setScalar(unsigned i, double value)
-{
-    _scalars[i] = value;
-    return *getThis();
-}
-
-tmpl double GenericVector<X, T>::getScalar(unsigned i) const
-{
-    return _scalars[i];
-}
-
-tmpl bool GenericVector<X, T>::isNull() const
-{
-    return equal(T());
-}
-
-tmpl bool GenericVector<X, T>::equal(const T &other) const
-{
-    for (unsigned i = 0; i < X; ++i) {
-        if (_scalars[i] != other._scalars[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
-tmpl T &GenericVector<X, T>::add(double k)
-{
-    double scalars[X];
-    for (unsigned i = 0; i < X; ++i) {
-        scalars[i] = k;
-    }
-    return add(T(scalars));
-}
-
-tmpl T &GenericVector<X, T>::add(double scalars[X])
-{
-    return add(T(scalars));
-}
-
-tmpl T& GenericVector<X, T>::add(const  T &other)
-{
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] += other._scalars[i];
-    }
-    return *getThis();
-}
-
-tmpl T &GenericVector<X, T>::sub(double k)
-{
-    double scalars[X];
-    for (unsigned i = 0; i < X; ++i) {
-        scalars[i] = k;
-    }
-    return sub(T(scalars));
-}
-
-tmpl T &GenericVector<X, T>::sub(double scalars[X])
-{
-    return sub(T(scalars));
-}
-
-tmpl T& GenericVector<X, T>::sub(const T &other)
-{
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] -= other._scalars[i];
-    }
-    return *getThis();
+    this->fill(0);
 }
 
-tmpl T &GenericVector<X, T>::mult(double k)
+tmplx VectorXD<X>::MatrixMxN(double k)
 {
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] *= k;
-    }
-    return *getThis();
+    this->fill(k);
 }
 
-tmpl T &GenericVector<X, T>::mult(double scalars[X])
+tmplx VectorXD<X>::MatrixMxN(const double scalars[X])
 {
-    return mult(T(scalars));
+    this->fill(scalars);
 }
 
-tmpl T &GenericVector<X, T>::mult(const T &other)
+tmplx VectorXD<X>::MatrixMxN(const VectorXD<X>& other)
 {
     for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] *= other._scalars[i];
+        _scalars[i] = other._scalars[i];
     }
-    return *getThis();
 }
 
-tmpl T &GenericVector<X, T>::div(double k)
+tmpl T& GenericVector<X, T>::setScalar(unsigned i, double value)
 {
-    double scalars[X];
-    for (unsigned i = 0; i < X; ++i) {
-        scalars[i] = k;
-    }
-    return div(T(scalars));
+    return setScalar(i, 0,value);
 }
 
-tmpl T &GenericVector<X, T>::div(double scalars[X])
+tmpl double GenericVector<X, T>::getScalar(unsigned i) const
 {
-    return div(T(scalars));
+    return getScalar(i, 0);
 }
 
-tmpl T &GenericVector<X, T>::div(const T &other)
+tmpl double GenericVector<X, T>::operator[](unsigned i) const
 {
-    for (unsigned i = 0; i < X; ++i) {
-        _scalars[i] /= other._scalars[i];
-    }
-    return *getThis();
+    return getScalar(i);
 }
 
 tmpl double GenericVector<X, T>::dotProduct(const T &other) const
 {
     double total = 0;
     for (unsigned i = 0; i < X; ++i) {
-        total += _scalars[i] * other._scalars[i];
+        total += _scalars[i][0] * other._scalars[i][0];
     }
     return total;
 }
     for (unsigned i = 0; i < X; ++i) {
         unsigned j = (i + 1) % X;
         unsigned k = (i + 2) % X;
-        _scalars[i] = (t._scalars[j] * other._scalars[k]) - (t._scalars[k] * other._scalars[j]);
+        _scalars[i][0] = (t._scalars[j][0] * other._scalars[k][0]) - (t._scalars[k][0] * other._scalars[j][0]);
     }
     return *getThis();
 }
 {
     double total = 0;
     for (unsigned i = 0; i < X; ++i) {
-        total += _scalars[i] * _scalars[i];
+        total += _scalars[i][0] * _scalars[i][0];
     }
     return sqrt(total);
 }
 
-tmpl T GenericVector<X, T>::operator+() const
-{
-    return *getThis();
-}
-
-tmpl T GenericVector<X, T>::operator+(const double &k) const
-{
-    return T(*getThis()).add(k);
-}
-
-tmpl T &GenericVector<X, T>::operator+=(const double &k)
-{
-    return add(k);
-}
-
-tmpl T GenericVector<X, T>::operator+(const T &other) const
-{
-    T v = *getThis();
-    return v.add(other);
-}
-
-tmpl T &GenericVector<X, T>::operator+=(const T &other)
-{
-    return add(other);
-}
-
-tmpl T GenericVector<X, T>::operator-() const
-{
-    double scalars[X];
-    for (unsigned i = 0; i < X; ++i) {
-        scalars[i] = -_scalars[i];
-    }
-    return T(scalars);
-}
-
-tmpl T GenericVector<X, T>::operator-(const double &k) const
-{
-    return T(*getThis()).sub(k);
-}
-
-tmpl T &GenericVector<X, T>::operator-=(const double &k)
-{
-    return sub(k);
-}
-
-tmpl T GenericVector<X, T>::operator-(const T &other) const
-{
-    return T(*getThis()).sub(other);
-}
-
-tmpl T &GenericVector<X, T>::operator-=(const T &other)
-{
-    return sub(other);
-}
-
-tmpl T GenericVector<X, T>::operator*(const double &k) const
-{
-    return T(*getThis()).mult(k);
-}
-
-tmpl T &GenericVector<X, T>::operator*=(const double &k)
-{
-    return mult(k);
-}
-
-tmpl T GenericVector<X, T>::operator*(const T &other) const
-{
-    return T(*getThis()).mult(other);
-}
-
-tmpl T &GenericVector<X, T>::operator*=(const T &other)
-{
-    dotProduct(other);
-    return *getThis();
-}
-
-tmpl T GenericVector<X, T>::operator/(const double &k) const
-{
-    return T(*getThis()).div(k);
-}
-
-tmpl T &GenericVector<X, T>::operator/=(const double &k)
-{
-    return div(k);
-}
-
-tmpl bool GenericVector<X, T>::operator==(const T &other) const
-{
-    return equal(other);
-}
-
-tmpl bool GenericVector<X, T>::operator!=(const T &other) const
-{
-    return !equal(other);
-}
-
-tmpl double GenericVector<X, T>::operator[](unsigned i) const
-{
-    return getScalar(i);
-}
-
-tmpl bool GenericVector<X, T>::operator!() const
-{
-    return isNull();
-}
-
-tmpl GenericVector<X, T>::operator bool() const
-{
-    return !isNull();
-}
-
 tmpl T* GenericVector<X, T>::getThis() const
 {
     return (T*)this;
 }
 
-tmpl QDebug operator<<(QDebug dbg, const T &v)
-{
-    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
-}
+//tmpl QDebug operator<<(QDebug dbg, const T &v)
+//{
+//    return dbg.nospace() << "(" << v.getX() << ", " << v.getY() << ", " << v.getZ() << ")";
+//}

tests/testmatrix3x3.cpp

 
 void TestMatrix3x3::isNull1Op()
 {
-//    double scalars[3][3] = {{0.0, 1.0, 2.0},
-//                            {3.0, 4.0, 5.0},
-//                            {6.0, 7.0, 8.0}};
-//    Matrix3x3 m(scalars);
-//    QCOMPARE((bool)m, false);
+    double scalars[3][3] = {{0.0, 1.0, 2.0},
+                            {3.0, 4.0, 5.0},
+                            {6.0, 7.0, 8.0}};
+    Matrix3x3 m(scalars);
+    QCOMPARE((bool)m, true);
 }
 
 void TestMatrix3x3::isNull2()
 
 void TestMatrix3x3::isNull2Op()
 {
-//    Matrix3x3 m;
-//    QCOMPARE((bool)m, true);
+    Matrix3x3 m;
+    QCOMPARE((bool)m, false);
+}
+
+void TestMatrix3x3::mult1()
+{
+    double scalars1[3][3] = {{42.0, 5.0, 6.0},
+                            {2.0, 10.0, 9.0},
+                            {69.0, 35.0, 51.0}};
+    double scalars2[3][3] = {{26.0, 17.0, 35.0},
+                            {6.0, 48.0, 52.0},
+                            {12.0, 25.0, 62.0}};
+    double scalars3[3][3] = {{1194.0, 1104.0, 2102.0},
+                            {220.0, 739.0, 1148.0},
+                            {2616.0, 4128.0, 7397.0}};
+    Matrix3x3 m1(scalars1);
+    Matrix3x3 m2(scalars2);
+    Matrix3x3 m3(scalars3);
+    Matrix3x3 m = m1.multMatrix(m2);
+    QCOMPARE(m.equal(m3), true);
 }

tests/testmatrix3x3.h

     void isNull1Op();
     void isNull2();
     void isNull2Op();
+
+    void mult1();
 };
 
 #endif // TESTMATRIX3X3_H

tests/tests.pro

 TARGET = tests
 TEMPLATE = app
 
+CONFIG += c++11
 
 SOURCES += \
     testvector3d.cpp \