vector.h

/* *************************************************************************
                            vector.h  -  description
                             -------------------
    begin                : Wed Oct 16 2002  
    copyright            : (C) 2002 by Micha Riser
    email                : mriser@gmx.net

    $Id: vector_8h-source.html,v 1.1 2005/02/04 21:02:26 micha Exp $
    
 ************************************************************************* */

/* *************************************************************************
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ************************************************************************* */

#ifndef VECTOR_H
#define VECTOR_H

#include <cmath>
#include <iostream>
#include "types.h"

class Matrix;

class Vector3 {

public: // Static methods ("constants")

    static Vector3 positiveInfinit() {return Vector3(DBL_INFINITY);}
    
    static Vector3 negativeInfinit() {return Vector3(-DBL_INFINITY);}

public: // Constructors and destructor

    Vector3() {}

    Vector3(DBL w) {for(int i=0; i<3; i++) a[i]=w;}

    Vector3(DBL x, DBL y, DBL z) {
        a[0]=x; a[1]=y; a[2]=z;
    }

public: // Public methods


    DBL& operator[](int i) {return a[i];}
    
    const DBL& operator[](int i) const {return a[i];}
    
    void add(const Vector3 &v) {for(int i=0; i<3; i++) a[i]+=v[i];}
    
    void sub(const Vector3 &v) {for(int i=0; i<3; i++) a[i]-=v[i];}
    
    void scale(DBL s) {for(int i=0; i<3; i++) a[i]*=s;}

    void scale(const Vector3& v) {for(int i=0; i<3; i++) a[i]*=v[i];}
    
    void normalize() {scale(1.0/length());}
    
    void inverse() {for(int i=0; i<3; i++) a[i]=1/a[i];}
    
    void applyFromLeft(const Matrix &m);
    
    void applyFromLeftTransposed(const Matrix &m);
    
    void rotate(const Vector3& v);
    
    void minimize(const Vector3 &v) {for(int i=0; i<3; i++) if (v[i]<a[i]) a[i]=v[i];}
    
    void maximize(const Vector3 &v) {for(int i=0; i<3; i++) if (v[i]>a[i]) a[i]=v[i];}
    
    Vector3 scaled(DBL s) const {
        Vector3 ret;
        for(int i=0; i<3; i++) ret[i] = a[i]*s;
        return ret;
    }
    
    double lengthSq() const {return a[0]*a[0]+a[1]*a[1]+a[2]*a[2];}
    
    double length() const {return sqrt(lengthSq());}
    
    bool equals(const Vector3& v) const {
        for(int i=0; i<3; i++)
            if(a[i]!=v[i]) return false;
        return true;
    }

    unsigned int hashValue() const {
        unsigned int res = 0;
        for(int i=0; i<3; i++) {
            const long long* p = reinterpret_cast<const long long*>(&(a[i]));
            unsigned int val = ((*p)>>38) ^ ((*p)>>49);
            res = (res<<4) ^ val;
        }
        return res;
    }

    // operator methods:

    bool operator<(const Vector3& v) const {
        for(int i=0; i<3; i++) {
            if (a[i]<v[i])
                return true;
            else
                if (a[i]>v[i]) return false;
        }
        return false;
    }

    bool operator==(const Vector3& v) const {return equals(v);}
    
    void operator+=(const Vector3& v) {add(v);}
    
    void operator-=(const Vector3& v) {sub(v);}

    void operator*=(DBL s) {scale(s);}
    
public: // Static methods:

    static DBL dotProd(const Vector3& v, const Vector3 &w) {
        DBL ret = 0;
        for(int i=0; i<3; i++) ret+=v[i]*w[i];
        return ret;
    }

    static Vector3 crossProd(const Vector3& u, const Vector3& v) {
        Vector3 res;
        res[0] = u[1]*v[2] - u[2]*v[1];
        res[1] = u[2]*v[0] - u[0]*v[2];
        res[2] = u[0]*v[1] - u[1]*v[0];
        return res;
    }
    
    static Vector3 add(const Vector3& v, const Vector3 &w) {
        Vector3 ret;
        for(int i=0; i<3; i++) ret[i] = v[i]+w[i];
        return ret;
    }
    
    static Vector3 sub(const Vector3& v, const Vector3 &w) {
        Vector3 ret;
        for(int i=0; i<3; i++) ret[i] = v[i]-w[i];
        return ret;
    }

    Vector3 operator*(DBL s) const {
        return scaled(s);    
    }

    static DBL distance(const Vector3& v, const Vector3 &w) {
        return sub(v,w).length();
    }

    static Vector3 deg2rad(const Vector3& v) {
        return v.scaled(PI/180.0);
    }
    
    static Vector3 rad2deg(const Vector3& v) {
        return v.scaled(180.0/PI);
    }
    
private: // Private members
    DBL a[3];

};

// Output Vector to stream
std::ostream& operator<<(std::ostream&s, const Vector3& v);



class Vector3f {

public: // public methods

    // Constructors
    
    Vector3f() {}

    Vector3f(const Vector3& v) {
        for(int i=0; i<3; i++) a[i] = v[i];
    }

    Vector3 toVector3() const {
        Vector3 ret;
        for(int i=0; i<3; i++) ret[i] =a[i];
        return ret;
    }

    FLT& operator[](int i) {return a[i];}

    const FLT& operator[](int i) const {return a[i];}

    bool equals(const Vector3f& v) const {
        for(int i=0; i<3; i++)
            if(a[i]!=v[i]) return false;
        return true;
    }

    unsigned int hashValue() const {
        unsigned int res = 0;
        for(int i=0; i<3; i++) {
            const unsigned int* p = reinterpret_cast<const unsigned int*>(&(a[i]));
            unsigned int val = ((*p)>>9) ^ ((*p)>>22);
            res = (res<<4) ^ val;
        }
        return res;
    }
    
private:
    FLT a[3];

};

#endif

---