coVector.h

Go to the documentation of this file.

/* This file is part of COVISE.

   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.

 * License: LGPL 2+ */

#ifndef COVISE_VECTOR_H
#define COVISE_VECTOR_H

/**************************************************************************\ 
 **                                                                        **
 **                                                                        **
 ** Description: Interface classes for application modules to the COVISE   **
 **              software environment                                      **
 **                                                                        **
 **                                                                        **
 **                                                                        **
 **                                                                        **
 **                                                                        **
 **                             (C)1997 RUS                                **
 **                Computing Center University of Stuttgart                **
 **                            Allmandring 30                              **
 **                            70550 Stuttgart                             **
 ** Author: D. Rantzau                                                     **
 ** Date:  15.08.97  V1.0                                                  **
\**************************************************************************/

#include <math.h>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include "coExport.h"

using std::ostream;
namespace covise
{

class coMatrix;

class UTILEXPORT coVector
{

    friend class coMatrix;

public:
    int dim;
    double vec4[4];
    double *vec;

    coVector()
    {
        dim = 3;
        vec = vec4;
    }

    coVector(const coVector &v)
    {
        dim = v.dim;
        if (dim < 5)
            vec = vec4;
        else
            vec = new double[dim];
        for (int i = 0; i < dim; i++)
            vec[i] = v[i];
    }

    coVector &operator=(const coVector &v)
    {
        dim = v.dim;
        if (dim < 5)
            vec = vec4;
        else
            vec = new double[dim];
        for (int i = 0; i < dim; i++)
            vec[i] = v[i];
        return *this;
    }

    coVector(int d)
    {
        dim = d;
        if (d < 5)
            vec = vec4;
        else
            vec = new double[d];
    }
    coVector(int d, double *_val)
    {
        dim = d;
        if (d < 5)
            vec = vec4;
        else
            vec = new double[d];
        for (int ctr = 0; ctr < d; ++d)
            vec[ctr] = _val[ctr];
    }

    ~coVector()
    {
        if (dim > 4)
            delete[] vec;
    }

    coVector(double _val[3])
    {
        dim = 3;
        vec = vec4;
        vec[0] = _val[0];
        vec[1] = _val[1];
        vec[2] = _val[2];
    }

    coVector(double a, double b, double c)
    {
        dim = 3;
        vec = vec4;
        vec[0] = a;
        vec[1] = b;
        vec[2] = c;
        vec[3] = 1.;
    }
    coVector(double a, double b, double c, double d)
    {
        dim = 4;
        vec = vec4;
        vec[0] = a;
        vec[1] = b;
        vec[2] = c;
        vec[3] = d;
    }

    int operator==(coVector &v);

    coVector operator+(const coVector &v) const;

    coVector operator-(const coVector &v) const;

    coVector operator-() const;

    double operator*(const coVector &v) const;

    coVector operator*(const coMatrix &m) const;

    coVector operator*(double r) const;

    double &operator[](int i)
    {
        return vec[i];
    }

    double operator[](int i) const
    {
        return vec[i];
    }

    //
    // vector operators:
    //
    double length() const;

    coVector scale(double f)
    {
        return *this * f;
    }

    double dot(const coVector &v) const;

    coVector cross(const coVector &v) const;

    coVector eval(const coVector &v) const;

    coVector unitize() const;

    coVector negate() const;

    // print the vector:

    void print(FILE *f, char *n = 0);

    void get(double f[3])
    {
        f[0] = vec[0];
        f[1] = vec[1];
        f[2] = vec[2];
    }

    void get(float f[3])
    {
        f[0] = (float)vec[0];
        f[1] = (float)vec[1];
        f[2] = (float)vec[2];
    }

    coVector maximal(const coVector &v) const;

    double enclosedAngle(const coVector &v) const;

    bool isZero() const;

    coVector &normalize();

    friend ostream &operator<<(ostream &O, const coVector &v)
    {
        O << "[" << v[0] << "|" << v[1] << "|" << v[2] << "]";
        return O;
    }
    /*{\Mbinopfunc  writes $v$ componentwise to the output stream $O$.}*/

    //friend istream& operator>>(istream& I, coVector& v);
    /*{\Mbinopfunc  reads $v$ componentwise from the input stream $I$.}*/
};
}
#endif // COVISE_VECTOR_H