GVector.h

Go to the documentation of this file.

#ifndef __VECMATH_GVECTOR_HPP
#define __VECMATH_GVECTOR_HPP

#include <vecmath/Tuple2f.h>
#include <vecmath/Tuple3d.h>
#include <vecmath/Tuple3f.h>
#include <vecmath/Tuple4d.h>
#include <vecmath/Tuple4f.h>

class GMatrix;

class VECMATH_EXPORT GVector {
    int length;
public:
    double *values;

    explicit GVector(int i) {
        length = i;
        values = new double[i];
        zero();
    }

    GVector(const GVector& gvector) {
        values = new double[gvector.length];
        length = gvector.length;
        for(int i = 0; i < length; i++)
            values[i] = gvector.values[i];
    }

    GVector(const Tuple2f& tuple2f) {
        length = 2;
        values = new double[length];
        tuple2f.get(values);
    }

    GVector(const Tuple3d& tuple3d) {
        length = 3;
        values = new double[length];
        tuple3d.get(values);
    }

    GVector(const Tuple3f& tuple3f) {
        length = 3;
        values = new double[length];
        tuple3f.get(values);
    }

    GVector(const Tuple4d& tuple4d) {
        length = 4;
        values = new double[length];
        tuple4d.get(values);
    }

    GVector(const Tuple4f& tuple4f) {
        length = 4;
        values = new double[length];
        tuple4f.get(values);
    }

//      GVector(const double ad[]) {
//          length = ad.length;
//          values = new double[ad.length];
//          for(int i = 0; i < length; i++)
//              values[i] = ad[i];
//
//      }

    GVector(const double ad[], int i) {
        length = i;
        values = new double[i];
        for(int j = 0; j < i; j++)
            values[j] = ad[j];
    }

    virtual ~GVector() {
        delete [] values;
    }

    void LUDBackSolve(GMatrix& gmatrix, GVector& gvector, GVector& gvector1);

    void SVDBackSolve(GMatrix& gmatrix, GMatrix& gmatrix1, GMatrix& gmatrix2, GVector& gvector);

    void add(const GVector& gvector) {
        for (int i = 0; i < length; i++)
            values[i] += gvector.values[i];
    }

    void add(const GVector& gvector, const GVector& gvector1) {
        for(int i = 0; i < length; i++)
            values[i] = gvector.values[i] + gvector1.values[i];
    }

    double angle(const GVector& gvector) const {
        return acos(dot(gvector) / (norm() * gvector.norm()));
    }

    double dot(const GVector& gvector) const {
        double d = 0.0;
        for (int i = 0; i < length; i++)
            d += values[i] * gvector.values[i];

        return d;
    }

    virtual bool epsilonEquals(GVector gvector, double d) const {
        if (length != gvector.length)
            return false;

        for (int i = 0; i < length; i++) {
            double d1 = values[i] - gvector.values[i];
            if ((d1 >= 0.0 ? d1 : -d1) > d)
                return false;
        }

        return true;
    }

//      virtual bool equals(Object obj)
//      {
//          try
//          {
//              GVector gvector = (GVector)obj;
//              if(length != gvector.length)
//                  return false;
//              for(int i = 0; i < length; i++)
//                  if(values[i] != gvector.values[i])
//                      return false;
//
//              return true;
//          }
//          catch(ClassCastException _ex)
//          {
//              return false;
//          }
//          catch(NullPointerException _ex)
//          {
//              return false;
//          }
//      }

    virtual bool equals(const GVector& gvector) {
//          try {
            if(length != gvector.length)
                return false;
            for(int i = 0; i < length; i++)
                if(values[i] != gvector.values[i])
                    return false;

            return true;
//          }
//          catch(NullPointerException _ex)
//          {
//              return false;
//          }
    }

    double getElement(int i) const {
        return values[i];
    }

    int getSize() const {
        return length;
    }

