vector.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys is free software; you can redistribute it and/or modify it under the      *
 * terms of the GNU General Public License as published by the Free Software         *
 * Foundation; either version 2 of the License, or (at your option) any later        *
 * version.                                                                          *
 *                                                                                   *
 * MechSys is distributed in the hope that it will be useful, but WITHOUT ANY        *
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A   *
 * PARTICULAR PURPOSE. See the GNU General Public License for more details.          *
 *                                                                                   *
 * You should have received a copy of the GNU General Public License along with      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_LINALG_VECTOR_H
#define MECHSYS_LINALG_VECTOR_H

#include <sstream>
#include <cassert>
#include <cmath>

#include "util/numstreams.h"

namespace LinAlg
{

// Prototype for expression classes
template <class t_exp, class t_res>
class expression;

template<typename Type>
class Vector
{
public:
    
    // Default constructor
    Vector() : _size(0), _values(NULL) {}
    // Constructor
    Vector(int Size)                              : _values(NULL) { _set(Size); }
    Vector(int Size, std::string const & strVals) : _values(NULL) { _set(Size,strVals); }
    // Destructor
    ~Vector()
    {
        if (_values!=NULL) delete [] _values;
    }
    // Copy constructor
    Vector(Vector<Type> const & Other)
    {
          _size = Other.Size();
        _values = new Type [_size];
        for (int i=0; i<_size; ++i)
            _values[i] = Other._values[i];
    }
    // Get
           int   Size()   const { return _size; }
          Type * GetPtr()       { assert(_values!=NULL); return _values; }
    const Type * GetPtr() const { assert(_values!=NULL); return _values; }
    // Set
    void Set(int Size)                              { _set(Size); }
    void Set(int Size, std::string const & strVals) { _set(Size,strVals); }
    void SetValues(Type Value) // {{{
    {
        assert(_values!=NULL);
        for (int i=0; i<_size; ++i)
            _values[i] = Value; 
    } // }}}
    void Reset(std::string const & strVals) // {{{
    {
        std::istringstream iss(strVals);
        for (int i=0; i<_size; ++i)
            iss >> _values[i];
    } // }}}
    void Resize(int Size) { _resize(Size); }
    // operators
    void operator= (const Vector<Type> & R) // {{{
    {
        assert(&R!=this);
        if (R.Size() != _size)
        {
            _size = R.Size();
            if (_values != NULL) delete [] _values;
            _values = new Type [_size];
        }
        
        int _components=_size;
        for (int i=0; i<_components; ++i)
            _values[i] = R._values[i];

    } // }}}

    // operator to assign values separated by commas {{{
    class CommaAssign
    {
    public:
        CommaAssign(Type * Values, int & Size, Type const & FirstValue):_values(Values),_size(Size),_index(0) 
        { 
            assert(_values!=NULL);
            _values[0] = FirstValue;
            for (int i=1; i<_size; ++i)
                _values[i] = static_cast<Type>(0);
        }
        CommaAssign & operator, (Type const & Num) 
        {
            _index++;
            assert(_index<_size);
            _values[_index] = Num;
            return *this;
        }
    private:
        Type * _values;
        int  & _size;
        int    _index;
    };

    CommaAssign operator = (Type const & Num) 
    {
        return CommaAssign(_values, _size, Num);
    } // }}}

    void operator+= (const Vector<Type> & R) // {{{
    {
        assert(_values!=NULL);
        assert(R.Rows()==_size);
        int _components=_size;
        for (int i=0; i<_components; ++i)
            _values[i] += R._values[i];
    } // }}}

    void operator-= (const Vector<Type> & R) // {{{
    {
        assert(_values!=NULL);
        assert(R.Rows()==_size);
        int _components=_size;
        for (int i=0; i<_components; ++i)
            _values[i] -= R._values[i];
    } // }}}
    
    // Suport for expression evaluation {{{
    template<typename t_exp>
    void operator  = (const expression<t_exp, Vector<Type> > & Exp) { Exp.Apply(*this); } 

    template<typename t_exp>
    void operator += (const expression<t_exp, Vector<Type> > & Exp) { Exp.Apply_pe(*this); } 

    template<typename t_exp>
    void operator -= (const expression<t_exp, Vector<Type> > & Exp) { Exp.Apply_me(*this); } // }}}

    Type & operator() (int i) // {{{
    {
        assert(_values!=NULL);
        assert(i>=0 & i<_size);
        return _values[i];
    } // }}}
    const Type & operator() (int i) const // {{{
    {
        assert(_values!=NULL);
        assert(i>=0 & i<_size);
        return _values[i];
    } // }}}
private:
    int    _size;
    Type * _values;
    void _set(int Size) // {{{
    {
        assert(_values==NULL);
        assert(Size>0);
          _size = Size;
        _values = new Type [_size];
    } // }}}
    void _set(int Size, std::string const & strVals) // {{{
    {
        assert(_values==NULL);
        assert(Size>0);
          _size = Size;
        _values = new Type [_size];
        std::istringstream iss(strVals);
        for (int i=0; i<_size; ++i)
            iss >> _values[i];
    } // }}}
    void _resize(int Size) // {{{
    {
        assert(Size>0);
        if (Size==_size && _values!=NULL) return;   
        if (_values!=NULL) delete [] _values;
        _size = Size;
        _values = new Type [_size];
    } // }}}
}; // class Vector<Type>


template<typename Type>
std::ostream & operator<< (std::ostream & os, const LinAlg::Vector<Type> & V) // {{{
{
    for (int i=0; i<V.Size(); ++i)
        os << _8s()<< V(i);
    os << std::endl;
    return os;
} // }}}

}; // namespace LinAlg

#endif // MECHSYS_LINALG_VECTOR_H

// vim:fdm=marker

---