libran.h

Go to the documentation of this file.

/*
 * Copyright    2019    R.K. Owen, Ph.D.
 * License      see lgpl.md (Gnu Lesser General Public License)
 */

#ifndef         _LIBRAN_H_
#  define       _LIBRAN_H_
#  ifdef __cplusplus
extern "C" {
#  endif

#  include <stdarg.h>

#  define LR_VER_MAJOR  0
#  define LR_VER_MINOR  5
#  define LR_VER_PATCH  1
#  define LR_VERSION    LR_VER_MAJOR.LR_VER_MINOR.LR_VER_PATCH

#  define LR_DATE       20191201

#  define LRerr_OK                      0x00 
#  define LRerr_Unspecified             0x01 
#  define LRerr_BadDataType             0x03 
#  define LRerr_BadLRType               0x05 
#  define LRerr_NoAuxiliaryObject       0x09 
#  define LRerr_NoAuxNormalizeDone      0x0B 
#  define LRerr_BadAuxSetup             0x0D 
#  define LRerr_BinGeneric              0x11 
#  define LRerr_TooManyValues           0x13 
#  define LRerr_InvalidInputValue       0x15 
#  define LRerr_InvalidRange            0x17 
#  define LRerr_UnmetPreconditions      0x19 
#  define LRerr_SuspiciousValues        0x1B 
#  define LRerr_AllocFail               0x1D 
#  define LRerr_InvalidCDF              0x21 
typedef enum {

        poisson = 1,    
        geometric,      
        binomial,       
        unif,           
        piece,          
        lspline,        
        uinvcdf,        
        gausbm,         
        gausmar,        
        gsn2,           
        gsn4,           
        gsn12,          
        logd,           
        nexp,           
        erlang,         
        cauchy,         
        cauchymar       
}       LR_type;

typedef union {
        long    l; 
        int     i; 
        float   f; 
        double  d; 
}       LR_val;

typedef enum {
        LR_int = 1,     
        LR_long,        
        LR_float,       
        LR_double       
}       LR_data_type;

/* tag & predefine the fns object */
typedef struct LR_obj LR_obj;

struct LR_obj {
        const char const *      type;   
        LR_type         t;      
        LR_data_type    d;      
        LR_val          a;      
        LR_val          b;      
        LR_val          m;      
        LR_val          s;      
        LR_val          x;      
        int             k;      
        int             n;      
        float           p;      
        float           q;      
        LR_val          iy;     
        LR_val          iy0;    
        int     (*ui)(LR_obj *);        
        long    (*ul)(LR_obj *);        
        float   (*uf)(LR_obj *);        
        double  (*ud)(LR_obj *);        
        float   (*rnf)(LR_obj *);               
        double  (*rnd)(LR_obj *);               
        int     (*rni)(LR_obj *);               
        float   (*pdff)(LR_obj *, float);       
        double  (*pdfd)(LR_obj *, double);      
        float   (*pdfi)(LR_obj *, int);         
        float   (*cdff)(LR_obj *, float);       
        double  (*cdfd)(LR_obj *, double);      
        float   (*cdfi)(LR_obj *, int);         
        void *          aux;    
        int             errno;  
};

typedef struct {
        int             n;      
        int             nn;     
        long            c;      
        double *        bdrs;   
        long *          bins;   
        int             errno;  
}       LR_bin;

typedef struct {
        int             n;      
        int             nn;     
        double *        bdrs;   
        double *        c;      
        double *        sc;     
        double          norm;   
        int             flags;  
        int (*new)(LR_obj *o, int n);           
        int (*rm)(LR_obj *o);                   
        int (*set)(LR_obj *o, double x, double p); 
        int (*normalize)(LR_obj *o);            
}       LR_pcs;

#  define       LR_AUX_NORM             0x01 
#  define       LR_AUX_SET              0x02 
typedef struct {
        double (*dcdf)(double x);       /*<! double version of CDF */
        float  (*fcdf)(float x);        /*<! float version of CDF */
}       LR_uinvcdf;

/* LibRan function declarations */
LR_obj *LR_new(LR_type t, LR_data_type d);
int LR_rm(LR_obj **o);
int LR_check(LR_obj *o);

/* LibRan object parameter setting */
int LR_vset(LR_obj *o, char *x, va_list ap);
int LR_set(LR_obj *o, char x, ...);
int LR_set_all(LR_obj *o, char *x, ...);

/* LibRan binning object */
LR_bin *LR_bin_new(int n);
int LR_bin_rm(LR_bin **b);
int LR_bin_set(LR_bin *b, double x);
int LR_bin_add(LR_bin *b, double x);

/* LibRan error and info routines */
char *LRstrerror(int LRerrno);
char *LRstrerrno(int LRerrno);
void LRperror(char *str, int LRerrno);
char *LRversion(char *str);

/* urand routines */
int     LR_irand(LR_obj *);
float   LR_frand(LR_obj *);
void    LR_isetseed(LR_obj *, int ity);
int     LR_igetseed(LR_obj *);
int     LR_igetrand(LR_obj *);
float   LR_fgetrand(LR_obj *);

long    LR_lrand(LR_obj *);
double  LR_drand(LR_obj *);
void    LR_lsetseed(LR_obj *, long lty);
long    LR_lgetseed(LR_obj *);
long    LR_lgetrand(LR_obj *);
double  LR_dgetrand(LR_obj *);

int     LR_igetval(char *str);
long    LR_lgetval(char *str);
float   LR_fgetval(char *str);
double  LR_dgetval(char *str);

/* LibRan generic distribution functions */
/* double */
double LRd_RAN(LR_obj *o);
double LRd_PDF(LR_obj *o, double x);
double LRd_CDF(LR_obj *o, double x);
/* float */
float LRf_RAN(LR_obj *o);
float LRf_PDF(LR_obj *o, float x);
float LRf_CDF(LR_obj *o, float x);
/* int */
int   LRi_RAN(LR_obj *o);
float LRi_PDF(LR_obj *o, int x);
float LRi_CDF(LR_obj *o, int x);
/* LibRan generic auxiliary functions */
int LR_aux_new(LR_obj *o, int n);
int LR_aux_rm(LR_obj *o);
int LR_aux_set(LR_obj *o, double x, double p);
int LR_aux_norm(LR_obj *o);

/* specific LibRan distribution functions */
/* double unif */
double LRd_unif_RAN(LR_obj *o);
double LRd_unif_PDF(LR_obj *o, double x);
double LRd_unif_CDF(LR_obj *o, double x);
/* float unif */
float LRf_unif_RAN(LR_obj *o);
float LRf_unif_PDF(LR_obj *o, float x);
float LRf_unif_CDF(LR_obj *o, float x);

/* piecewise uniform */
int LR_pcs_new(LR_obj *o, int n);
int LR_pcs_rm(LR_obj *o);
int LR_pcs_set(LR_obj *o, double x, double p);
int LR_pcs_norm(LR_obj *o);
/* double piece */
double LRd_piece_RAN(LR_obj *o);
double LRd_piece_PDF(LR_obj *o, double x);
double LRd_piece_CDF(LR_obj *o, double x);
/* float piece */
float LRf_piece_RAN(LR_obj *o);
float LRf_piece_PDF(LR_obj *o, float x);
float LRf_piece_CDF(LR_obj *o, float x);

/* linear spline */
int LR_lspl_new(LR_obj *o, int n);
int LR_lspl_rm(LR_obj *o);
int LR_lspl_set(LR_obj *o, double x, double p);
int LR_lspl_norm(LR_obj *o);
/* double linear spline */
double LRd_lspline_RAN(LR_obj *o);
double LRd_lspline_PDF(LR_obj *o, double x);
double LRd_lspline_CDF(LR_obj *o, double x);
/* float linear spline */
float LRf_lspline_RAN(LR_obj *o);
float LRf_lspline_PDF(LR_obj *o, float x);
float LRf_lspline_CDF(LR_obj *o, float x);

/* double user inverse CDF */
double LRd_uinvcdf_RAN(LR_obj *o);
double LRd_uinvcdf_PDF(LR_obj *o, double x);
double LRd_uinvcdf_CDF(LR_obj *o, double x);
int LRd_uinvcdf(LR_obj *o, double (*cdf)(double));
/* float user inverse CDF spline */
float LRf_uinvcdf_RAN(LR_obj *o);
float LRf_uinvcdf_PDF(LR_obj *o, float x);
float LRf_uinvcdf_CDF(LR_obj *o, float x);
int LRf_uinvcdf(LR_obj *o, float (*cdf)(float));

/* double negative exponential */
double LRd_nexp_RAN(LR_obj *o);
double LRd_nexp_PDF(LR_obj *o, double x);
double LRd_nexp_CDF(LR_obj *o, double x);
/* float negative exponential */
float LRf_nexp_RAN(LR_obj *o);
float LRf_nexp_PDF(LR_obj *o, float x);
float LRf_nexp_CDF(LR_obj *o, float x);

/* double Erlang */
double LRd_erlang_RAN(LR_obj *o);
double LRd_erlang_PDF(LR_obj *o, double x);
double LRd_erlang_CDF(LR_obj *o, double x);
/* float Erlang */
float LRf_erlang_RAN(LR_obj *o);
float LRf_erlang_PDF(LR_obj *o, float x);
float LRf_erlang_CDF(LR_obj *o, float x);

/* double gaussian */
double LRd_gausbm_RAN(LR_obj *o);
double LRd_gausmar_RAN(LR_obj *o);
double LRd_gaus_PDF(LR_obj *o, double x);
double LRd_gaus_CDF(LR_obj *o, double x);
/* float gaussian */
float LRf_gausbm_RAN(LR_obj *o);
float LRf_gausmar_RAN(LR_obj *o);
float LRf_gaus_PDF(LR_obj *o, float x);
float LRf_gaus_CDF(LR_obj *o, float x);

/* double gsn2 */
double LRd_gsn2_RAN(LR_obj *o);
double LRd_gsn2_PDF(LR_obj *o, double x);
double LRd_gsn2_CDF(LR_obj *o, double x);
/* float gsn2 */
float LRf_gsn2_RAN(LR_obj *o);
float LRf_gsn2_PDF(LR_obj *o, float x);
float LRf_gsn2_CDF(LR_obj *o, float x);

/* double gsn4 */
double LRd_gsn4_RAN(LR_obj *o);
double LRd_gsn4_PDF(LR_obj *o, double x);
double LRd_gsn4_CDF(LR_obj *o, double x);
/* float gsn4 */
float LRf_gsn4_RAN(LR_obj *o);
float LRf_gsn4_PDF(LR_obj *o, float x);
float LRf_gsn4_CDF(LR_obj *o, float x);

/* double gsn12 */
double LRd_gsn12_RAN(LR_obj *o);
double LRd_gsn12_PDF(LR_obj *o, double x);
double LRd_gsn12_CDF(LR_obj *o, double x);
double LRd_xgsn12_PDF(LR_obj *o, double x);
double LRd_xgsn12_CDF(LR_obj *o, double x);
/* float gsn12 */
float LRf_gsn12_RAN(LR_obj *o);
float LRf_gsn12_PDF(LR_obj *o, float x);
float LRf_gsn12_CDF(LR_obj *o, float x);

/* double cauchy */
double LRd_cauchy_RAN(LR_obj *o);
double LRd_cauchymar_RAN(LR_obj *o);
double LRd_cauchy_PDF(LR_obj *o, double x);
double LRd_cauchy_CDF(LR_obj *o, double x);
/* float cauchy */
float LRf_cauchy_RAN(LR_obj *o);
float LRf_cauchymar_RAN(LR_obj *o);
float LRf_cauchy_PDF(LR_obj *o, float x);
float LRf_cauchy_CDF(LR_obj *o, float x);

/* Poisson */
int LRi_poisson_RAN(LR_obj *o);
float LRi_poisson_PDF(LR_obj *o, int x);
float LRi_poisson_CDF(LR_obj *o, int x);

/* Geometric */
int LRi_geometric_RAN(LR_obj *o);
float LRi_geometric_PDF(LR_obj *o, int x);
float LRi_geometric_CDF(LR_obj *o, int x);

/* Binomial */
int LRi_binomial_RAN(LR_obj *o);
float LRi_binomial_PDF(LR_obj *o, int x);
float LRi_binomial_CDF(LR_obj *o, int x);

#  ifdef __cplusplus
}
#  endif
#endif          /* _LIBRAN_H_ */