|| ||           || Doxygen's  

---

HxVector.h

/*
 *  Copyright (c) 1998, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *
 *  Author(s):
 *  Dennis Koelma (koelma@wins.uva.nl)
 *  Edo Poll (poll@wins.uva.nl)
 *  Jan-Mark Geusebroek (mark@wins.uva.nl)
 */

#ifndef HxVector_h
#define HxVector_h

#include "HxIoFwd.h"
#include "HxStd.h"

#include "HxEnvironment.h"

template<class C> class L_HXBASIS HxTMatrix ;
L_HXBASIS typedef HxTMatrix<double>  HxMatrix ;

class L_HXBASIS HxVector {
public:


                        HxVector();

                        HxVector(int n);

                        HxVector(int n, double* data);

                        HxVector(double a0, double a1);

                        HxVector(double a0, double a1, double a2);

                        HxVector(double a0, double a1, double a2, double a3);

                        HxVector(const HxVector& v);

                        HxVector(const HxMatrix& m);

                        ~HxVector();



    int                 nElem() const;

    int                 valid() const;


    HxVector&                   operator=(double a);

    HxVector&                   operator=(const HxVector& v);

    double&                     operator[](int i) const;

    HxVector                    operator-() const;

    friend L_HXBASIS double     operator*(const HxVector& a, const HxVector& b);

    friend HxVector             operator*(const double a, const HxVector& b);

    friend HxVector             operator*(const HxVector& a, const double b);

    friend HxVector             operator/(const HxVector& a, double          b);

    friend HxVector             operator/(double          a, const HxVector& b);

    friend L_HXBASIS HxVector   operator+(const HxVector& a, const HxVector& b);

    friend HxVector             operator+(const HxVector& a, double          b);

    friend HxVector             operator+(double          a, const HxVector& b);

    friend L_HXBASIS HxVector   operator-(const HxVector& a, const HxVector& b);

    friend HxVector             operator-(const HxVector& a, double          b);

    friend HxVector             operator-(double          a, const HxVector& b);

    friend L_HXBASIS int        operator==(const HxVector& a, const HxVector& b);

    friend int                  operator!=(const HxVector& a, const HxVector& b);



    HxMatrix            t() const;

    HxMatrix            diag() const;

    HxVector            add(const HxVector& b) const;

    HxVector            add(const double val) const;

    HxVector            sub(const HxVector& b) const;

    HxVector            sub(const double val) const;

    HxVector            mul(const HxVector& b) const;

    HxVector            mul(const HxMatrix& m) const;

    HxVector            mul(const double val) const;

    HxVector            div(const double val) const;

    HxVector            sin() const;

    HxVector            cos() const;

    HxVector            tan() const;

    HxVector            sinh() const;

    HxVector            cosh() const;

    HxVector            tanh() const;

    HxVector            exp() const;

    HxVector            log() const;

    HxVector            sqrt() const;

    HxVector            abs() const;

    HxVector            sgn() const;

    HxVector            map(double (*f)(double)) const;

    STD_OSTREAM&        put(STD_OSTREAM& os) const;

private:
//    friend class HxMatrix;
//  friend template<class C> class HxTMatrix<C> ;
//  template<class C>   friend class Matrix<C> ;

    int                 _n;    // number of elements
    double*             _data; // data pointer
};

inline HxVector::HxVector()
{
    _n = 0;
    _data = 0;
}

inline HxVector::HxVector(int n)
{
    _n = n;
    _data = new double[_n];
}

inline HxVector::HxVector(int n, double* data)
{
    _n = n;
    _data = data;
}

inline HxVector::HxVector(double a0, double a1)
{
    _n = 2;
    _data = new double[_n];
    _data[0] = a0;
    _data[1] = a1;
}

inline HxVector::HxVector(double a0, double a1, double a2)
{
    _n = 3;
    _data = new double[_n];
    _data[0] = a0;
    _data[1] = a1;
    _data[2] = a2;
}

