LinearSumFunction.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif
#endif

#include "LinearSumFunction.h"

#ifdef SSTREAM_DEFECT
#include <strstream>
using std::ostrstream;
#else
#include <sstream>
using std::ostringstream;
#endif

#include <cassert>

#ifdef ITERATOR_MEMBER_DEFECT
using namespace std;
#else
using std::vector;
using std::string;
#endif

LinearSumFunction::LinearSumFunction ( )
{
  initialize ();
}

LinearSumFunction::LinearSumFunction ( const LinearSumFunction & old )
{
  FunctionList_t::const_iterator it = old.m_functions.begin();
  while ( it != old.m_functions.end() ) {
    FunctionBase * function = (*it)->clone ();
    m_functions.push_back ( function );
  }

  initialize ();
}

void LinearSumFunction::initialize ()
{
  m_name = "Linear Sum";
}

FunctionBase * LinearSumFunction::clone () const
{

  return new LinearSumFunction ( *this );
}

const vector < string > & LinearSumFunction::parmNames() const
{
  LinearSumFunction * self = const_cast < LinearSumFunction * > ( this );

  self->m_parm_names.clear();

  unsigned int f_size = m_functions.size ();
  for ( unsigned int i = 0; i < f_size; i++ ) {
#ifdef SSTREAM_DEFECT
    ostrstream strm_text;
#else
    std::ostringstream strm_text;
#endif
    strm_text << "-" << i << std::ends;

    const vector< string > & names = m_functions[i] -> parmNames ();
    unsigned int n_size = names.size ();
    for ( unsigned int j = 0; j < n_size; j++ ) {
      string name = names [j];
      name += strm_text.str();
      self -> m_parm_names.push_back ( name );
    }
  }

  return m_parm_names;
}

const vector<double> & LinearSumFunction::getParameters ()
{
  m_parms.clear ();
  FunctionList_t::const_iterator it = m_functions.begin ();
  for ( ; it != m_functions.end (); ++it ) {
    const vector<double> & vals = (*it)->getParameters ();
    m_parms.insert ( m_parms.end (), vals.begin(), vals.end () ); 
  }
  return m_parms;
}


vector< double >::const_iterator
LinearSumFunction::
setParameters ( std::vector< double >::const_iterator it )
{
  FunctionList_t::iterator fit = m_functions.begin();

  for ( ;fit != m_functions.end (); ++fit ) {
    it = (*fit)->setParameters ( it );
  }

  return it;
}


double LinearSumFunction::derivByParm ( int index, double x ) const
{
  double value = 0;
  unsigned int numf = m_functions.size ();
  for ( unsigned int i = 0; i < numf; i++ ) {
    int size = m_functions [i] -> size ();
    if ( index < size ) {
      value = m_functions [i] -> derivByParm ( index, x );
      break;
    }
    else {
      index -= size;
    }
  }

  return value;
}

int LinearSumFunction::count ()
{
  return m_functions.size();
}

int
LinearSumFunction::
size () const
{
  int number = 0;
  unsigned int numf = m_functions.size ();

  for ( unsigned int i = 0; i < numf; i++ ) {
    const FunctionBase * function = m_functions [i];
    number += function -> size ();
  }

  return number;
}

bool LinearSumFunction::isComposite () const
{
  return true;
}

void LinearSumFunction:: addToComposite ( FunctionBase * function )
{
  // not sure why this was put in, but it breaks archiving and
  // dearchiving

//   if ( m_functions.empty() ) {
//     m_name += " of ";
//   }
//   else {
//     m_name += " + ";
//   }
//   m_name += function -> name ();

  m_functions.push_back ( function );
}

void
LinearSumFunction::
removeFromComposite ( FunctionBase * function )
{
  FunctionList_t::iterator it = m_functions.begin ();

  while ( it != m_functions.end () ) {
    if ( (*it) == function ){
      it = m_functions.erase ( it );
    }
    else{
      it ++;
    }
  }
}

double LinearSumFunction::operator () ( double x ) const
{
  double sum = 0.0;
  FunctionList_t::const_iterator it = m_functions.begin ();

  for ( ; it != m_functions.end (); ++it ) {
    sum += (*it)->operator () ( x );
  }
  return sum;
}

void 
LinearSumFunction::
initialParameters ( const FunctionHelper * helper )
{
  // does nothing
}

---