plComputableObject.h

/*=============================================================================
 * Product        : OpenPL 
 * File           : plComputableObject.h
 * Author         : Juan-Manuel Ahuactzin
 * Creation       : Wed Jun  6 12:01:46 2001
 *
 *=============================================================================
 *     (c) Copyright 2000, Centre National de la Recherche Scientifique,
 *                              all rights reserved
 *=============================================================================
 *
 *------------------------- Description ---------------------------------------
 *   
 *   
 *-----------------------------------------------------------------------------
*/


#ifndef _plComputableObject_h_
#define _plComputableObject_h_

#include <plObject.h>
#include <plMath.h>
#include <plSignature.h>
#include <plVariablesConjunction.h>
#include <plValues.h>
#include <plDataValues.h>

/*****************************************************************************
 *                           External Classes
 *****************************************************************************/
class kplComputableObject;
class kplVariable;


/*****************************************************************************
 *                           Classes Definitions
 *****************************************************************************/

class plComputableObjectList : public plObject
{
  //friend class plComputableObject;
public:
  typedef list <kplComputableObject *> kplCOL;
  typedef kplCOL::iterator iterator;
  typedef kplCOL::const_iterator const_iterator;    
  
protected :
  kplCOL internList;
public :
  plComputableObjectList() {}
  
  plComputableObjectList(const plComputableObject & obj);
  
  plComputableObjectList(const plComputableObjectList & l);

  ~plComputableObjectList();

  plComputableObjectList &operator=(const plComputableObjectList & l);
  
  plComputableObjectList operator^(const plComputableObject &f1) const;

  plComputableObjectList operator*(const plComputableObject &f1) const;
  
  plComputableObjectList operator*(const plComputableObjectList &r_list) const;
  
  const plComputableObjectList& operator*=(const plComputableObject &f1);
  
  const plComputableObjectList& operator*=(const plComputableObjectList &r_list);
  
  void push_back(kplComputableObject * o);
  void push_back(const plComputableObject & o); 
  
  iterator begin() {return internList.begin();}
  const_iterator begin() const {return internList.begin();}
  
  iterator end() {return internList.end();}
  const_iterator end() const {return internList.end();}
  
  unsigned int size() const {return internList.size();}

  void clear();
};



class plComputableObject : public plObject
{
  
 protected:
  
  plSignature signature;

  list <kplVariable *> head_variables;

  unsigned int variables_size;

  list <kplVariable*> search_variables;
  
  list <kplVariable*> known_variables;

  mutable plDataValues head_variables_data_values;

  mutable plDataValues known_variables_data_values;

  virtual plProbValue kernel_compute(const plDataValues &params) const=0;

  virtual void kernel_rename(const map 
                 <kplVariable*, kplVariable *> &rename_map)=0;

  virtual void Output(ostream &out) const;
  
public:
  void set_variables(const list <kplVariable*> search_vars, 
             const list <kplVariable*> known_vars);

  void set_variables(const list <kplVariable*> search_vars);
  
  

  bool is(const plComputableObjectType& type) const;


  bool is_some_on_signature(const plSignature& prototype_signature) const;

  plVariablesConjunction get_head_plvariables() const;

  plVariablesConjunction get_search_plvariables() const;

  plVariablesConjunction get_known_plvariables() const;

  plComputableObject();

  virtual ~plComputableObject();

  virtual plProbValue compute(const plValues &parameter)const;

  virtual plProbValue compute(int *parameter)const;

  virtual plProbValue compute(unsigned int *parameter)const;
  
  virtual plProbValue compute(long int *parameter)const;
  
  virtual plProbValue compute(float *parameter)const;
  
  virtual plProbValue compute(double *parameter)const;

  virtual plProbValue compute(long double *parameter)const;

  virtual plProbValue compute(int parameter)const;

  /* *Computes the value of the function, by using a single unsigned
      integer parameter. */
  virtual plProbValue compute(unsigned int parameter)const;

  virtual plProbValue compute(long int parameter)const;

  virtual plProbValue compute(float parameter)const;

  virtual plProbValue compute(double parameter)const;

#ifndef RAVI_INTERFACE
  virtual plProbValue compute(long double parameter)const;
#endif

  virtual plProbValue compute(const vector <int> &parameter)const;

  virtual plProbValue compute(const vector <unsigned int> &parameter)const;
  
  virtual plProbValue compute(const vector <long int> &parameter)const;
  
  virtual plProbValue compute(const vector <float> &parameter)const;
  
  virtual plProbValue compute(const vector <double> &parameter)const;

  virtual plProbValue compute(const vector <long double> &parameter)const;

  virtual kplComputableObject*  get_root_kernel()const =0 ;

#ifndef RAVI_INTERFACE
  const list <kplVariable*> get_head_variables() const;
#endif

  bool rename(const plVariablesConjunction &new_variables);

  virtual ostream& write_head(ostream &out) const=0;

  virtual ostream& write_body(ostream &out) const = 0;


  plComputableObjectList operator^(const plComputableObject &f2)const;

  plComputableObjectList operator^(const plComputableObjectList &v_list)const ;

  plComputableObjectList operator*(const plComputableObject &f2)const ;

  plComputableObjectList operator*(const plComputableObjectList &v_list)const;

  virtual void replace(const plVariablesConjunction &left_vars, const plVariablesConjunction &right_vars, 
           plCndKernel &new_cnd_kernel) = 0;
  
  virtual void replace(const plVariablesConjunction &left_vars, plKernel &new_kernel) = 0;

};




ostream & operator<<(ostream & out, const plComputableObjectList & klist);



#endif

---