math/VectorN.h

Go to the documentation of this file.

#ifndef VectorN_h
#define VectorN_h 1

#include <vector>
#include "debug/debug.h"

class VectorN 
{

  public:
    //## Constructors (specified)
      //## Operation: VectorN%922595691
      VectorN ();

      //## Operation: VectorN%922595696
      VectorN (const VectorN& right);
          explicit VectorN( const double a );
          VectorN( const double a, const double b );
      VectorN( const double a, const double b, const double c );
          VectorN( const double a, const double b, const double c, const double d );

    //## Destructor (generated)
      virtual ~VectorN();


      void SetLength (const int length);

      double&       operator [] (const unsigned int index);
      inline const double& operator [] (const unsigned int index) const;

      VectorN& operator =  ( const VectorN& right);
      VectorN  operator +  ( const VectorN& right) const;
      VectorN  operator -  ( const VectorN& right) const;
      VectorN  operator *  ( const double   right) const;
          VectorN& operator *= ( const double   right);
      VectorN& operator += ( const VectorN& right);
      VectorN& operator -= ( const VectorN& right);
      VectorN  operator /  ( const double   right) const;
      VectorN& operator /= ( const double   right);

      double       Dot( const VectorN& right ) const;
      unsigned int Length () const;
      unsigned int Size() const { return Length(); }
      unsigned int size() const { return Size(); }
      virtual void Output () const;

      //## Operation: operator==%930083381
      //        Assignment operator for vectors.  Returns a reference to
      //        the resultant.
      bool operator == (const VectorN& right) const;

      //## Operation: operator!=%930083382
      //        Assignment operator for vectors.  Returns a reference to
      //        the resultant.
      bool operator != (const VectorN& right) const;

          // Compares if two vectors are equal to within a given Tolerance.
          bool Compare( const VectorN& right, const double& tol) const;
      void Append( const VectorN& right );
      void Normalize();
      double MagSquared () const;
      double Magnitude () const;
      void clear();
      void push_back( const double newElement );
      void reserve( const unsigned int size );
      void resize( const unsigned int size, const double fill = 0.0 );
  protected:
  private:
      std::vector< double > elements;
};

double  Average( const VectorN& v );
VectorN ClosestPoint   ( const VectorN& c0, const VectorN& c1, const VectorN& p );
double  DistanceSquared( const VectorN& c0, const VectorN& c1, const VectorN& p );
VectorN Ln( const VectorN& right );
VectorN operator*( const double f, const VectorN& v );
std::ostream& operator<<( std::ostream &os, const VectorN& v ) ;
std::istream& operator>>( std::istream &is, VectorN& v ) ;

//=============================================================================
// VectorN::operator[]
//=============================================================================
const double& VectorN::operator[] ( const unsigned int index ) const
{
    #ifdef _DEBUG
            int size = elements.size();
            IJG_Assert( size > index );
    #endif
        return elements[ index ];
}

#endif

---