FunctionBase.sip

Go to the documentation of this file.

/* -*- mode:c++ -*- */

// class FunctionHelper;

class FunctionBase
{
%TypeHeaderCode
#include "functions/FunctionBase.h"
%End

protected:

  FunctionBase ();
  FunctionBase ( const FunctionBase & );
  virtual double derivByParm ( int , double  ) const = 0;
  void setName ( const char * );
  virtual void initialize () = 0;

public:

  virtual ~FunctionBase();

  const std::string & name () const;

  virtual FunctionBase * clone () const;
%VirtualCatcherCode
    PyObject *sipResObj = sipCallMethod ( 0, sipMethod, "" );
    if ( !sipResObj || 
         sipParseResult ( 0,
                          sipMethod,
                          sipResObj,
                          "L",
                          sipForceConvertTo_FunctionBase,
                          &sipRes) < 0) {
                PyErr_Print();
    }
  sipTransfer ( sipResObj, 1 );
%End

  virtual int size () const;

//   /** Returns the number of free parameters.
//    */
//   virtual unsigned int numberFreeParms () const;

  virtual const std::vector < std::string > & parmNames ( );

  void setParmNames ( const std::vector < std::string > & );

//   /** Returns a vector of free parameter names. Names are appended
//       at the back of the vector.*/
//   void freeParmNames ( std::vector< std::string > &  ) const;
    
  virtual bool isComposite () const;

  virtual void addToComposite ( FunctionBase * );

  virtual void removeFromComposite ( FunctionBase * );

  virtual int count ();

  virtual const std::vector< double > & getParameters ();

  virtual void setParameters ( const std::vector< double > & );

//   /** Returns the fixed parameter flags. */
//   virtual const std::vector < bool > & fixedFlags () const;

//   /** Sets the fixed flag for each function parameter.  A fixed
//       parameter is not returned or set by the values() or setValues()
//       member functions. */
//   virtual void setFixedFlags ( const std::vector < bool > & );

//   /** Sets the parameter values to the value pointed to by the
//       iterator. Returns an iterator to a data element one past the
//       last used data element. */
//   virtual std::vector< double >::const_iterator 
//   setParameters ( std::vector< double >::const_iterator it );

//   /** Sets the fixed flag for the parameter values.  Returns an
//       iterator to the end of the sequence used. */
//   virtual std::vector < bool >:: const_iterator
//   setFixedFlags ( std::vector < bool >:: const_iterator it );

  virtual double operator () ( double ) const = 0;

// %MethodCode
// sipRes = sipCpp -> operator () ( 0. );
// %End


//   virtual double __call__ ( double );
//   /** The function call operator.  @bug Temporary fix until we
//    undertand how to get SIP to accept operator()().*/
//   virtual double valueAt ( double ) const;
  
//   /** The function call operator for multi-dimension coordinate
//       variable.  Returns the value of the function at coordinate
//       represented by @a v.  The implementation in this base class uses
//       the first element of the vector and calls operator () ( double ).
//   */
//   virtual double operator () ( const std::vector < double > & v ) const;

//   /** Sets the FunctionHelper so that the function can calculate a
//       reasonable set of initial parameter values. */
//   virtual void initialParameters ( const FunctionHelper *  );

//   /** Returns the value of the free parameters.  For each free
//       parameter, its value is push_back to the @p parms vector */
//   virtual void getFreeParameters ( std::vector < double > & ) const;

//   /** Returns the value of the k-th free parameters. */
//   virtual double getFreeParameter( unsigned int ) const;
  
//   /** Sets the values of the free parameters. */
//   void setFreeParameters ( const std::vector< double > &  );

//   /** Sets the values of the free parameters.  For each free
//       parameter, its value is set from the value pointed by the
//       iterator, and the iterator is advanced.  Returns the advanced
//       iterator. */
//   virtual std::vector< double >:: const_iterator 
//   setFreeParameters ( std::vector< double >:: const_iterator it );

  virtual bool hasDerivatives () const;

//   /** Returns the function's derivatives.  Calculates the function's
//       derivatives for each free parameter at the coordinate value @p
//       x.  Appends the derivatives at the end of the sequence @a
//       derives. */
//   virtual void getFreeDerivatives ( std::vector < double > & , 
//                                  double ) const;

  virtual double integrate ( double , double  ) const;

};

---