nmrMultiVariablePowerBasis.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */
 
/*
  
  Author(s):    Ofri Sadowsky
  Created on: 2003-08-20
 
  (C) Copyright 2003-2007 Johns Hopkins University (JHU), All Rights
  Reserved.
 
--- begin cisst license - do not edit ---
 
This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.
 
--- end cisst license ---
*/
 
 
#ifndef _nmrMultiVariablePowerBasis_h
#define _nmrMultiVariablePowerBasis_h
 
#include <cisstNumerical/nmrPolynomialTermPowerIndex.h>
#include <cisstVector/vctDynamicMatrix.h>
#include <cisstNumerical/nmrExport.h>

class CISST_EXPORT nmrMultiVariablePowerBasis
{
public:
    typedef double VariableType;
    typedef nmrPolynomialTermPowerIndex::PowerType PowerType;
    typedef nmrPolynomialTermPowerIndex::VariableIndexType VariableIndexType;
    typedef VariableType ValueType;
 
protected:
    typedef vctDynamicMatrix<VariableType> BasisContainerType;
    BasisContainerType BasisContainer;
 
public:
    nmrMultiVariablePowerBasis(VariableIndexType numVariables, PowerType maxPower)
    {
        Initialize(numVariables, maxPower);
    }
 
    virtual ~nmrMultiVariablePowerBasis()
    {}

    void Initialize(VariableIndexType numVariables, PowerType maxPower);
 
    VariableIndexType GetNumVariables() const
    { 
        return BasisContainer.rows();
    }
 
    PowerType GetMaxDegree() const
    {
        return BasisContainer.cols() - 1;
    }
 
    VariableType GetVariable(VariableIndexType variableIndex) const
    {
        return BasisContainer.Element(variableIndex, 1);
    }

    void GetVariables(VariableType vars[]) const
    {
        vctDynamicVectorRef<VariableType> varsVector(GetNumVariables(), vars);
        varsVector.Assign(BasisContainer.Column(1));
    }

    VariableType GetSumOfVariables() const
    {
        return BasisContainer.Column(1).SumOfElements();
    }

    VariableType GetVariablePower(VariableIndexType var, PowerType power) const
    {
        return BasisContainer.Element(var, power);
    }

    virtual void SetVariable(VariableIndexType varIndex, VariableType value) = 0;

    virtual void SetVariables(const VariableType vars[]) = 0;
 

    virtual bool CanSetVariable(VariableIndexType varIndex) const = 0;

    ValueType EvaluatePowerProduct(const PowerType powers[]) const;
 
protected:
    void PrivateSetVariable(VariableIndexType varIndex, VariableType value);
 
public:
    class StandardPowerBasis;

    class BarycentricBasis;
};
 
class CISST_EXPORT nmrMultiVariablePowerBasis::StandardPowerBasis : public nmrMultiVariablePowerBasis
{
public:
    typedef nmrMultiVariablePowerBasis BaseType;
    StandardPowerBasis(VariableIndexType numVariables, PowerType maxPower)
        : BaseType(numVariables, maxPower)
    {}
 
    virtual bool CanSetVariable(VariableIndexType varIndex) const
    { return ( (0 <= varIndex) && (varIndex < GetNumVariables()) ); }
    
    virtual void SetVariable(VariableIndexType varIndex, VariableType value)
    {
        CMN_ASSERT(CanSetVariable(varIndex));
        PrivateSetVariable(varIndex, value);
    }
    
    virtual void SetVariables(VariableType const vars[]);
};
 
 
class CISST_EXPORT nmrMultiVariablePowerBasis::BarycentricBasis : public nmrMultiVariablePowerBasis
{
protected:
    VariableIndexType ImplicitVarIndex;
public:
    typedef nmrMultiVariablePowerBasis BaseType;
    BarycentricBasis(VariableIndexType numVariables, PowerType maxPower, 
        VariableIndexType implicitVarIndex = -1);

    VariableType GetImplicitVariable() const
    { 
        return GetVariable(ImplicitVarIndex); 
    }

    VariableIndexType GetImplicitVarIndex() const
    { 
        return ImplicitVarIndex; 
    }

    void SetImplicitVarIndex(VariableIndexType newIndex)
    { 
        CMN_ASSERT( (0 <= newIndex) && (newIndex < GetNumVariables()) );
        ImplicitVarIndex = newIndex;
    }
 
    virtual bool CanSetVariable(VariableIndexType varIndex) const
    {
        return ( (0 <= varIndex) && 
            (varIndex < GetNumVariables()) && 
            (varIndex != GetImplicitVarIndex()) );
    }
    
    virtual void SetVariable(VariableIndexType varIndex, VariableType value);
    
    virtual void SetVariables(VariableType const vars[]);
};
 
#endif