Vector.h

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#ifndef VECTOR_H
#define VECTOR_H

#include <string>
#include <iostream>
#include <math.h>
#include <sys/time.h>

using namespace std;

class Vector {
public:
    double x;

    double y;

    double z;

    inline  Vector(double x_,double y_,double z_) {
        x=x_;
        y=y_;
        z=z_;
    }

    inline Vector() {}

    inline void normalise() {
        double length_;

        length_ = length();
        if (length_ != 0) {
            x /= length_;
            y /= length_;
            z /= length_;
        } else {
            x = 0;
            y = 0;
            z = 0;
        }
    }

    inline Vector getNormalised() {
        double length_;

        length_ = length();
        if (length_ != 0)
            return Vector(x / length_,y / length_,z / length_);
        else
            return Vector (0,0,0);
    }

    inline Vector crossProduct(const Vector & b) {
        Vector tmp_;
        tmp_.x = (y * b.z) - (z * b.y);
        tmp_.y = (z * b.x) - (x * b.z);
        tmp_.z = (x * b.y) - (y * b.x);
        return tmp_;
    }

    inline double length() {
        return sqrt((x * x) + (y * y) + (z * z));
    }

    inline double scalarProduct(const Vector & b) {
        return (x * b.x) + (y * b.y) + (z * b.z);
    }

    // Die folgenden Operatoren arbeiten alle Komponentenweise

    inline double operator*(const Vector & b) {
        return (x * b.x) + (y * b.y) + (z * b.z);
    }

    inline Vector operator-(const Vector & a) {
        return Vector(x-a.x,y-a.y,z-a.z);
    }

    inline Vector operator+(const Vector & a) {
        return Vector(x+a.x,y+a.y,z+a.z);
    }

    inline Vector & operator+=(const Vector & a) {
        x+=a.x;
        y+=a.y;
        z+=a.z;
        return *this;
    }

    inline Vector & operator-=(const Vector & a) {
        x-=a.x;
        y-=a.y;
        z-=a.z;
        return *this;
    }

    inline bool operator==(const Vector & a) {
        if(x==a.x && y==a.y && z==a.z)
            return true;
        else
            return false;
    }

    inline Vector operator*(const double a) {
        return Vector(x*a,y*a,z*a);
    }

    inline Vector operator/(const double a) {
        return Vector(x/a,y/a,z/a);
    }

    inline Vector operator+(const double a) {
        return Vector(x+a,y+a,z+a);
    }

    inline Vector& operator*=(const double a) {
        x*=a;
        y*=a;
        z*=a;
        return *this;
    }

    inline Vector& operator/=(const double a) {
        x/=a;
        y/=a;
        z/=a;
        return *this;
    }
};

inline ostream & operator<<(ostream &out_, const Vector & v_) {
    out_ << " X: " << v_.x << " Y: " << v_.y << " Z: " << v_.z;
    return out_;
}

inline istream & operator>>(istream &in_, Vector & v_) {
    string s_;
    in_ >> s_ ;
    in_ >>  v_.x ;
    in_ >> s_ ;
    in_ >>  v_.y ;
    in_ >> s_ ;
    in_ >>  v_.z ;
    return in_;
}

#endif

---