src/sigmoid.h

/*
 *   See COPYING file distributed along with the psignifit package for
 *   the copyright and license terms
 */
#ifndef SIGMOID_H
#define SIGMOID_H

#include "errors.h"
#include "special.h"
#include <cmath>
#include <string>

class PsiSigmoid
{
        public:
                virtual double f   ( double x ) const { throw NotImplementedError(); }            
                virtual double df  ( double x ) const { throw NotImplementedError(); }            
                virtual double ddf ( double x ) const { throw NotImplementedError(); }            
                virtual double inv ( double p ) const { throw NotImplementedError(); }            
                virtual int    getcode ( void ) const { throw NotImplementedError(); }            
        virtual PsiSigmoid * clone ( void ) const { throw NotImplementedError(); }                
        static std::string getDescriptor ( void ) { throw NotImplementedError(); }
};

class PsiId : public PsiSigmoid
{
        public:
                double f   ( double x ) const { return x; }
                double df  ( double x ) const { return 1; }
                double ddf ( double x ) const { return 0; }
                double inv ( double x ) const { return x; }
                int getcode ( void ) const { return 6; }
                PsiSigmoid * clone ( void ) const { return new PsiId(*this); }
                static std::string getDescriptor ( void ) { return "id"; }
};

class PsiLogistic : public PsiSigmoid
{
        public:
                PsiLogistic ( void ) {}  
                PsiLogistic ( const PsiLogistic& original) {}  
                double f ( double x ) const;                 
                double df ( double x ) const;                
                double ddf ( double x ) const;               
                double inv ( double p ) const { return log(p/(1-p)); }  
                int getcode ( void ) const { return 1; }     
        PsiSigmoid * clone ( void ) const {
            return new PsiLogistic(*this);
        }
        static std::string getDescriptor ( void ) {
            return "logistic";
        }
};

class PsiGauss : public PsiSigmoid
{
        public:
                PsiGauss ( void ) {} 
                PsiGauss ( const PsiGauss& original) {} 
                double f   ( double x ) const;                 
                double df  ( double x ) const;                 
                double ddf ( double x ) const;                 
                double inv ( double p ) const;                 
                int getcode ( void ) const { return 2; }       
        PsiSigmoid * clone (void ) const {
            return new PsiGauss(*this);
        }
        static std::string getDescriptor ( void ) {
            return "gauss";
        }
};

class PsiGumbelL : public PsiSigmoid
{
        public:
                PsiGumbelL ( void ) {} 
                PsiGumbelL ( const PsiGumbelL& original ) {} 
                double f   ( double x ) const;              
                double df  ( double x ) const;              
                double ddf ( double x ) const;              
                double inv ( double p ) const;              
                int getcode ( void ) const { return 3; }    
        PsiSigmoid * clone ( void ) const {
            return new PsiGumbelL(*this);
        }
        static std::string getDescriptor ( void ) {
            return "gumbel_l";
        }
};

class PsiGumbelR : public PsiSigmoid
{
        public:
                PsiGumbelR ( void ) {} 
                PsiGumbelR ( const PsiGumbelR& original ) {} 
                double f   ( double x ) const;             
                double df  ( double x ) const;             
                double ddf ( double x ) const;             
                double inv ( double p ) const;             
                int getcode ( void ) const { return 6; }   
        PsiSigmoid * clone ( void ) const {
            return new PsiGumbelR(*this);
        }
        static std::string getDescriptor ( void ) {
            return "gumbel_r";
        }
};

class PsiCauchy : public PsiSigmoid
{
        public:
        PsiCauchy( void ) {}                 
        PsiCauchy( const PsiCauchy& oiginal) {} 
                double f   ( double x ) const;             
                double df  ( double x ) const;             
                double ddf ( double x ) const;             
                double inv ( double p ) const;             
                int    getcode ( void ) const { return 4; }
        PsiSigmoid * clone ( void ) const {
            return new PsiCauchy(*this);
        }
        static std::string getDescriptor ( void ) {
            return "cauchy";
        }
};

class PsiExponential : public PsiSigmoid
{
        public:
        PsiExponential( void ) {}                 
        PsiExponential( const PsiExponential& oiginal) {} 
                double f   (double x ) const;              
                double df  (double x ) const;              
                double ddf (double x ) const;              
                double inv (double p ) const throw(BadArgumentError);              
                int    getcode ( void ) const { return 5; }
        PsiSigmoid * clone ( void ) const {
            return new PsiExponential(*this);
        }
        static std::string getDescriptor ( void ) {
            return "exponential";
        }
};

#endif