Vector.h

Go to the documentation of this file.

#ifndef Vector_H
#define Vector_H

#include "defines.h"
#include <vector>
//#include <iostream>
#include <iosfwd>

namespace annie
{
/* note: we should NOT use all of the std::vector functions. This opens us a way to define Vector as real[fixed] or dynamically resizable array of reals
 * TODO: hide them in the vector's descendant, then..!
 * TODO: it's inconvenient to set the size... but we cannot slow down [] ...
 * with all respect and understanding, I'd rename Vector to Vector
 * 
The time-critical function is [].
* OPT: employ STL's valarray ?
*/
//typedef std::vector<real> Vector;
typedef std::vector<real> VFather;
class Vector : protected  VFather   {
    public:
    #define BLUB_TYPE(t) typedef VFather::t t
    BLUB_TYPE(size_type);

    //TODO: purge dependency on iterators.... we can make iterated sucessor if needed. Or can we do it. without overhead ???
    BLUB_TYPE(iterator);
    BLUB_TYPE(const_iterator);
    #undef BLUB_TYPE
    Vector()    {}
    Vector(uint items, real values) : VFather(items, values) {}
    Vector(const Vector &src) : VFather(src)    {}
    Vector(size_type size) : VFather(size) {}
    Vector &operator = (const Vector &v)    { VFather::operator=(v); return *this; }

    friend  bool operator==(const Vector &o1, const Vector &o2);

    static Vector fromInts(std::vector<int> iv);
    static Vector fromInts(uint size, int *data);
    
    size_type size() const  { return VFather::size(); }
    void reserve(size_type s) { VFather::reserve(s); }
    void resize(size_type s) { VFather::resize(s); }
    iterator begin() { return VFather::begin(); }
    const_iterator begin() const    { return VFather::begin(); }
    const_iterator end() const  { return VFather::end(); }
    real &operator[](uint i)    { return VFather::operator[](i); }
    const real &operator[](uint i)  const { return VFather::operator[](i); }
    //unwanted?
    void clear() { VFather::clear(); }
    void push_back(const real & x)  { VFather::push_back(x); }

    real magnitude()    const;
    void normalize();
    Vector operator- (const Vector &v) const;
    Vector operator+ (const Vector &v) const;
    Vector &operator+= (const Vector &v);

    Vector subset(uint start=0) const { return subset(start, size() - start); }
    Vector subset(uint start, uint size=0) const;

    void setAll(real val);
    
    void null() { setAll(0.); }

    Vector &append(const Vector &v);    
    
    void setMore(const Vector &v, uint startIndex=0);

    void clamp(real min, real max);
    
    Vector &operator*= (const real r);
    Vector operator* (const real r) const;
    Vector operator+ (const real r) const;
    Vector &operator+= (const real r);
    
    real distance(const Vector &to) const;
    const static Vector ZOID;   //0-dimensional constant
    
    operator std::string() const;

    void toStream(std::ostream &s) const;
  protected:
    template<class InputIterator>
    Vector(InputIterator f,  InputIterator t) : VFather(f, t) {}
};
std::ostream &operator<<(std::ostream &os, const annie::Vector &v);
bool operator==(const Vector &o1, const Vector &o2);
}
#endif //_H

---