MultiVector.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* This library 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 Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                              SOFA :: Framework                              *
*                                                                             *
* Authors: M. Adam, J. Allard, B. Andre, P-J. Bensoussan, S. Cotin, C. Duriez,*
* H. Delingette, F. Falipou, F. Faure, S. Fonteneau, L. Heigeas, C. Mendoza,  *
* M. Nesme, P. Neumann, J-P. de la Plata Alcade, F. Poyer and F. Roy          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_CORE_COMPONENTMODEL_BEHAVIOR_MULTIVECTOR_H
#define SOFA_CORE_COMPONENTMODEL_BEHAVIOR_MULTIVECTOR_H

#include <sofa/core/objectmodel/BaseObject.h>
#include <sofa/core/componentmodel/behavior/BaseMechanicalState.h>
#include <sofa/defaulttype/BaseMatrix.h>
#include <sofa/defaulttype/BaseVector.h>

namespace sofa
{

namespace core
{

namespace componentmodel
{

namespace behavior
{

template<class Parent>
class MultiVector
{
public:
    typedef BaseMechanicalState::VecId VecId;

protected:
    Parent* parent;

    VecId v;

    bool dynamic;

    MultiVector(const MultiVector<Parent>& v);

public:
    MultiVector(Parent* parent, VecId v) : parent(parent), v(v), dynamic(false)
    {}

    MultiVector(Parent* parent, VecId::Type t) : parent(parent), v(parent->v_alloc(t)), dynamic(true)
    {}

    ~MultiVector()
    {
        if (dynamic) parent->v_free(v);
    }

    operator VecId()
    {
        return v;
    }

    void clear()
    {
        parent->v_clear(v);
    }

    void eq(VecId a)
    {
        parent->v_eq(v, a);
    }

    void peq(VecId a, double f=1.0)
    {
        parent->v_peq(v, a, f);
    }
    void teq(double f)
    {
        parent->v_teq(v, f);
    }
    double dot(VecId a)
    {
        parent->v_dot(v, a);
        return parent->finish();
    }
    
    void threshold( double threshold ) 
    {
      parent->v_threshold(v, threshold);
    }

    double norm()
    {
        parent->v_dot(v, v);
        return sqrt( parent->finish() );
    }

    void operator=(VecId a)
    {
        eq(a);
    }

    void operator=(const MultiVector<Parent>& a)
    {
        eq(a.v);
    }

    void operator+=(VecId a)
    {
        peq(a);
    }

    void operator-=(VecId a)
    {
        peq(a,-1);
    }

    void operator*=(double f)
    {
        teq(f);
    }

    void operator/=(double f)
    {
        teq(1.0/f);
    }

    double operator*(VecId a)
    {
        return dot(a);
    }

    friend std::ostream& operator << (std::ostream& out, const MultiVector<Parent>& mv )
    {
        mv.parent->print(mv.v,out);
        return out;
    }
};

} // namespace behavior

} // namespace componentmodel

} // namespace core

} // namespace sofa

#endif