Vector.h

Go to the documentation of this file.

// vim:set noet ts=8 sw=8:
#ifndef VECTOR_H_
#define VECTOR_H_

#include <string.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include "FloatUtils.h"

template<class T = float>
class Vector {
        public:
                Vector (T x = 0, T y = 0, T z = 0) {
                        mCoords[0] = x;
                        mCoords[1] = y;
                        mCoords[2] = z;
                }

                // standard copy-ctor, assignment op. and dtor suffice

                T x() const { return mCoords[0]; }
                T y() const { return mCoords[1]; }
                T z() const { return mCoords[2]; }

                void setX(T x) { mCoords[0] = x; }
                void setY(T y) { mCoords[1] = y; }
                void setZ(T z) { mCoords[2] = z; }

                T* vector() { return mCoords; }
                const T* vector() const { return mCoords; }

                operator T*() { return vector(); }

                Vector<T> operator +=(const Vector<T>& v) {
                        mCoords[0] += v.x();
                        mCoords[1] += v.y();
                        mCoords[2] += v.z();
                        return *this;
                }
                Vector<T> operator+(const Vector<T>& v) const {
                        Vector<T> r(*this);
                        return r += v;
                }

                Vector<T> operator -=(const Vector<T>& v) {
                        mCoords[0] -= v.x();
                        mCoords[1] -= v.y();
                        mCoords[2] -= v.z();
                        return *this;
                }
                Vector<T> operator-(const Vector<T>& v) const {
                        Vector<T> r(*this);
                        return r -= v;
                }

                Vector<T> operator-() const {
                        return Vector<T>(-x(), -y(), -z());
                }

                // cross product
                Vector<T> operator*=(const Vector<T>& b) {
                        T xval = y() * b.z() - b.y() * z();
                        T yval = b.x() * z() - x() * b.z();
                        T zval = x() * b.y() - b.x() * y();
                        setX(xval);
                        setY(yval);
                        setZ(zval);
                        return *this;
                }
                // cross product
                Vector<T> operator*(const Vector<T>& b) const {
                        Vector<T> r(*this);
                        return r *= b;
                }

                //Tdot product (scalar product)
                T dotProduct(const Vector<T>& b) const {
                        return x() * b.x() + y() * b.y() + z() * b.z();
                }

                Vector<T>& operator*=(T scalar) {
                        mCoords[0] *= scalar;
                        mCoords[1] *= scalar;
                        mCoords[2] *= scalar;
                        return *this;
                }
                
                Vector<T>& operator+=(T scalar) {
                        mCoords[0] += scalar;
                        mCoords[1] += scalar;
                        mCoords[2] += scalar;
                        return *this;
                }
                
                Vector<T> operator*(T scalar) const {
                        return Vector<T>(x() * scalar, y() * scalar, z() * scalar);
                }
                Vector<T>& operator/=(float scalar) {
                        mCoords[0] /= scalar;
                        mCoords[1] /= scalar;
                        mCoords[2] /= scalar;
                        return *this;
                }
                Vector<T> operator/(float scalar) const {
                        return Vector<T>(x() / scalar, y() / scalar, z() / scalar);
                }

                bool operator==(const Vector<T>& v2) const {
                        
                        return ((x()==v2.x())&&(y()==v2.y())&&(z()==v2.z()));
                //      if (!floatEq(x(),v2.x())) return false;
                //      if (!floatEq(y(),v2.y())) return false;
                //      if (!floatEq(z(),v2.z())) return false;
                //      return true;
                }
                
                float len() const {
                        return sqrt(x()*x() + y()*y() + z()*z());
                }

                Vector<T> normalized() const {
                        return Vector<T>(*this).normalize();
                }

                Vector<T>& normalize() {
                        return operator/=(len());
                }

                float angle(const Vector<T>& with) const {
                        float dotprod = dotProduct(with);
                        float frac = dotprod / (len() * with.len());
                        return acos(frac);
                }

                bool operator>=(const Vector<T>& b) const {
                        return x() >= b.x() &&
                                   y() >= b.y() &&
                                   z() >= b.z();
                }

                bool operator<=(const Vector<T>& b) const {
                        return x() <= b.x() &&
                                   y() <= b.y() &&
                                   z() <= b.z();
                }

                bool operator<(const Vector<T>& b) const {
                        return x() < b.x() &&
                                   y() < b.y() &&
                                   z() < b.z();
                }

                bool operator>(const Vector<T>& b) const {
                        return x() > b.x() &&
                                   y() > b.y() &&
                                   z() > b.z();
                }

        private:
                T mCoords[3];
};

/*
inline bool vector_eq(const Vector<T>& a, const Vector<T>& b, float eps = 0.0005) {
        return floatEq(a.x(), b.x(), eps) &&
                        floatEq(a.y(), b.y(), eps) &&
                        floatEq(a.z(), b.z(), eps);
}*/
        
#endif

---