FunctionBase.cxx

Go to the documentation of this file.

// for truncation warning in debug mode
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "FunctionBase.h"

#include <cassert>

using std::string;
using std::vector;

namespace hippodraw {

FunctionBase::FunctionBase ()
{
  m_name = "nil";
}

FunctionBase::
FunctionBase ( const FunctionBase & fb )
  : m_name ( fb.m_name ),
    m_parm_names ( fb.m_parm_names ),
    m_parms ( fb.m_parms ),
    m_fixed_flags ( fb.m_fixed_flags )
{
}

FunctionBase::~FunctionBase ()
{
}

FunctionBase *
FunctionBase::
clone () const
{
  assert ( false );
  return 0;
}

void
FunctionBase::
initialParameters ( const FunctionHelper * )
{
}

void
FunctionBase::
setName ( const char * name )
{
  m_name = name;
}

void FunctionBase::resize ()
{
  assert ( ! m_parm_names.empty () );

  size_t size = m_parm_names.size ();
  m_parms.resize ( size );
  m_fixed_flags.resize ( size, 0 ); // set to free parameter
}

const string & FunctionBase::name () const
{
  return m_name;
}

const vector < string > & FunctionBase::parmNames ( ) const
{
  return m_parm_names;
}

void
FunctionBase::
setParmNames ( const std::vector < std::string > & names )
{
  m_parm_names = names;
  resize ();
}

const vector < double > & FunctionBase::getParameters () const
{
  return m_parms;
}

const vector < int > &
FunctionBase::
getFixedFlags ( ) const
{
  return m_fixed_flags;
}

void
FunctionBase::
setFixedFlags ( const vector < int > & flags )
{
  vector < int > :: const_iterator it = flags.begin ();
  setFixedFlags ( it );
}

void
FunctionBase::
setParameters ( const std::vector< double > & incr )
{
  vector< double >::const_iterator it = incr.begin ();
  setParameters ( it );
}

vector < double > ::const_iterator
FunctionBase::
setParameters ( std::vector < double > :: const_iterator it )
{
  unsigned int size = m_parms.size();
  for ( unsigned int i = 0; i < size; i++ ) {
    m_parms[i] = *it++;
  }

  return it;
}

vector < int > ::const_iterator
FunctionBase::
setFixedFlags ( std::vector < int > :: const_iterator it )
{

  unsigned int size = m_parms.size ();
  for ( unsigned int i = 0; i < size; i++ ) {
    m_fixed_flags[i] = *it++;
}
  return it;
}

bool
FunctionBase::
hasDerivatives () const
{
  return true;
}

double FunctionBase::integrate ( double a, double b ) const
{
  int n = 10;
  double h  = (b - a)/n;
  double x = a;
  double sumt = operator()( a ) / 2;
  
  for( int i = 1; i <=  n - 1; i++ )
    {
      x += h;
      sumt += operator()( x );
    }
  
  sumt = ( sumt + operator()( b ) / 2 ) * h;
  
  return sumt;
}

int FunctionBase::size () const
{
  return m_parm_names.size ();
}

bool FunctionBase::isComposite () const
{
  return false;
}

void FunctionBase::addToComposite ( FunctionBase * )
{
}

void FunctionBase::removeFromComposite ( FunctionBase * )
{
}

int FunctionBase::count()
{
  return 0;
}

double
FunctionBase::
operator () ( const std::vector < double > & v ) const
{
  assert ( v.size () == 1 );

  return this -> operator () ( v.front () );
}

double
FunctionBase::
derivByParm ( int, double ) const
{
        assert ( false );
        return 0.;
}

void
FunctionBase::
initialize ()
{
        assert ( false );
}

double
FunctionBase::
operator () ( double ) const
{
        assert ( false );
        return 0.;
}

unsigned int
FunctionBase::
dimensions () const
{
  return 1;
}

} // namespace hippodraw