vectorn.h

basic mathematic classes used for math programming

#ifndef VECTOR_N_H
#define VECTOR_N_H

class matrixN;
class smatrixN;

class vectorN
{
  private:
    int     n,
			on;
    m_real *v;

    // stream
    friend ostream&  operator<<( ostream&, const vectorN& );
    friend istream&  operator>>( istream&, vectorN& );

    // dot product
    friend m_real    operator%( const vectorN&, const vectorN& );
	friend vectorN   operator-( const vectorN&, const vectorN& ); 
	friend vectorN   operator*( const m_real&,  const vectorN&);
//	friend vectorN   operator*( const m_real&,  vectorN&);
	friend vectorN   operator/( const vectorN&, const m_real& );


  public:
     vectorN();
	 vectorN(const vectorN&);
     vectorN( int );
     vectorN( int, m_real* );
    ~vectorN();

	void	  getValue( m_real* );
	m_real	  getValue( int i ) const { assert(i>=0 && i<n); return v[i]; }
	void	  setValue( m_real* );
	void	  setValue( int i, m_real d ) { assert(i>=0 && i<n); v[i] = d; }

    m_real&   operator[](int i) const {  assert(i>=0 && i<n); return v[i]; }
    int       size() const { return n; }
    int       getSize() const { return n; }
    void      setSize( int );
	void      setExactSize(int ); // only allocate memory size this vector need

    m_real    len() const ;
    m_real    length() const ;
	m_real    length2() const;
	m_real    componentSum() const;

    vectorN&  normalize();

    vectorN&  assign( const vectorN& );
    vectorN&  operator=( const vectorN& );

    vectorN&  negate();

    vectorN&  add( const vectorN&, const vectorN& );
    vectorN&  operator+=( const vectorN& );

    vectorN&  sub(const  vectorN&, const vectorN& );
    vectorN&  operator-=( const vectorN& );

    vectorN&  mult( vectorN const&, m_real );
    vectorN&  operator*=( m_real );

    vectorN&  mult( const matrixN&, const vectorN& );
    vectorN&  mult( const vectorN&, const matrixN& );
    vectorN&  mult( const smatrixN&, const vectorN& );
    vectorN&  mult( const vectorN&, const smatrixN& );

    vectorN&  div( const vectorN&, m_real );
    vectorN&  operator/=( m_real );

	friend m_real	difference(const vectorN&, const vectorN& );

	// SOR (Successive Over Relaxation)
    vectorN&  solve(const matrixN&,  const vectorN&, int, m_real, m_real );

	// LU Decomposition
    vectorN&  solve(const matrixN&, const vectorN& );

	// SVD (Singular Value Decomposition)
    vectorN&  solve(const matrixN&, const vectorN&, m_real );

	// Preconditioned Conjugate Gradient
    vectorN&  solve(const  smatrixN&, const vectorN& );

	void      exchange( int i, int j);
};

#endif