bpmwf/bpm_wf.h

Go to the documentation of this file.

/*
  libbpm - BPM signal processing/simulation library
  Copyright (C) 2006-07 Bino Maiheu (bino@hep.ucl.ac.uk)
  
  This program 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; either version 2 of the License, or
  (at your option) any later version.
  
  This program 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 General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA 
*/

#ifndef BPMWAVE_H_LOADED__
#define BPMWAVE_H_LOADED__

/* -----------------------------------------------------------------------------
// includes
// -------------------------------------------------------------------------- */
#include <math.h>
#include <float.h>
#include <stdio.h>
#include <stdlib.h>

#include "bpm/bpm_defs.h"
#include "bpm/bpm_units.h"
#include "bpm/bpm_messages.h"
#include "bpm/bpm_nr.h"

/* -----------------------------------------------------------------------------
// macro definitions
// -------------------------------------------------------------------------- */
#define WF_EPS          1.e-10 
#define MAX_ALLOWED_NS  262144 
#define WF_NEAREST    0x0000   
#define WF_LINEAR     0x0001   
#define WF_QUADRATIC  0x0002   
#define WF_SINC       0x0004   
#define WF_LANCZOS    0x0008   
/* -----------------------------------------------------------------------------
// typedefs, enums and other declarations
// -------------------------------------------------------------------------- */
#ifdef __cplusplus
extern "C" {
#endif

  typedef struct {
    int     ns; 
    double  fs; 
    double *wf; 
  } doublewf_t;
  
  typedef struct {
    int     ns; 
    double  fs; 
    int    *wf; 
  } intwf_t;
  
  typedef struct {
    int        ns; 
    double     fs; 
    complex_t *wf; 
  } complexwf_t;
  

  typedef struct {
    int     imax;  
    int     imin;  
    double  max;   
    double  min;   
    double  mean;  
    double  rms;   
  } wfstat_t;
  
/* -----------------------------------------------------------------------------
// function prototypes and declarations
// -------------------------------------------------------------------------- */

  // wfstats_t handling routines -----------------------------------------------

  EXTERN int wfstat_reset( wfstat_t *s );


  EXTERN void wfstat_print( FILE *of, wfstat_t *s );
  

  // doublewf_t handling routines ----------------------------------------------

  EXTERN doublewf_t* doublewf( int ns, double fs );

  
  EXTERN doublewf_t* doublewf_time_series( int ns, double fs );


  EXTERN doublewf_t* doublewf_sample_series( int ns, double fs );


  EXTERN doublewf_t* doublewf_frequency_series( int ns, double fs );


  EXTERN int doublewf_setvalues( doublewf_t *w, double *x );

 
  EXTERN int doublewf_setfunction( doublewf_t *w, 
                                   double (*wffun)( double t, int, double* ),
                                   int npars, double *par );
  

  EXTERN int doublewf_copy( doublewf_t *copy, doublewf_t *src );


  EXTERN doublewf_t* doublewf_copy_new( doublewf_t *w );


  EXTERN int doublewf_subset( doublewf_t *sub, doublewf_t *w, int i1, int i2 );


  EXTERN int doublewf_reset( doublewf_t *w ); 


  EXTERN void doublewf_delete( doublewf_t *w );
  

  EXTERN intwf_t* intwf_cast_new( doublewf_t *w );


  EXTERN int intwf_cast( intwf_t *iw, doublewf_t *w );


  EXTERN int doublewf_compat( doublewf_t *w1, doublewf_t *w2 );

  
  EXTERN int doublewf_add( doublewf_t *w1, doublewf_t *w2 );


  EXTERN int doublewf_subtract( doublewf_t *w1, doublewf_t *w2 );


  EXTERN int doublewf_multiply( doublewf_t *w1, doublewf_t *w2 );


  EXTERN int doublewf_divide( doublewf_t *w1, doublewf_t *w2 );


  EXTERN int doublewf_scale( double f, doublewf_t *w );


  EXTERN int doublewf_bias( double c, doublewf_t *w );


  EXTERN int doublewf_add_cwtone( doublewf_t *w, double amp, double phase, double freq,
                                  double phasenoise );

  
  EXTERN int doublewf_add_dcywave( doublewf_t *w, double amp, double phase, double freq, 
                                   double ttrig, double tdcy, double phasenoise );
  
  
  EXTERN int doublewf_add_ampnoise( doublewf_t *w, double sigma );

  

  EXTERN int doublewf_basic_stats( doublewf_t *w, int s0, int s1, wfstat_t *stats );


  EXTERN int doublewf_derive( doublewf_t *w );

  EXTERN int doublewf_integrate( doublewf_t *w );


  EXTERN void doublewf_print( FILE *of, doublewf_t *w );


  EXTERN double doublewf_getvalue( doublewf_t *w, double t, unsigned int mode );
  

  EXTERN int doublewf_resample( doublewf_t *w2, double fs, doublewf_t *w1, unsigned int mode );



  // intwf_t handling routines ----------------------------------------------


  EXTERN intwf_t* intwf( int ns, double fs );
  
  EXTERN intwf_t* intwf_sample_series( int ns, double fs );


  EXTERN int intwf_setvalues( intwf_t *w, int *x );

 
  EXTERN int intwf_setfunction( intwf_t *w, 
                                int (*wffun)( double t, int, double* ),
                                int npars, double *par );
  

  EXTERN int intwf_copy( intwf_t *copy, intwf_t *src );


  EXTERN intwf_t* intwf_copy_new( intwf_t *w );


  EXTERN int intwf_subset( intwf_t *sub, intwf_t *w, int i1, int i2 );


  EXTERN int intwf_reset( intwf_t *w ); 


  EXTERN void intwf_delete( intwf_t *w );
  

  EXTERN doublewf_t* doublewf_cast_new( intwf_t *w );


  EXTERN int doublewf_cast( doublewf_t *w, intwf_t *iw );


  EXTERN int intwf_compat( intwf_t *w1, intwf_t *w2 );

  
  EXTERN int intwf_add( intwf_t *w1, intwf_t *w2 );


  EXTERN int intwf_subtract( intwf_t *w1, intwf_t *w2 );


  EXTERN int intwf_multiply( intwf_t *w1, intwf_t *w2 );


  EXTERN int intwf_divide( intwf_t *w1, intwf_t *w2 );


  EXTERN int intwf_scale( int f, intwf_t *w );


  EXTERN int intwf_bias( int c, intwf_t *w );


  EXTERN int intwf_add_cwtone( intwf_t *w, double amp, double phase, double freq,
                               double phasenoise );

  
  EXTERN int intwf_add_dcywave( intwf_t *w, double amp, double phase, double freq, 
                                double ttrig, double tdcy, double phasenoise );
  
  
  EXTERN int intwf_add_ampnoise( intwf_t *w, double sigma );

  

  EXTERN int intwf_basic_stats( intwf_t *w, int s0, int s1, wfstat_t *stats );


  EXTERN int intwf_derive( intwf_t *w );

  EXTERN int intwf_integrate( intwf_t *w );


  EXTERN void intwf_print( FILE *of, intwf_t *w );


  EXTERN int intwf_getvalue( intwf_t *w, double t, unsigned int mode );
  

  EXTERN int intwf_resample( intwf_t *w2, double fs, intwf_t *w1, unsigned int mode );



  // complexwf_t handling routines ----------------------------------------------

  EXTERN complexwf_t* complexwf( int ns, double fs );

  EXTERN complexwf_t* complexwf_copy_new( complexwf_t *w );

  EXTERN int complexwf_copy( complexwf_t *copy, complexwf_t *src );

  EXTERN int complexwf_subset( complexwf_t *sub, complexwf_t *w, int i1, int i2 );


  EXTERN int complexwf_setvalues( complexwf_t *w, complex_t *x );

  EXTERN int complexwf_setfunction( complexwf_t *w, 
                                    complex_t (*wffun)( double, int, double* ),
                                    int npars, double *par );

  EXTERN int complexwf_reset( complexwf_t *w );

  EXTERN void complexwf_delete( complexwf_t *w );

  EXTERN int complexwf_compat( complexwf_t *w1, complexwf_t *w2 );

  EXTERN int complexwf_add( complexwf_t *w1, complexwf_t *w2 );

  EXTERN int complexwf_subtract( complexwf_t *w1, complexwf_t *w2 );

  EXTERN int complexwf_multiply( complexwf_t *w1, complexwf_t *w2 );

  
  EXTERN int complexwf_divide( complexwf_t *w1, complexwf_t *w2 );


  EXTERN int complexwf_scale( complex_t f, complexwf_t *w );


  EXTERN int complexwf_bias( complex_t c, complexwf_t *w );


  EXTERN int complexwf_add_cwtone( complexwf_t *w, double amp, double phase, double freq,
                                   double phasenoise );
  

  EXTERN int complexwf_add_dcywave( complexwf_t *w, double amp, double phase, double freq, 
                                    double ttrig, double tdcy, double phasenoise );
 
  EXTERN int complexwf_add_noise( complexwf_t *w, double sigma );


  EXTERN int complexwf_add_ampnoise( complexwf_t *w, double sigma );


  EXTERN int complexwf_add_phasenoise( complexwf_t *w, double sigma );


  EXTERN void complexwf_print( FILE *of, complexwf_t *w );

  EXTERN int complexwf_getreal( doublewf_t *re, complexwf_t *z );

  EXTERN int complexwf_getimag( doublewf_t *im, complexwf_t *z );

  EXTERN int complexwf_getamp( doublewf_t *r, complexwf_t *z );

  EXTERN int complexwf_getphase( doublewf_t *theta, complexwf_t *z );

  EXTERN doublewf_t* complexwf_getreal_new( complexwf_t *z );

  EXTERN doublewf_t* complexwf_getimag_new( complexwf_t *z );

  EXTERN doublewf_t* complexwf_getamp_new( complexwf_t *z );

  EXTERN doublewf_t* complexwf_getphase_new( complexwf_t *z );

  EXTERN int complexwf_setreal( complexwf_t *z, doublewf_t *re );

  EXTERN int complexwf_setimag( complexwf_t *z, doublewf_t *im );


#ifdef __cplusplus
}
#endif

#endif /* #ifndef __BPMWAVE_H_LOADED */

/* ========================== end of file 'bpm_wave.h' ==================== */

---