src/getstart.h

#ifndef GETSTART_H
#define GETSTART_H

#include "psychometric.h"
#include "data.h"

#include <list>
#include <vector>

class PsiGrid {
        private:
                unsigned int ndim;   // number of parameters over which the grid goes
                unsigned int ngrid;  // number of points per grid dimension
                std::vector< std::vector<double> > grid1d;  // data points along each single dimension
                std::vector<double> lower_bounds;  // lower bounds for each single dimension
                std::vector<double> upper_bounds;  // upper bounds for each single dimension
        public:
                PsiGrid ( void ) {} 
                PsiGrid (
                                const std::vector<double>& xmin,  
                                const std::vector<double>& xmax,  
                                unsigned int gridsize             
                                ); 
                PsiGrid shift ( const std::vector<double>& newposition ) const;  
                PsiGrid shrink ( const std::vector<double>& newposition ) const; 
                PsiGrid subgrid ( void ) const;                           
                unsigned int get_gridsize ( void ) const { return grid1d.front().size(); } 
                bool empty ( void ) const { return grid1d.empty(); }   
                const std::vector<double>& front ( void ) const { return grid1d.front(); }   
                unsigned int dimension ( void ) const { return grid1d.size(); }              
                double get_lower ( unsigned int i ) const { return lower_bounds[i]; }        
                double get_upper ( unsigned int i ) const { return upper_bounds[i]; }        
                double get_incr ( unsigned int i ) const { return (get_upper(i)-get_lower(i))/(get_gridsize()-1); } 
                double operator() ( unsigned int i, unsigned int j ) const { return grid1d[i][j]; }
};

std::vector<double> linspace (
                double xmin,
                double xmax,
                unsigned int n
                );   

void makegridpoints (
                const PsiGrid& grid,                           
                std::vector<double> prm,                       
                unsigned int pos,                              
                std::list< std::vector<double> > *gridpoints   
                );    

void evalgridpoints (
                const std::list< std::vector<double> >& grid,       
                std::list< std::vector<double> > *bestprm,          
                std::list< double > *L,                             
                const PsiData* data,                                
                const PsiPsychometric* pmf,                         
                unsigned int nbest                                  
                );              

void updategridpoints (
                const PsiGrid& grid,                              
                const std::list< std::vector<double> >& bestprm,  
                std::list< std::vector<double> > *newgridpoints,  
                std::list< PsiGrid > *newgrids                    
                );             

void a_range ( const PsiData* data,  double *xmin, double *xmax );    
void b_range ( const PsiData* data,  double *xmin, double *xmax );    
void lm_range ( const PsiData* data, double *xmin, double *xmax );    
void gm_range ( const PsiData* data, double *xmin, double *xmax );    

void parameter_range ( const PsiData* data, const PsiPsychometric* pmf, unsigned int prmindex, double *xmin, double *xmax );   

std::vector<double> getstart (
                const PsiPsychometric* pmf,    
                const PsiData* data,           
                unsigned int gridsize,         
                unsigned int nneighborhoods,   
                unsigned int niterations,      
                std::vector<double> *incr=NULL 
                );    

std::vector<double> pymakegridpoints (
                const PsiGrid& grid,                           
                std::vector<double> prm,                       
                unsigned int pos                               
                );    

#endif