maths.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2006 by Matthew Williams   *
 *   matt@milliams.com   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Library General Public License as       *
 *   published by the Free Software Foundation; either version 2 of the    *
 *   License, or (at your option) any later version.                       *
 *                                                                         *
 *   This program 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 Library General Public     *
 *   License along with this program; if not, write to the                 *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef MATHS_H
#define MATHS_H

#include <cmath>
#include <vector>

namespace sparkle
{

    struct VecXY
    {
        double x;
        double y;
        void operator()(double newX, double newY)
        {
            x = newX;
            y = newY;
        }
    };
    

    template<class T>
    class Vector
    {
        public:

            Vector(T startX, T startY, T startZ = 0) : x(startX), y(startY), z(startZ), real(true) {};
            Vector(const Vector& copyVector) : x(copyVector.getX()), y(copyVector.getY()), z(copyVector.getZ()), real(copyVector.isReal()) {}
            Vector(VecXY copyVecXY) : x(copyVecXY.x), y(copyVecXY.y), z(0.0), real(true) {}
            Vector(bool status = true) {real = status;}
            ~Vector() {};
            

            void setX(T newX) {x = newX;}
            void setY(T newY) {y = newY;}
            void setZ(T newZ) {z = newZ;}
            

            T getX() const {return x;}
            T getY() const {return y;}
            T getZ() const {return z;}
            T getLength() const {return sqrt((x*x)+(y*y)+(z*z));}
            bool isReal() const {return real;}
            

            Vector& operator=(const Vector& vec) {if(this == &vec) return *this; x = vec.getX(); y = vec.getY(); z = vec.getZ(); real = vec.isReal(); return *this;}
            Vector& operator=(const VecXY& vecxy) {x = vecxy.x; y = vecxy.y; z = 0.0; real = true; return *this;}
            bool operator==(const Vector& vec) const {if((vec.getX() == x) && (vec.getY() == y) && (vec.getZ() == z)) return true; else return false;}
            const Vector& operator+(const Vector& vec) const {return Vector(vec.getX()+x, vec.getY()+y, vec.getZ()+z);}
            Vector& operator+=(const Vector& vec) {x += vec.getX(); y += vec.getY(); z += vec.getZ(); return *this;}
            const Vector& operator-(const Vector& vec) const {return Vector(x-vec.getX(), y-vec.getY(), z-vec.getZ());}
            Vector& operator-=(const Vector& vec) {x -= vec.getX(); y -= vec.getY(); z -= vec.getZ(); return *this;}

            const double operator*(const Vector& vec) const {return ((vec.getX() * x) + (vec.getY() * y) + (vec.getZ() * z));}

            const Vector& operator^(const Vector& vec) const {return Vector(((vec.getZ()*y)-(vec.getY()*z)), ((vec.getX()*z)-(vec.getZ()*x)), ((vec.getY()*x)-(vec.getX()*y)));}
            
            const Vector<double>& operator^(const double& scalar) const {return Vector(x*scalar, y*scalar, z*scalar);}
            Vector<double>& operator^=(const double& scalar) {x *= scalar; y *= scalar; z *= scalar; return *this;}
            const Vector<double>& operator*(const double& scalar) const {return Vector(x*scalar, y*scalar, z*scalar);}
            Vector<double>& operator*=(const double& scalar) {x *= scalar; y *= scalar; z *= scalar; return *this;}
            const Vector<double>& operator/(const double& scalar) const {return Vector(x/scalar, y/scalar, z/scalar);}
            Vector<double>& operator/=(const double& scalar) {x /= scalar; y /= scalar; z /= scalar; return *this;}
            const Vector<double>& operator%(const double& scalar) const {return Vector(x%scalar, y%scalar, z%scalar);}
            Vector<double>& operator%=(const double& scalar) {x %= scalar; y %= scalar; z %= scalar; return *this;}
        protected:
            T x;
            T y;
            T z;
            bool real;
    };
    

    Vector<double> intersection(Vector<double> pos1, Vector<double> dir1, Vector<double> pos2, Vector<double> dir2);
    

    double momentOfInertia(std::vector<double> x, std::vector<double> y, double mass);

    double dAbs(double value);
};
#endif // MATHS_H

---