    int hashCode() const {
        int i = 0;
//          for(int j = 0; j < length; j++)
//              i ^= (new Double(values[j])).hashCode();
//
        return i;
    }

    void interpolate(const GVector& gvector, double d) {
        for (int i = 0; i < length; i++)
            values[i] = (1.0 - d) * values[i] + d * gvector.values[i];
    }

    void interpolate(const GVector& gvector, const GVector& gvector1, double d) {
        for (int i = 0; i < length; i++)
            values[i] = (1.0 - d) * gvector.values[i] + d * gvector1.values[i];

    }

    void mul(const GMatrix& gmatrix, const GVector& gvector);
    void mul(const GVector& gvector, const GMatrix& gmatrix);

    void negate() {
        for(int i = 0; i < length; i++)
            values[i] *= -1;
    }

    double norm() const {
        return sqrt(normSquared());
    }

    double normSquared() const {
        double d = 0.0;

        for (int i = 0; i < length; i++)
            d += values[i] * values[i];

        return d;
    }

    void normalize() {
        double d = normSquared();

        for(int i = 0; i < length; i++)
            values[i] /= d;
    }

    void normalize(const GVector& gvector) {
        double d = gvector.normSquared();

        for (int i = 0; i < length; i++)
            values[i] = gvector.values[i] / d;
    }

    void scale(double d) {
        scale(d, *this);
    }

    void scale(double d, const GVector& gvector) {
        for (int i = 0; i < length; i++)
            values[i] = gvector.values[i] * d;
    }

    void scaleAdd(double d, const GVector& gvector, const GVector& gvector1)  {
        for (int i = 0; i < length; i++)
            values[i] = gvector.values[i] * d + gvector1.values[i];
    }

    void set(const GVector& gvector) {
        if (length < gvector.length) {
            resize(gvector.length);
            for (int i = 0; i < length; i++)
                values[i] = gvector.values[i];
        } else {
            for (int i = 0; i < gvector.length; i++)
                values[i] = gvector.values[i];
            zero(gvector.length);
        }
    }

    void set(const Tuple2f& tuple2f) {
        if (length < 2)
            resize(2);

        tuple2f.get(values);
        zero(2);
    }

    void set(const Tuple3d& tuple3d) {
        if (length < 3)
            resize(3);

        tuple3d.get(values);
        zero(3);
    }

    void set(const Tuple3f& tuple3f) {
        if (length < 3)
            resize(3);

        tuple3f.get(values);
        zero(3);
    }

    void set(const Tuple4d& tuple4d) {
        if (length < 4)
            resize(4);

        tuple4d.get(values);
        zero(4);
    }

    void set(const Tuple4f& tuple4f) {
        if (length < 4)
            resize(4);

        tuple4f.get(values);
        zero(4);
    }

    void set(const double ad[]) {
        for (int i = 0; i < length; i++)
            values[i] = ad[i];
    }

    void setElement(int i, double d) {
        values[i] = d;
    }

    void setSize(int i) {
        int k = (length < i) ? length : i;
        double *ad = new double[i];

        for (int j = 0; j < k; j++)
            ad[j] = values[j];

        length = i;
        delete [] values;
        values = ad;
    }

    void sub(const GVector& gvector) {
        for (int i = 0; i < length; i++)
            values[i] -= gvector.values[i];
    }

    void sub(GVector gvector, GVector gvector1) {
        for (int i = 0; i < length; i++)
            values[i] = gvector.values[i] - gvector1.values[i];
    }

//      String& toString() {
//          StringBuffer stringbuffer = new StringBuffer(length * 8);
//          for(int i = 0; i < length; i++)
//              stringbuffer.append(values[i]).append(" ");
//
//          return stringbuffer.toString();
//      }

    void zero(int from = 0) {
        for (int i = from; i < length; i++)
            values[i] = 0.0;
    }

private:
    double* resize(int i) {
        if (length > 0 && values != 0) {
            delete [] values;
        }

        values = new double[i];
        length = i;

        return values;
    }

};

#endif

---