inline HxVector::HxVector(double a0, double a1, double a2, double a3)
{
    _n = 4;
    _data = new double[_n];
    _data[0] = a0;
    _data[1] = a1;
    _data[2] = a2;
    _data[3] = a3;
}

inline HxVector::HxVector(const HxVector& v)
{
    _n = v.nElem();
    _data = new double[_n];

    double* t = v._data;
    double* u = _data;
    int i = v.nElem();
    while (--i >= 0)
        *u++ = *t++;
}

inline HxVector::~HxVector()
{ 
    delete [] _data; 
}

inline int
HxVector::nElem() const
{ 
    return _n; 
}

inline int
HxVector::valid() const
{
    return (_n != 0);
}

inline HxVector&
HxVector::operator=(double a)
{
    int i = nElem();
    double *t = _data;
    while (--i >= 0)
        *t++ = a;
    return *this;
}

inline HxVector&
HxVector::operator=(const HxVector& v)
{
    if (this != &v) {
        delete [] _data;
        _n = v.nElem();
        _data = new double [_n];
        double *t = _data;
        double *u = v._data;
        int i = v.nElem();
        while (--i >= 0)
            *t++ = *u++;
    }
    return *this;
}

inline double&
HxVector::operator[](int i) const
{ 
    return _data[i];
} 

inline HxVector
HxVector::operator-() const
{
    HxVector m(*this);
    double* t = m._data;
    double* u = _data;
    int i = nElem();
    while (--i >= 0)
        *t++ = -(*u++);
    return m;
}

inline HxVector
operator*(const HxVector& a, double b)
{
    HxVector m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ * b;
    return m;
}

inline HxVector 
operator*(double a, const HxVector &b)
{
    HxVector m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
    *t++ = a * *u++;
    return m;
}

inline HxVector 
operator/(const HxVector &a, double b)
{
    HxVector m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ / b;
    return m;
}

inline HxVector 
operator/(double a, const HxVector &b)
{
    HxVector m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
        *t++ = a / *u++;
    return m;
}

inline HxVector 
operator+(const HxVector &a, double b)
{
    HxVector m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ + b;
    return m;
}

inline HxVector 
operator+(double a, const HxVector &b)
{
    HxVector m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
        *t++ = a + *u++;
    return m;
}

inline HxVector 
operator-(const HxVector &a, double b)
{
    HxVector m(a);
    double* t = m._data;
    double* u = a._data;
    int i = a.nElem();
    while (--i >= 0)
        *t++ = *u++ - b;
    return m;
}

inline HxVector 
operator-(double a, const HxVector &b)
{
    HxVector m(b);
    double* t = m._data;
    double* u = b._data;
    int i = b.nElem();
    while (--i >= 0)
        *t++ = a - *u++;
    return m;
}

inline int 
operator!=(const HxVector &a, const HxVector &b)
{
    return !(a == b);
}


inline STD_OSTREAM&
operator<<(STD_OSTREAM& os, const HxVector v)
{
    return v.put(os);
}


inline HxVector
HxVector::map(double (*f)(double)) const
{
    HxVector m(*this);
    double* t = m._data;
    double* u = _data;
    int i = nElem();
    while (--i >= 0)
            *t++ = f(*u++);
    return m;
}

inline STD_OSTREAM&
HxVector::put(STD_OSTREAM& s) const
{

    s << "( el:";
    s << _n << STD_ENDL ;

    double* t = _data ;

    for(int i=0;i<_n;i++)
        s << *t++ << " ";

    s << ")" << STD_ENDL;
    return s;
}


L_HXBASIS double       operator*(const HxVector& a, const HxVector& b);
L_HXBASIS HxVector     operator+(const HxVector& a, const HxVector& b);
L_HXBASIS HxVector     operator-(const HxVector& a, const HxVector& b);
L_HXBASIS int          operator==(const HxVector& a, const HxVector& b);

#endif

---