pdf.h

Go to the documentation of this file.

// $Id$
// Copyright (C) 2002 Klaas Gadeyne <first dot last at gmail dot com>
 /***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/
#ifndef PDF_H
#define PDF_H

#include <vector>
#include <iostream>
#include "../wrappers/matrix/vector_wrapper.h"
#include "../wrappers/matrix/matrix_wrapper.h"
#include "../sample/sample.h"
#include "../bfl_err.h"
#include "../bfl_constants.h"


namespace BFL
{
  using namespace std;

  // Defines for different sampling methods
#define DEFAULT 0 // Default sampling method, must be valid for every PDF!!
#define BOXMULLER 1
#define CHOLESKY 2
#define RIPLEY 3 // For efficient sampling from discrete/mcpdfs

  template <typename T> class Pdf
    {

    public:

      Pdf(unsigned int dimension=0);

      // Default Copy Constructor will do the job

      virtual ~Pdf();

      virtual Pdf<T>* Clone() const = 0;


      virtual bool SampleFrom (vector<Sample<T> >& list_samples,
                               const unsigned int num_samples,
                               int method = DEFAULT,
                               void * args = NULL) const;


      virtual bool  SampleFrom (Sample<T>& one_sample,
                                int method = DEFAULT,
                                void * args = NULL) const;


      virtual Probability ProbabilityGet(const T& input) const;


      unsigned int DimensionGet() const;


      virtual void DimensionSet(unsigned int dim);


      virtual T ExpectedValueGet() const;


      virtual MatrixWrapper::SymmetricMatrix CovarianceGet() const;

    private:
      unsigned int _dimension;

    };

template<typename T>
Pdf<T>::Pdf(unsigned int dim)
{
  assert((int)dim >= 0);

  _dimension = dim;
#ifdef __CONSTRUCTOR__
  cout << "Pdf constructor" << endl;
#endif
}

template<typename T>
Pdf<T>::~Pdf()
{
#ifdef __DESTRUCTOR__
  cout << "Pdf destructor" << endl;
#endif
}

template<typename T> inline unsigned int
Pdf<T>::DimensionGet () const
{
  return _dimension;
}

template<typename T> void
Pdf<T>::DimensionSet ( unsigned int dim )
{
  assert((int)dim >= 0);
  _dimension = dim;
}

template<typename T> bool
Pdf<T>::SampleFrom (vector<Sample<T> >& list_samples,
                    const unsigned int num_samples,
                    int method,
                    void * args) const
{
  list_samples.resize(num_samples);
  typename vector<Sample<T> >::iterator sample_it;
  for (sample_it = list_samples.begin(); sample_it != list_samples.end() ; sample_it++)
    if (!this->SampleFrom(*sample_it, method,args))
      return false;

  return true;
}

template<typename T> bool
Pdf<T>::SampleFrom (Sample<T>& one_sample,
                    int method,
                    void * args) const
{
  cerr << "Error Pdf<T>: The SampleFrom function was called, but you didn't implement it!\n";
  exit(-BFL_ERRMISUSE);
  return false;
}

template<typename T> Probability
Pdf<T>::ProbabilityGet (const T& input) const
{
  cerr << "Error Pdf<T>: The ProbabilityGet function was called, but you didn't implement it!\n";
  exit(-BFL_ERRMISUSE);
  return 1;
}

template<typename T>  T
Pdf<T>::ExpectedValueGet () const
{
  cerr << "Error Pdf<T>: The ExpectedValueGet function was called, but you didn't implement it!\n";
  exit(-BFL_ERRMISUSE);
  T t;
  return t;
}


template<typename T> MatrixWrapper::SymmetricMatrix
Pdf<T>::CovarianceGet () const
{
  cerr << "Error Pdf<T>: The CovarianceGet function was called, but you didn't implement it!\n";
  exit(-BFL_ERRMISUSE);
  MatrixWrapper::SymmetricMatrix m;
  return m;
}



} // End namespace
#endif