AVFactories.h   AVFactories.h 
skipping to change at line 18 skipping to change at line 18
#define _AVFACTORIES_H #define _AVFACTORIES_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <stdarg.h> #include <stdarg.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
\defgroup AVFactories_h AVFactories_h \addtogroup AVFactories_h
\ingroup factories
\brief Provides prototype and status code information for use of CreateVect or, \brief Provides prototype and status code information for use of CreateVect or,
CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/AVFactories.h> #include <lal/AVFactories.h>
\endcode \endcode
\section secXLALfcts XLAL Functions \section secXLALfcts XLAL Functions
skipping to change at line 172 skipping to change at line 171
array of dimensions is \c NULL). array of dimensions is \c NULL).
The destroy function does not return any value. If the function is passed a The destroy function does not return any value. If the function is passed a
\c NULL pointer, it will set \c xlalErrno to \c #XLAL_EFAULT. \c NULL pointer, it will set \c xlalErrno to \c #XLAL_EFAULT.
If the function is passed an object that appears corrupted (e.g., a If the function is passed an object that appears corrupted (e.g., a
vector with zero length or will a \c NULL data pointer) it will set vector with zero length or will a \c NULL data pointer) it will set
\c xlalErrno to \c #XLAL_EINVAL. \c xlalErrno to \c #XLAL_EINVAL.
*/ */
/*@{ */ /*@{ */
/** \name Error Codes *//*@{*/
#define AVFACTORIESH_ELENGTH 1 /** \name Error Codes */
#define AVFACTORIESH_EVPTR 2 /*@{*/
#define AVFACTORIESH_EUPTR 4 #define AVFACTORIESH_ELENGTH 1 /**< Illegal length. */
#define AVFACTORIESH_EDPTR 8 #define AVFACTORIESH_EVPTR 2 /**< Null vector/array handle. */
#define AVFACTORIESH_EMALLOC 16 #define AVFACTORIESH_EUPTR 4 /**< Non-null vector/array pointer. */
#define AVFACTORIESH_EDPTR 8 /**< Null vector/array data. */
#define AVFACTORIESH_EMALLOC 16 /**< Malloc failure. */
/*@}*/
/*@} */
/** \cond DONT_DOXYGEN */
#define AVFACTORIESH_MSGELENGTH "Illegal length." #define AVFACTORIESH_MSGELENGTH "Illegal length."
#define AVFACTORIESH_MSGEVPTR "Null vector/array handle." #define AVFACTORIESH_MSGEVPTR "Null vector/array handle."
#define AVFACTORIESH_MSGEUPTR "Non-null vector/array pointer." #define AVFACTORIESH_MSGEUPTR "Non-null vector/array pointer."
#define AVFACTORIESH_MSGEDPTR "Null vector/array data." #define AVFACTORIESH_MSGEDPTR "Null vector/array data."
#define AVFACTORIESH_MSGEMALLOC "Malloc failure." #define AVFACTORIESH_MSGEMALLOC "Malloc failure."
/*@}*/ /** \endcond */
/*@}*/
/* CHAR vector prototypes */ /**
CHARVector * XLALCreateCHARVector ( UINT4 length ); \defgroup ArrayFactories_c Module ArrayFactories.c
CHARVector * XLALResizeCHARVector ( CHARVector * vector, UINT4 length ); \ingroup AVFactories_h
void XLALDestroyCHARVector ( CHARVector * vector );
void LALCHARCreateVector ( LALStatus *, CHARVector **, UINT4 );
void LALCHARResizeVector ( LALStatus *, CHARVector **, UINT4 );
void LALCHARDestroyVector ( LALStatus *, CHARVector ** );
/* INT2 vector prototypes */ \brief Create/destroy \<datatype\>Array objects.
INT2Vector * XLALCreateINT2Vector ( UINT4 length );
INT2Vector * XLALResizeINT2Vector ( INT2Vector * vector, UINT4 length );
void XLALDestroyINT2Vector ( INT2Vector * vector );
void LALI2CreateVector ( LALStatus *, INT2Vector **, UINT4 );
void LALI2ResizeVector ( LALStatus *, INT2Vector **, UINT4 );
void LALI2DestroyVector ( LALStatus *, INT2Vector ** );
/* INT2 array prototypes */ \heading{Description}
The \c CreateArray family of functions create a \<datatype\>Array of the ap
propriate dimensions.
The \c DestroyArray family of functions return the storage allocated by the
\c CreateArray functions to the system.
*/
/*@{*/
/** \name INT2 array prototypes */
/*@{*/
INT2Array * XLALCreateINT2ArrayL ( UINT4, ... ); INT2Array * XLALCreateINT2ArrayL ( UINT4, ... );
INT2Array * XLALCreateINT2ArrayV ( UINT4, UINT4 * ); INT2Array * XLALCreateINT2ArrayV ( UINT4, UINT4 * );
INT2Array * XLALCreateINT2Array ( UINT4Vector * ); INT2Array * XLALCreateINT2Array ( UINT4Vector * );
INT2Array * XLALResizeINT2ArrayL ( INT2Array *, UINT4, ... ); INT2Array * XLALResizeINT2ArrayL ( INT2Array *, UINT4, ... );
INT2Array * XLALResizeINT2ArrayV ( INT2Array *, UINT4, UINT4 * ); INT2Array * XLALResizeINT2ArrayV ( INT2Array *, UINT4, UINT4 * );
INT2Array * XLALResizeINT2Array ( INT2Array *, UINT4Vector * ); INT2Array * XLALResizeINT2Array ( INT2Array *, UINT4Vector * );
void XLALDestroyINT2Array ( INT2Array * ); void XLALDestroyINT2Array ( INT2Array * );
void LALI2CreateArray ( LALStatus *, INT2Array **, UINT4Vector * ); void LALI2CreateArray ( LALStatus *, INT2Array **, UINT4Vector * );
void LALI2ResizeArray ( LALStatus *, INT2Array **, UINT4Vector * ); void LALI2ResizeArray ( LALStatus *, INT2Array **, UINT4Vector * );
void LALI2DestroyArray ( LALStatus *, INT2Array ** ); void LALI2DestroyArray ( LALStatus *, INT2Array ** );
/*@}*/
/* INT4 vector prototypes */ /** \name INT4 array prototypes */
INT4Vector * XLALCreateINT4Vector ( UINT4 length ); /*@{*/
INT4Vector * XLALResizeINT4Vector ( INT4Vector * vector, UINT4 length );
void XLALDestroyINT4Vector ( INT4Vector * vector );
void LALI4CreateVector ( LALStatus *, INT4Vector **, UINT4 );
void LALI4ResizeVector ( LALStatus *, INT4Vector **, UINT4 );
void LALI4DestroyVector ( LALStatus *, INT4Vector ** );
/* INT4 array prototypes */
INT4Array * XLALCreateINT4ArrayL ( UINT4, ... ); INT4Array * XLALCreateINT4ArrayL ( UINT4, ... );
INT4Array * XLALCreateINT4ArrayV ( UINT4, UINT4 * ); INT4Array * XLALCreateINT4ArrayV ( UINT4, UINT4 * );
INT4Array * XLALCreateINT4Array ( UINT4Vector * ); INT4Array * XLALCreateINT4Array ( UINT4Vector * );
INT4Array * XLALResizeINT4ArrayL ( INT4Array *, UINT4, ... ); INT4Array * XLALResizeINT4ArrayL ( INT4Array *, UINT4, ... );
INT4Array * XLALResizeINT4ArrayV ( INT4Array *, UINT4, UINT4 * ); INT4Array * XLALResizeINT4ArrayV ( INT4Array *, UINT4, UINT4 * );
INT4Array * XLALResizeINT4Array ( INT4Array *, UINT4Vector * ); INT4Array * XLALResizeINT4Array ( INT4Array *, UINT4Vector * );
void XLALDestroyINT4Array ( INT4Array * ); void XLALDestroyINT4Array ( INT4Array * );
void LALI4CreateArray ( LALStatus *, INT4Array **, UINT4Vector * ); void LALI4CreateArray ( LALStatus *, INT4Array **, UINT4Vector * );
void LALI4ResizeArray ( LALStatus *, INT4Array **, UINT4Vector * ); void LALI4ResizeArray ( LALStatus *, INT4Array **, UINT4Vector * );
void LALI4DestroyArray ( LALStatus *, INT4Array ** ); void LALI4DestroyArray ( LALStatus *, INT4Array ** );
/*@}*/
/* INT8 vector prototypes */ /** \name INT8 array prototypes */
INT8Vector * XLALCreateINT8Vector ( UINT4 length ); /*@{*/
INT8Vector * XLALResizeINT8Vector ( INT8Vector * vector, UINT4 length );
void XLALDestroyINT8Vector ( INT8Vector * vector );
void LALI8CreateVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8ResizeVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8DestroyVector ( LALStatus *, INT8Vector ** );
/* INT8 array prototypes */
INT8Array * XLALCreateINT8ArrayL ( UINT4, ... ); INT8Array * XLALCreateINT8ArrayL ( UINT4, ... );
INT8Array * XLALCreateINT8ArrayV ( UINT4, UINT4 * ); INT8Array * XLALCreateINT8ArrayV ( UINT4, UINT4 * );
INT8Array * XLALCreateINT8Array ( UINT4Vector * ); INT8Array * XLALCreateINT8Array ( UINT4Vector * );
INT8Array * XLALResizeINT8ArrayL ( INT8Array *, UINT4, ... ); INT8Array * XLALResizeINT8ArrayL ( INT8Array *, UINT4, ... );
INT8Array * XLALResizeINT8ArrayV ( INT8Array *, UINT4, UINT4 * ); INT8Array * XLALResizeINT8ArrayV ( INT8Array *, UINT4, UINT4 * );
INT8Array * XLALResizeINT8Array ( INT8Array *, UINT4Vector * ); INT8Array * XLALResizeINT8Array ( INT8Array *, UINT4Vector * );
void XLALDestroyINT8Array ( INT8Array * ); void XLALDestroyINT8Array ( INT8Array * );
void LALI8CreateArray ( LALStatus *, INT8Array **, UINT4Vector * ); void LALI8CreateArray ( LALStatus *, INT8Array **, UINT4Vector * );
void LALI8ResizeArray ( LALStatus *, INT8Array **, UINT4Vector * ); void LALI8ResizeArray ( LALStatus *, INT8Array **, UINT4Vector * );
void LALI8DestroyArray ( LALStatus *, INT8Array ** ); void LALI8DestroyArray ( LALStatus *, INT8Array ** );
/*@}*/
/* UINT2 vector prototypes */ /** \name UINT2 array prototypes */
UINT2Vector * XLALCreateUINT2Vector ( UINT4 length ); /*@{*/
UINT2Vector * XLALResizeUINT2Vector ( UINT2Vector * vector, UINT4 length );
void XLALDestroyUINT2Vector ( UINT2Vector * vector );
void LALU2CreateVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2ResizeVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2DestroyVector ( LALStatus *, UINT2Vector ** );
/* UINT2 array prototypes */
UINT2Array * XLALCreateUINT2ArrayL ( UINT4, ... ); UINT2Array * XLALCreateUINT2ArrayL ( UINT4, ... );
UINT2Array * XLALCreateUINT2ArrayV ( UINT4, UINT4 * ); UINT2Array * XLALCreateUINT2ArrayV ( UINT4, UINT4 * );
UINT2Array * XLALCreateUINT2Array ( UINT4Vector * ); UINT2Array * XLALCreateUINT2Array ( UINT4Vector * );
UINT2Array * XLALResizeUINT2ArrayL ( UINT2Array *, UINT4, ... ); UINT2Array * XLALResizeUINT2ArrayL ( UINT2Array *, UINT4, ... );
UINT2Array * XLALResizeUINT2ArrayV ( UINT2Array *, UINT4, UINT4 * ); UINT2Array * XLALResizeUINT2ArrayV ( UINT2Array *, UINT4, UINT4 * );
UINT2Array * XLALResizeUINT2Array ( UINT2Array *, UINT4Vector * ); UINT2Array * XLALResizeUINT2Array ( UINT2Array *, UINT4Vector * );
void XLALDestroyUINT2Array ( UINT2Array * ); void XLALDestroyUINT2Array ( UINT2Array * );
void LALU2CreateArray ( LALStatus *, UINT2Array **, UINT4Vector * ); void LALU2CreateArray ( LALStatus *, UINT2Array **, UINT4Vector * );
void LALU2ResizeArray ( LALStatus *, UINT2Array **, UINT4Vector * ); void LALU2ResizeArray ( LALStatus *, UINT2Array **, UINT4Vector * );
void LALU2DestroyArray ( LALStatus *, UINT2Array ** ); void LALU2DestroyArray ( LALStatus *, UINT2Array ** );
/*@}*/
/* UINT4 vector prototypes */ /** \name UINT4 array prototypes */
UINT4Vector * XLALCreateUINT4Vector ( UINT4 length ); /*@{*/
UINT4Vector * XLALResizeUINT4Vector ( UINT4Vector * vector, UINT4 length );
void XLALDestroyUINT4Vector ( UINT4Vector * vector );
void LALU4CreateVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4ResizeVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4DestroyVector ( LALStatus *, UINT4Vector ** );
/* UINT4 array prototypes */
UINT4Array * XLALCreateUINT4ArrayL ( UINT4, ... ); UINT4Array * XLALCreateUINT4ArrayL ( UINT4, ... );
UINT4Array * XLALCreateUINT4ArrayV ( UINT4, UINT4 * ); UINT4Array * XLALCreateUINT4ArrayV ( UINT4, UINT4 * );
UINT4Array * XLALCreateUINT4Array ( UINT4Vector * ); UINT4Array * XLALCreateUINT4Array ( UINT4Vector * );
UINT4Array * XLALResizeUINT4ArrayL ( UINT4Array *, UINT4, ... ); UINT4Array * XLALResizeUINT4ArrayL ( UINT4Array *, UINT4, ... );
UINT4Array * XLALResizeUINT4ArrayV ( UINT4Array *, UINT4, UINT4 * ); UINT4Array * XLALResizeUINT4ArrayV ( UINT4Array *, UINT4, UINT4 * );
UINT4Array * XLALResizeUINT4Array ( UINT4Array *, UINT4Vector * ); UINT4Array * XLALResizeUINT4Array ( UINT4Array *, UINT4Vector * );
void XLALDestroyUINT4Array ( UINT4Array * ); void XLALDestroyUINT4Array ( UINT4Array * );
void LALU4CreateArray ( LALStatus *, UINT4Array **, UINT4Vector * ); void LALU4CreateArray ( LALStatus *, UINT4Array **, UINT4Vector * );
void LALU4ResizeArray ( LALStatus *, UINT4Array **, UINT4Vector * ); void LALU4ResizeArray ( LALStatus *, UINT4Array **, UINT4Vector * );
void LALU4DestroyArray ( LALStatus *, UINT4Array ** ); void LALU4DestroyArray ( LALStatus *, UINT4Array ** );
/*@}*/
/* UINT8 vector prototypes */ /** \name UINT8 array prototypes */
UINT8Vector * XLALCreateUINT8Vector ( UINT4 length ); /*@{*/
UINT8Vector * XLALResizeUINT8Vector ( UINT8Vector * vector, UINT4 length );
void XLALDestroyUINT8Vector ( UINT8Vector * vector );
void LALU8CreateVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8ResizeVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8DestroyVector ( LALStatus *, UINT8Vector ** );
/* UINT8 array prototypes */
UINT8Array * XLALCreateUINT8ArrayL ( UINT4, ... ); UINT8Array * XLALCreateUINT8ArrayL ( UINT4, ... );
UINT8Array * XLALCreateUINT8ArrayV ( UINT4, UINT4 * ); UINT8Array * XLALCreateUINT8ArrayV ( UINT4, UINT4 * );
UINT8Array * XLALCreateUINT8Array ( UINT4Vector * ); UINT8Array * XLALCreateUINT8Array ( UINT4Vector * );
UINT8Array * XLALResizeUINT8ArrayL ( UINT8Array *, UINT4, ... ); UINT8Array * XLALResizeUINT8ArrayL ( UINT8Array *, UINT4, ... );
UINT8Array * XLALResizeUINT8ArrayV ( UINT8Array *, UINT4, UINT4 * ); UINT8Array * XLALResizeUINT8ArrayV ( UINT8Array *, UINT4, UINT4 * );
UINT8Array * XLALResizeUINT8Array ( UINT8Array *, UINT4Vector * ); UINT8Array * XLALResizeUINT8Array ( UINT8Array *, UINT4Vector * );
void XLALDestroyUINT8Array ( UINT8Array * ); void XLALDestroyUINT8Array ( UINT8Array * );
void LALU8CreateArray ( LALStatus *, UINT8Array **, UINT4Vector * ); void LALU8CreateArray ( LALStatus *, UINT8Array **, UINT4Vector * );
void LALU8ResizeArray ( LALStatus *, UINT8Array **, UINT4Vector * ); void LALU8ResizeArray ( LALStatus *, UINT8Array **, UINT4Vector * );
void LALU8DestroyArray ( LALStatus *, UINT8Array ** ); void LALU8DestroyArray ( LALStatus *, UINT8Array ** );
/*@}*/
/* REAL4 vector prototypes */ /** \name REAL4 array prototypes */
REAL4Vector * XLALCreateREAL4Vector ( UINT4 length ); /*@{*/
REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyREAL4Vector ( REAL4Vector * vector );
void LALSCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSDestroyVector ( LALStatus *, REAL4Vector ** );
/* REAL4 array prototypes */
REAL4Array * XLALCreateREAL4ArrayL ( UINT4, ... ); REAL4Array * XLALCreateREAL4ArrayL ( UINT4, ... );
REAL4Array * XLALCreateREAL4ArrayV ( UINT4, UINT4 * ); REAL4Array * XLALCreateREAL4ArrayV ( UINT4, UINT4 * );
REAL4Array * XLALCreateREAL4Array ( UINT4Vector * ); REAL4Array * XLALCreateREAL4Array ( UINT4Vector * );
REAL4Array * XLALResizeREAL4ArrayL ( REAL4Array *, UINT4, ... ); REAL4Array * XLALResizeREAL4ArrayL ( REAL4Array *, UINT4, ... );
REAL4Array * XLALResizeREAL4ArrayV ( REAL4Array *, UINT4, UINT4 * ); REAL4Array * XLALResizeREAL4ArrayV ( REAL4Array *, UINT4, UINT4 * );
REAL4Array * XLALResizeREAL4Array ( REAL4Array *, UINT4Vector * ); REAL4Array * XLALResizeREAL4Array ( REAL4Array *, UINT4Vector * );
void XLALDestroyREAL4Array ( REAL4Array * ); void XLALDestroyREAL4Array ( REAL4Array * );
void LALSCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * ); void LALSCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALSResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * ); void LALSResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALSDestroyArray ( LALStatus *, REAL4Array ** ); void LALSDestroyArray ( LALStatus *, REAL4Array ** );
/*@}*/
/* REAL8 vector prototypes */ /** \name REAL4 array prototypes (default name) */
REAL8Vector * XLALCreateREAL8Vector ( UINT4 length ); /*@{*/
REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length ); REAL4Array * XLALCreateArrayL ( UINT4, ... );
void XLALDestroyREAL8Vector ( REAL8Vector * vector ); REAL4Array * XLALCreateArrayV ( UINT4, UINT4 * );
void LALDCreateVector ( LALStatus *, REAL8Vector **, UINT4 ); REAL4Array * XLALCreateArray ( UINT4Vector * );
void LALDResizeVector ( LALStatus *, REAL8Vector **, UINT4 ); REAL4Array * XLALResizeArrayL ( REAL4Array *, UINT4, ... );
void LALDDestroyVector ( LALStatus *, REAL8Vector ** ); REAL4Array * XLALResizeArrayV ( REAL4Array *, UINT4, UINT4 * );
REAL4Array * XLALResizeArray ( REAL4Array *, UINT4Vector * );
void XLALDestroyArray ( REAL4Array * );
void LALCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALDestroyArray ( LALStatus *, REAL4Array ** );
/*@}*/
/* REAL8 array prototypes */ /** \name REAL8 array prototypes */
/*@{*/
REAL8Array * XLALCreateREAL8ArrayL ( UINT4, ... ); REAL8Array * XLALCreateREAL8ArrayL ( UINT4, ... );
REAL8Array * XLALCreateREAL8ArrayV ( UINT4, UINT4 * ); REAL8Array * XLALCreateREAL8ArrayV ( UINT4, UINT4 * );
REAL8Array * XLALCreateREAL8Array ( UINT4Vector * ); REAL8Array * XLALCreateREAL8Array ( UINT4Vector * );
REAL8Array * XLALResizeREAL8ArrayL ( REAL8Array *, UINT4, ... ); REAL8Array * XLALResizeREAL8ArrayL ( REAL8Array *, UINT4, ... );
REAL8Array * XLALResizeREAL8ArrayV ( REAL8Array *, UINT4, UINT4 * ); REAL8Array * XLALResizeREAL8ArrayV ( REAL8Array *, UINT4, UINT4 * );
REAL8Array * XLALResizeREAL8Array ( REAL8Array *, UINT4Vector * ); REAL8Array * XLALResizeREAL8Array ( REAL8Array *, UINT4Vector * );
void XLALDestroyREAL8Array ( REAL8Array * ); void XLALDestroyREAL8Array ( REAL8Array * );
void LALDCreateArray ( LALStatus *, REAL8Array **, UINT4Vector * ); void LALDCreateArray ( LALStatus *, REAL8Array **, UINT4Vector * );
void LALDResizeArray ( LALStatus *, REAL8Array **, UINT4Vector * ); void LALDResizeArray ( LALStatus *, REAL8Array **, UINT4Vector * );
void LALDDestroyArray ( LALStatus *, REAL8Array ** ); void LALDDestroyArray ( LALStatus *, REAL8Array ** );
/*@}*/
/* COMPLEX8 vector prototypes */ /** \name COMPLEX8 array prototypes */
COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length ); /*@{*/
COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4
length );
void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector * vector );
void LALCCreateVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCResizeVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCDestroyVector ( LALStatus *, COMPLEX8Vector ** );
/* COMPLEX8 array prototypes */
COMPLEX8Array * XLALCreateCOMPLEX8ArrayL ( UINT4, ... ); COMPLEX8Array * XLALCreateCOMPLEX8ArrayL ( UINT4, ... );
COMPLEX8Array * XLALCreateCOMPLEX8ArrayV ( UINT4, UINT4 * ); COMPLEX8Array * XLALCreateCOMPLEX8ArrayV ( UINT4, UINT4 * );
COMPLEX8Array * XLALCreateCOMPLEX8Array ( UINT4Vector * ); COMPLEX8Array * XLALCreateCOMPLEX8Array ( UINT4Vector * );
COMPLEX8Array * XLALResizeCOMPLEX8ArrayL ( COMPLEX8Array *, UINT4, ... ); COMPLEX8Array * XLALResizeCOMPLEX8ArrayL ( COMPLEX8Array *, UINT4, ... );
COMPLEX8Array * XLALResizeCOMPLEX8ArrayV ( COMPLEX8Array *, UINT4, UINT4 * ); COMPLEX8Array * XLALResizeCOMPLEX8ArrayV ( COMPLEX8Array *, UINT4, UINT4 * );
COMPLEX8Array * XLALResizeCOMPLEX8Array ( COMPLEX8Array *, UINT4Vector * ); COMPLEX8Array * XLALResizeCOMPLEX8Array ( COMPLEX8Array *, UINT4Vector * );
void XLALDestroyCOMPLEX8Array ( COMPLEX8Array * ); void XLALDestroyCOMPLEX8Array ( COMPLEX8Array * );
void LALCCreateArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * ); void LALCCreateArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * );
void LALCResizeArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * ); void LALCResizeArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * );
void LALCDestroyArray ( LALStatus *, COMPLEX8Array ** ); void LALCDestroyArray ( LALStatus *, COMPLEX8Array ** );
/*@}*/
/* COMPLEX16 vector prototypes */ /** \name COMPLEX16 array prototypes */
COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length ); /*@{*/
COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UIN
T4 length );
void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector * vector );
void LALZCreateVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZResizeVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZDestroyVector ( LALStatus *, COMPLEX16Vector ** );
/* COMPLEX16 array prototypes */
COMPLEX16Array * XLALCreateCOMPLEX16ArrayL ( UINT4, ... ); COMPLEX16Array * XLALCreateCOMPLEX16ArrayL ( UINT4, ... );
COMPLEX16Array * XLALCreateCOMPLEX16ArrayV ( UINT4, UINT4 * ); COMPLEX16Array * XLALCreateCOMPLEX16ArrayV ( UINT4, UINT4 * );
COMPLEX16Array * XLALCreateCOMPLEX16Array ( UINT4Vector * ); COMPLEX16Array * XLALCreateCOMPLEX16Array ( UINT4Vector * );
COMPLEX16Array * XLALResizeCOMPLEX16ArrayL ( COMPLEX16Array *, UINT4, ... ) ; COMPLEX16Array * XLALResizeCOMPLEX16ArrayL ( COMPLEX16Array *, UINT4, ... ) ;
COMPLEX16Array * XLALResizeCOMPLEX16ArrayV ( COMPLEX16Array *, UINT4, UINT4 * ); COMPLEX16Array * XLALResizeCOMPLEX16ArrayV ( COMPLEX16Array *, UINT4, UINT4 * );
COMPLEX16Array * XLALResizeCOMPLEX16Array ( COMPLEX16Array *, UINT4Vector * ); COMPLEX16Array * XLALResizeCOMPLEX16Array ( COMPLEX16Array *, UINT4Vector * );
void XLALDestroyCOMPLEX16Array ( COMPLEX16Array * ); void XLALDestroyCOMPLEX16Array ( COMPLEX16Array * );
void LALZCreateArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * ); void LALZCreateArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * );
void LALZResizeArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * ); void LALZResizeArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * );
void LALZDestroyArray ( LALStatus *, COMPLEX16Array ** ); void LALZDestroyArray ( LALStatus *, COMPLEX16Array ** );
/*@}*/
/* REAL4 vector prototypes */ /*@}*/
/* ---------- end: ArrayFactories_c ---------- */
/** \defgroup VectorFactories_c Module VectorFactories.c
\ingroup AVFactories_h
\brief Create/destroy \<datatype\>%Vector objects.
\heading{Description}
The \c CreateVector family of functions create a \<datatype\>%Vector of the
appropriate dimensions.
The \c ResizeVector family of functions changes the amount of storage alloc
ated by the \c CreateVector functions.
The \c DestroyVector family of functions return the storage allocated by th
e \c CreateVector functions to the system.
*/
/*@{*/
/** \name CHAR vector prototypes */
/*@{*/
CHARVector * XLALCreateCHARVector ( UINT4 length );
CHARVector * XLALResizeCHARVector ( CHARVector * vector, UINT4 length );
void XLALDestroyCHARVector ( CHARVector * vector );
void LALCHARCreateVector ( LALStatus *, CHARVector **, UINT4 );
void LALCHARResizeVector ( LALStatus *, CHARVector **, UINT4 );
void LALCHARDestroyVector ( LALStatus *, CHARVector ** );
/*@}*/
/** \name INT2 vector prototypes */
/*@{*/
INT2Vector * XLALCreateINT2Vector ( UINT4 length );
INT2Vector * XLALResizeINT2Vector ( INT2Vector * vector, UINT4 length );
void XLALDestroyINT2Vector ( INT2Vector * vector );
void LALI2CreateVector ( LALStatus *, INT2Vector **, UINT4 );
void LALI2ResizeVector ( LALStatus *, INT2Vector **, UINT4 );
void LALI2DestroyVector ( LALStatus *, INT2Vector ** );
/*@}*/
/** \name INT4 vector prototypes */
/*@{*/
INT4Vector * XLALCreateINT4Vector ( UINT4 length );
INT4Vector * XLALResizeINT4Vector ( INT4Vector * vector, UINT4 length );
void XLALDestroyINT4Vector ( INT4Vector * vector );
void LALI4CreateVector ( LALStatus *, INT4Vector **, UINT4 );
void LALI4ResizeVector ( LALStatus *, INT4Vector **, UINT4 );
void LALI4DestroyVector ( LALStatus *, INT4Vector ** );
/*@}*/
/** \name INT8 vector prototypes */
/*@{*/
INT8Vector * XLALCreateINT8Vector ( UINT4 length );
INT8Vector * XLALResizeINT8Vector ( INT8Vector * vector, UINT4 length );
void XLALDestroyINT8Vector ( INT8Vector * vector );
void LALI8CreateVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8ResizeVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8DestroyVector ( LALStatus *, INT8Vector ** );
/*@}*/
/** \name UINT2 vector prototypes */
/*@{*/
UINT2Vector * XLALCreateUINT2Vector ( UINT4 length );
UINT2Vector * XLALResizeUINT2Vector ( UINT2Vector * vector, UINT4 length );
void XLALDestroyUINT2Vector ( UINT2Vector * vector );
void LALU2CreateVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2ResizeVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2DestroyVector ( LALStatus *, UINT2Vector ** );
/*@}*/
/** \name UINT4 vector prototypes */
/*@{*/
UINT4Vector * XLALCreateUINT4Vector ( UINT4 length );
UINT4Vector * XLALResizeUINT4Vector ( UINT4Vector * vector, UINT4 length );
void XLALDestroyUINT4Vector ( UINT4Vector * vector );
void LALU4CreateVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4ResizeVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4DestroyVector ( LALStatus *, UINT4Vector ** );
/*@}*/
/** \name UINT8 vector prototypes */
/*@{*/
UINT8Vector * XLALCreateUINT8Vector ( UINT4 length );
UINT8Vector * XLALResizeUINT8Vector ( UINT8Vector * vector, UINT4 length );
void XLALDestroyUINT8Vector ( UINT8Vector * vector );
void LALU8CreateVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8ResizeVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8DestroyVector ( LALStatus *, UINT8Vector ** );
/*@}*/
/** \name REAL4 vector prototypes */
/*@{*/
REAL4Vector * XLALCreateREAL4Vector ( UINT4 length );
REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyREAL4Vector ( REAL4Vector * vector );
void LALSCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSDestroyVector ( LALStatus *, REAL4Vector ** );
/*@}*/
/** \name REAL4 vector prototypes (default name) */
/*@{*/
REAL4Vector * XLALCreateVector ( UINT4 length ); REAL4Vector * XLALCreateVector ( UINT4 length );
REAL4Vector * XLALResizeVector ( REAL4Vector * vector, UINT4 length ); REAL4Vector * XLALResizeVector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyVector ( REAL4Vector * vector ); void XLALDestroyVector ( REAL4Vector * vector );
void LALCreateVector ( LALStatus *, REAL4Vector **, UINT4 ); void LALCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALResizeVector ( LALStatus *, REAL4Vector **, UINT4 ); void LALResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALDestroyVector ( LALStatus *, REAL4Vector ** ); void LALDestroyVector ( LALStatus *, REAL4Vector ** );
/*@}*/
/* REAL4 array prototypes */ /** \name REAL8 vector prototypes */
REAL4Array * XLALCreateArrayL ( UINT4, ... ); /*@{*/
REAL4Array * XLALCreateArrayV ( UINT4, UINT4 * ); REAL8Vector * XLALCreateREAL8Vector ( UINT4 length );
REAL4Array * XLALCreateArray ( UINT4Vector * ); REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length );
REAL4Array * XLALResizeArrayL ( REAL4Array *, UINT4, ... ); void XLALDestroyREAL8Vector ( REAL8Vector * vector );
REAL4Array * XLALResizeArrayV ( REAL4Array *, UINT4, UINT4 * ); void LALDCreateVector ( LALStatus *, REAL8Vector **, UINT4 );
REAL4Array * XLALResizeArray ( REAL4Array *, UINT4Vector * ); void LALDResizeVector ( LALStatus *, REAL8Vector **, UINT4 );
void XLALDestroyArray ( REAL4Array * ); void LALDDestroyVector ( LALStatus *, REAL8Vector ** );
void LALCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * ); /*@}*/
void LALResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALDestroyArray ( LALStatus *, REAL4Array ** ); /** \name COMPLEX8 vector prototypes */
/*@{*/
COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length );
COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4
length );
void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector * vector );
void LALCCreateVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCResizeVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCDestroyVector ( LALStatus *, COMPLEX8Vector ** );
/*@}*/
/** \name COMPLEX16 vector prototypes */
/*@{*/
COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length );
COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UIN
T4 length );
void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector * vector );
void LALZCreateVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZResizeVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZDestroyVector ( LALStatus *, COMPLEX16Vector ** );
/*@}*/
/*@}*/
/* ---------- end: VectorFactories_c ---------- */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _AVFACTORIES_H */ #endif /* _AVFACTORIES_H */
 End of changes. 29 change blocks. 
119 lines changed or deleted 212 lines changed or added


 BandPassTimeSeries.h   BandPassTimeSeries.h 
skipping to change at line 39 skipping to change at line 39
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
#include <lal/ZPGFilter.h> #include <lal/ZPGFilter.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /**
\author Creighton, T. D.
\addtogroup BandPassTimeSeries_h \addtogroup BandPassTimeSeries_h
\author Creighton, T. D.
\brief Provides routines to low- or high-pass filter a time series. \brief Provides routines to low- or high-pass filter a time series.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/BandPassTimeSeries.h> #include <lal/BandPassTimeSeries.h>
\endcode \endcode
This header covers routines that apply a time-domain low- or This header covers routines that apply a time-domain low- or
high-pass filter to a data series of type <tt>\<datatype\>TimeSeries</tt>. high-pass filter to a data series of type <tt>\<datatype\>TimeSeries</tt>.
 End of changes. 2 change blocks. 
1 lines changed or deleted 1 lines changed or added


 BitField.h   BitField.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**
* \author Karl Wette
* \file
* \brief Macros for manipulating integers as bit fields
*/
#ifndef _BITFIELD_H #ifndef _BITFIELD_H
#define _BITFIELD_H #define _BITFIELD_H
#include <lal/LALAtomicDatatypes.h> #include <lal/LALAtomicDatatypes.h>
/** /**
* \addtogroup BitField_h
* \author Karl Wette
* \brief Macros for manipulating integers as bit fields
*/
/*@{*/
/**
* Return a mask where the (zero-based) ith bit is set * Return a mask where the (zero-based) ith bit is set
*/ */
#define ONE_BIT(T, i) (((T)1) << (i)) #define ONE_BIT(T, i) (((T)1) << (i))
/** /**
* Return a mask where all bits from 0 to n-1 are set * Return a mask where all bits from 0 to n-1 are set
*/ */
#define ALL_BITS(T, n) ((((T)1) << (n)) - ((T)1)) #define ALL_BITS(T, n) ((((T)1) << (n)) - ((T)1))
/** /**
skipping to change at line 61 skipping to change at line 62
/** /**
* Get if all bits from 0 to n-1 of x are set * Get if all bits from 0 to n-1 of x are set
*/ */
#define GET_ALL(T, x, n) ((x & ALL_BITS(T, n)) == ALL_BITS(T, n) ? 1 : 0) #define GET_ALL(T, x, n) ((x & ALL_BITS(T, n)) == ALL_BITS(T, n) ? 1 : 0)
/** /**
* Sets all bits from 0 to n of x to the truth of v * Sets all bits from 0 to n of x to the truth of v
*/ */
#define SET_ALL(T, x, n, v) x = ((v) ? x | ALL_BITS(T, n) : x & ~ALL_BITS(T , n)) #define SET_ALL(T, x, n, v) x = ((v) ? x | ALL_BITS(T, n) : x & ~ALL_BITS(T , n))
/*@}*/
#endif #endif
 End of changes. 3 change blocks. 
6 lines changed or deleted 9 lines changed or added


 Calibration.h   Calibration.h 
skipping to change at line 37 skipping to change at line 37
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/BandPassTimeSeries.h> #include <lal/BandPassTimeSeries.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /** \addtogroup Calibration_h
* \author P. R. Brady, J. D. E. Creighton * \author P. R. Brady, J. D. E. Creighton
* \addtogroup Calibration_h * \brief Calibration API
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/Calibration.h> * #include <lal/Calibration.h>
* \endcode * \endcode
* *
*/ */
/** @{ */ /*@{*/
/**\name Error Codes */ /*@{*/ /**\name Error Codes */
/*@{*/
#define CALIBRATIONH_ENULL 001 /**< Null pointer */ #define CALIBRATIONH_ENULL 001 /**< Null pointer */
#define CALIBRATIONH_ESIZE 002 /**< Invalid size */ #define CALIBRATIONH_ESIZE 002 /**< Invalid size */
#define CALIBRATIONH_ESZMM 004 /**< Size mismatch */ #define CALIBRATIONH_ESZMM 004 /**< Size mismatch */
#define CALIBRATIONH_EZERO 010 /**< Zero factor */ #define CALIBRATIONH_EZERO 010 /**< Zero factor */
#define CALIBRATIONH_ETIME 020 /**< Time out of range */ #define CALIBRATIONH_ETIME 020 /**< Time out of range */
#define CALIBRATIONH_EUNIT 040 /**< Incompatible units */ #define CALIBRATIONH_EUNIT 040 /**< Incompatible units */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define CALIBRATIONH_MSGENULL "Null pointer" #define CALIBRATIONH_MSGENULL "Null pointer"
skipping to change at line 237 skipping to change at line 238
struct tagMyIIRFilter { struct tagMyIIRFilter {
SWIGLAL_STRUCT(MyIIRFilter); SWIGLAL_STRUCT(MyIIRFilter);
INT4 yOrder; INT4 yOrder;
INT4 xOrder; INT4 xOrder;
REAL8 a[20]; REAL8 a[20];
REAL8 b[20]; REAL8 b[20];
REAL8 yhist[20]; REAL8 yhist[20];
REAL8 xhist[20]; REAL8 xhist[20];
} MyIIRFilter; } MyIIRFilter;
/** @} */ /*@}*/
/* ----- Prototypes ----- */ /* ----- Prototypes ----- */
void LALComputeTransfer( LALStatus *status, CalibrationRecord *calrec ); void LALComputeTransfer( LALStatus *status, CalibrationRecord *calrec );
void void
LALUpdateCalibration( LALUpdateCalibration(
LALStatus *status, LALStatus *status,
CalibrationFunctions *output, CalibrationFunctions *output,
CalibrationFunctions *input, CalibrationFunctions *input,
 End of changes. 5 change blocks. 
5 lines changed or deleted 6 lines changed or added


 CoarseGrainFrequencySeries.h   CoarseGrainFrequencySeries.h 
skipping to change at line 189 skipping to change at line 189
(The special case \f$f_0=f'_0=0\f$ is an (The special case \f$f_0=f'_0=0\f$ is an
exception to the condition on the minimum frequency.)</li> exception to the condition on the minimum frequency.)</li>
<li> The routines return an error if either minimum frequency <li> The routines return an error if either minimum frequency
(\f$f_{\scriptstyle\textrm{min}}\f$ or \f$f'_{\scriptstyle\textrm{min}}\f $) is (\f$f_{\scriptstyle\textrm{min}}\f$ or \f$f'_{\scriptstyle\textrm{min}}\f $) is
negative (unless \f$f_0=0\f$ or \f$f'_0=0\f$, respectively).</li> negative (unless \f$f_0=0\f$ or \f$f'_0=0\f$, respectively).</li>
</ul> </ul>
*/ */
/*@{*/ /*@{*/
/**\name Error Codes */ /*@{*/ /**\name Error Codes */
/*@{*/
#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1 /**< Null po inter */ #define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1 /**< Null po inter */
#define COARSEGRAINFREQUENCYSERIESH_ESAMEPTR 2 /**< Input a nd Output pointers the same */ #define COARSEGRAINFREQUENCYSERIESH_ESAMEPTR 2 /**< Input a nd Output pointers the same */
#define COARSEGRAINFREQUENCYSERIESH_EZEROLEN 3 /**< Zero le ngth for data member of series */ #define COARSEGRAINFREQUENCYSERIESH_EZEROLEN 3 /**< Zero le ngth for data member of series */
#define COARSEGRAINFREQUENCYSERIESH_ENONPOSDELTAF 4 /**< Negativ e or zero frequency spacing */ #define COARSEGRAINFREQUENCYSERIESH_ENONPOSDELTAF 4 /**< Negativ e or zero frequency spacing */
#define COARSEGRAINFREQUENCYSERIESH_ENEGFMIN 5 /**< Negativ e start frequency */ #define COARSEGRAINFREQUENCYSERIESH_ENEGFMIN 5 /**< Negativ e start frequency */
#define COARSEGRAINFREQUENCYSERIESH_EMMHETERO 7 /**< Mismatc h in heterodyning frequencies */ #define COARSEGRAINFREQUENCYSERIESH_EMMHETERO 7 /**< Mismatc h in heterodyning frequencies */
#define COARSEGRAINFREQUENCYSERIESH_EMMFMIN 8 /**< Mismatc h in start frequencies */ #define COARSEGRAINFREQUENCYSERIESH_EMMFMIN 8 /**< Mismatc h in start frequencies */
#define COARSEGRAINFREQUENCYSERIESH_EMMDELTAF 9 /**< Mismatc h in frequency spacings */ #define COARSEGRAINFREQUENCYSERIESH_EMMDELTAF 9 /**< Mismatc h in frequency spacings */
#define COARSEGRAINFREQUENCYSERIESH_EMMLEN 10 /**< Mismatc h in sequence lengths */ #define COARSEGRAINFREQUENCYSERIESH_EMMLEN 10 /**< Mismatc h in sequence lengths */
#define COARSEGRAINFREQUENCYSERIESH_EOORCOARSE 16 /**< Coarse- graining paramaters out of range */ #define COARSEGRAINFREQUENCYSERIESH_EOORCOARSE 16 /**< Coarse- graining paramaters out of range */
 End of changes. 1 change blocks. 
1 lines changed or deleted 2 lines changed or added


 ComplexFFT.h   ComplexFFT.h 
skipping to change at line 57 skipping to change at line 57
* \code * \code
* #include <lal/ComplexFFT.h> * #include <lal/ComplexFFT.h>
* \endcode * \endcode
* *
* Perform complex-to-complex fast Fourier transforms of vectors using the * Perform complex-to-complex fast Fourier transforms of vectors using the
* package FFTW [\ref fj_1998]. * package FFTW [\ref fj_1998].
* *
*/ */
/*@{*/ /*@{*/
/** \name Error Codes */ /*@{*/ /** \name Error Codes */
/*@{*/
#define COMPLEXFFTH_ENULL 1 /**< Null pointer */ #define COMPLEXFFTH_ENULL 1 /**< Null pointer */
#define COMPLEXFFTH_ENNUL 2 /**< Non-null pointer */ #define COMPLEXFFTH_ENNUL 2 /**< Non-null pointer */
#define COMPLEXFFTH_ESIZE 4 /**< Invalid input size */ #define COMPLEXFFTH_ESIZE 4 /**< Invalid input size */
#define COMPLEXFFTH_ESZMM 8 /**< Size mismatch */ #define COMPLEXFFTH_ESZMM 8 /**< Size mismatch */
#define COMPLEXFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */ #define COMPLEXFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */
#define COMPLEXFFTH_ESAME 32 /**< Input/Output data vectors are the same */ #define COMPLEXFFTH_ESAME 32 /**< Input/Output data vectors are the same */
#define COMPLEXFFTH_EALOC 64 /**< Memory allocation failed */ #define COMPLEXFFTH_EALOC 64 /**< Memory allocation failed */
#define COMPLEXFFTH_EFFTW 128 /**< Error in FFTW */ #define COMPLEXFFTH_EFFTW 128 /**< Error in FFTW */
#define COMPLEXFFTH_ESNGL 256 /**< FFTW library is not single-precision */ #define COMPLEXFFTH_ESNGL 256 /**< FFTW library is not single-precision */
#define COMPLEXFFTH_EINTL 512 /**< Error in Intel FFT library */ #define COMPLEXFFTH_EINTL 512 /**< Error in Intel FFT library */
skipping to change at line 464 skipping to change at line 465
* @deprecated Use XLALCOMPLEX16VectorFFT() instead. * @deprecated Use XLALCOMPLEX16VectorFFT() instead.
*/ */
void void
LALCOMPLEX16VectorFFT ( LALCOMPLEX16VectorFFT (
LALStatus *status, LALStatus *status,
COMPLEX16Vector *output, COMPLEX16Vector *output,
COMPLEX16Vector *input, COMPLEX16Vector *input,
COMPLEX16FFTPlan *plan COMPLEX16FFTPlan *plan
); );
/*@} */ /*@}*/
#undef RESTRICT #undef RESTRICT
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _COMPLEXFFT_H */ #endif /* _COMPLEXFFT_H */
 End of changes. 2 change blocks. 
2 lines changed or deleted 4 lines changed or added


 Date.h   Date.h 
skipping to change at line 21 skipping to change at line 21
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**
* \defgroup Date_h Time Conversions
* \ingroup date
* \author D.W. Chin, J.D.E. Creighton and Kipp Cannon
* \brief Provides routines for manipulating date and time information.
\heading{Synopsis}
\code
#include <lal/Date.h>
\endcode
This header covers routines for manipulating date and time
information. The various time systems are discussed in [\ref esaa1992].
*/
#ifndef _DATE_H #ifndef _DATE_H
#define _DATE_H #define _DATE_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
/* the following two preprocessor defines are to include the prototypes for /* the following two preprocessor defines are to include the prototypes for
* gmtime_r() and asctime_r() from /usr/include/time.h * gmtime_r() and asctime_r() from /usr/include/time.h
skipping to change at line 85 skipping to change at line 69
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
#define XLAL_BILLION_INT4 1000000000 #define XLAL_BILLION_INT4 1000000000
#define XLAL_BILLION_INT8 LAL_INT8_C( 1000000000 ) #define XLAL_BILLION_INT8 LAL_INT8_C( 1000000000 )
#define XLAL_BILLION_REAL8 1e9 #define XLAL_BILLION_REAL8 1e9
/** \ingroup Date_h *//*@{*/ /**
* \addtogroup Date_h
* \author D.W. Chin, J.D.E. Creighton and Kipp Cannon
* \brief Provides routines for manipulating date and time information.
\heading{Synopsis}
\code
#include <lal/Date.h>
\endcode
This header covers routines for manipulating date and time
information. The various time systems are discussed in [\ref esaa1992].
*/
/*@{*/
/** The UNIX time of the GPS origin epoch. /** The UNIX time of the GPS origin epoch.
* *
* 1980 6 JAN 0h UTC is 3657 days after 1970 1 JAN 0h UTC: * 1980 6 JAN 0h UTC is 3657 days after 1970 1 JAN 0h UTC:
* 8 standard years of 365 days = 2920 days * 8 standard years of 365 days = 2920 days
* 2 leap years of 366 days = 734 days * 2 leap years of 366 days = 734 days
* 5 extra days. * 5 extra days.
* Hence 3657*86400=315964800. * Hence 3657*86400=315964800.
* *
* Note that this deliberately does not account for any leap seconds in the * Note that this deliberately does not account for any leap seconds in the
* interval. POSIX:2001 defines the relation between the UNIX time * interval. POSIX:2001 defines the relation between the UNIX time
skipping to change at line 108 skipping to change at line 107
* t = utc.tm_sec + utc.tm_min*60 + utc.tm_hour*3600 * t = utc.tm_sec + utc.tm_min*60 + utc.tm_hour*3600
* + utc.tm_yday*86400 + (utc.tm_year-70)*31536000 * + utc.tm_yday*86400 + (utc.tm_year-70)*31536000
* + ((utc.tm_year-69)/4)*86400 - ((utc.tm_year-1)/100)*86400 * + ((utc.tm_year-69)/4)*86400 - ((utc.tm_year-1)/100)*86400
* + ((utc.tm_year+299)/400)*86400; * + ((utc.tm_year+299)/400)*86400;
* \endcode * \endcode
* so if you were to set \c utc.tm_sec=utc.tm_min=utc.tm_hour=0, * so if you were to set \c utc.tm_sec=utc.tm_min=utc.tm_hour=0,
* \c utc.tm_yday=5, and \c utc.tm_year=80, then you get * \c utc.tm_yday=5, and \c utc.tm_year=80, then you get
* \c t=315964800. That is what this is. * \c t=315964800. That is what this is.
*/ */
#define XLAL_EPOCH_UNIX_GPS 315964800 #define XLAL_EPOCH_UNIX_GPS 315964800
#define XLAL_EPOCH_J2000_0_JD 2451545.0 /**< Julian Day of the J2000.0 epoc
h (2000 JAN 1 12h UTC). */ #define XLAL_EPOCH_J2000_0_JD 2451545.0 /**< Julian Day of the J2000
#define XLAL_EPOCH_J2000_0_TAI_UTC 32 /**< Leap seconds (TAI-UTC) on the J2 .0 epoch (2000 JAN 1 12h UTC). */
000.0 epoch (2000 JAN 1 12h UTC). */ #define XLAL_EPOCH_J2000_0_TAI_UTC 32 /**< Leap seconds (TAI-UTC)
#define XLAL_EPOCH_J2000_0_GPS 630763213 /**< GPS seconds of the J2000.0 ep on the J2000.0 epoch (2000 JAN 1 12h UTC). */
och (2000 JAN 1 12h UTC). */ #define XLAL_EPOCH_J2000_0_GPS 630763213 /**< GPS seconds of the J200
#define XLAL_EPOCH_GPS_JD 2444244.5 /**< Julian Day of the GPS epoch (1980 0.0 epoch (2000 JAN 1 12h UTC). */
JAN 6 0h UTC) */ #define XLAL_EPOCH_GPS_JD 2444244.5 /**< Julian Day of the GPS e
#define XLAL_EPOCH_GPS_TAI_UTC 19 /**< Leap seconds (TAI-UTC) on the GPS ep poch (1980 JAN 6 0h UTC) */
och (1980 JAN 6 0h UTC) */ #define XLAL_EPOCH_GPS_TAI_UTC 19 /**< Leap seconds (TAI-UTC)
#define XLAL_MJD_REF 2400000.5 /**< Reference Julian Day for Mean Julian Da on the GPS epoch (1980 JAN 6 0h UTC) */
y. */ #define XLAL_MJD_REF 2400000.5 /**< Reference Julia
n Day for Mean Julian Day. */
#define XLAL_MODIFIED_JULIEN_DAY(utc) (XLALJulianDay(utc)-XLAL_MJD_REF) /** < Modified Julian Day for specified civil time structure. */ #define XLAL_MODIFIED_JULIEN_DAY(utc) (XLALJulianDay(utc)-XLAL_MJD_REF) /** < Modified Julian Day for specified civil time structure. */
/** This structure stores pointers to a ::LALDetector and a
* ::LIGOTimeGPS. Its sole purpose is to aggregate these
* structures for passing to functions.
*/
typedef struct
tagLALPlaceAndGPS
{
SWIGLAL_STRUCT(LALPlaceAndGPS);
LALDetector *p_detector; /**< pointer to a detector */
LIGOTimeGPS *p_gps; /**< Pointer to a GPS time structure */
}
LALPlaceAndGPS;
/*@}*/ /*@}*/
/* ---------- Function prototypes : see respective source.c files for doxyg
en documentation ---------- */
/* Converts GPS time to nano seconds stored as an INT8. */ /* Converts GPS time to nano seconds stored as an INT8. */
INT8 XLALGPSToINT8NS( const LIGOTimeGPS *epoch ); INT8 XLALGPSToINT8NS( const LIGOTimeGPS *epoch );
/* Converts nano seconds stored as an INT8 to GPS time. */ /* Converts nano seconds stored as an INT8 to GPS time. */
LIGOTimeGPS * XLALINT8NSToGPS( LIGOTimeGPS *epoch, INT8 ns ); LIGOTimeGPS * XLALINT8NSToGPS( LIGOTimeGPS *epoch, INT8 ns );
/* Sets GPS time given GPS integer seconds and residual nanoseconds. */ /* Sets GPS time given GPS integer seconds and residual nanoseconds. */
LIGOTimeGPS * XLALGPSSet( LIGOTimeGPS *epoch, INT4 gpssec, INT8 gpsnan ); LIGOTimeGPS * XLALGPSSet( LIGOTimeGPS *epoch, INT4 gpssec, INT8 gpsnan );
/* Sets GPS time given GPS seconds as a REAL8. */ /* Sets GPS time given GPS seconds as a REAL8. */
skipping to change at line 151 skipping to change at line 167
/* Compares two GPS times. */ /* Compares two GPS times. */
int XLALGPSCmp( const LIGOTimeGPS *t0, const LIGOTimeGPS *t1 ); int XLALGPSCmp( const LIGOTimeGPS *t0, const LIGOTimeGPS *t1 );
/* Multiply a GPS time by a REAL8 */ /* Multiply a GPS time by a REAL8 */
LIGOTimeGPS *XLALGPSMultiply( LIGOTimeGPS *gps, REAL8 x ); LIGOTimeGPS *XLALGPSMultiply( LIGOTimeGPS *gps, REAL8 x );
/* Divide a GPS time by a REAL8 */ /* Divide a GPS time by a REAL8 */
LIGOTimeGPS *XLALGPSDivide( LIGOTimeGPS *gps, REAL8 x ); LIGOTimeGPS *XLALGPSDivide( LIGOTimeGPS *gps, REAL8 x );
/* Returns the leap seconds TAI-UTC at a given GPS second. */ /* Returns the leap seconds TAI-UTC at a given GPS second. */
int XLALLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch.*/ ); int XLALLeapSeconds( INT4 gpssec );
/* Returns the leap seconds GPS-UTC at a given GPS second. */ /* Returns the leap seconds GPS-UTC at a given GPS second. */
int XLALGPSLeapSeconds( INT4 gpssec /**< [In] Seconds relative to GPS epoch .*/ ); int XLALGPSLeapSeconds( INT4 gpssec );
/* Returns the leap seconds TAI-UTC for a given UTC broken down time. */ /* Returns the leap seconds TAI-UTC for a given UTC broken down time. */
int XLALLeapSecondsUTC( const struct tm *utc /**< [In] UTC as a broken down time.*/ ); int XLALLeapSecondsUTC( const struct tm *utc );
/* Returns the GPS seconds since the GPS epoch for a specified UTC time str ucture. */ /* Returns the GPS seconds since the GPS epoch for a specified UTC time str ucture. */
INT4 XLALUTCToGPS( const struct tm *utc /**< [In] UTC time in a broken down time structure. */ ); INT4 XLALUTCToGPS( const struct tm *utc );
/* Returns a pointer to a tm structure representing the time /* Returns a pointer to a tm structure representing the time
* specified in seconds since the GPS epoch. */ * specified in seconds since the GPS epoch. */
struct tm * XLALGPSToUTC( struct tm * XLALGPSToUTC(
struct tm *utc, /**< [Out] Pointer to tm struct where result is stored. struct tm *utc,
*/ INT4 gpssec
INT4 gpssec /**< [In] Seconds since the GPS epoch. */
); );
/* Returns the Julian Day (JD) corresponding to the date given in a broken /* Returns the Julian Day (JD) corresponding to the date given in a broken
* down time structure. */ * down time structure. */
REAL8 XLALJulianDay( const struct tm *utc /**< [In] UTC time in a broken do wn time structure. */ ); REAL8 XLALJulianDay( const struct tm *utc);
/* Returns the Modified Julian Day (MJD) corresponding to the date given in a broken down time structure.*/ /* Returns the Modified Julian Day (MJD) corresponding to the date given in a broken down time structure.*/
INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br oken down time structure. */ ); INT4 XLALModifiedJulianDay( const struct tm *utc );
/** Fill in missing fields of a C 'tm' broken-down time struct. */ /* Fill in missing fields of a C 'tm' broken-down time struct. */
int XLALFillBrokenDownTime(struct tm *tm); int XLALFillBrokenDownTime(struct tm *tm);
/* Returns the Greenwich mean or aparent sideral time in radians. */ /* Returns the Greenwich mean or aparent sideral time in radians. */
REAL8 XLALGreenwichSiderealTime( REAL8 XLALGreenwichSiderealTime(
const LIGOTimeGPS *gpstime, const LIGOTimeGPS *gpstime,
REAL8 equation_of_equinoxes REAL8 equation_of_equinoxes
); );
/* Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS time. */ /* Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS time. */
REAL8 XLALGreenwichMeanSiderealTime( REAL8 XLALGreenwichMeanSiderealTime(
skipping to change at line 203 skipping to change at line 219
LIGOTimeGPS *gps LIGOTimeGPS *gps
); );
/* Returns the GPS time for the given Greenwich sidereal time (in radians). */ /* Returns the GPS time for the given Greenwich sidereal time (in radians). */
LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS( LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS(
REAL8 gmst, REAL8 gmst,
REAL8 equation_of_equinoxes, REAL8 equation_of_equinoxes,
LIGOTimeGPS *gps LIGOTimeGPS *gps
); );
/** \ingroup Date_h
* This structure stores pointers to a ::LALDetector and a
* ::LIGOTimeGPS. Its sole purpose is to aggregate these
* structures for passing to functions.
*/
typedef struct
tagLALPlaceAndGPS
{
SWIGLAL_STRUCT(LALPlaceAndGPS);
LALDetector *p_detector; /**< pointer to a detector */
LIGOTimeGPS *p_gps; /**< Pointer to a GPS time structure */
}
LALPlaceAndGPS;
/*
* Function prototypes
*/
int XLALStrToGPS(LIGOTimeGPS *t, const char *nptr, char **endptr); int XLALStrToGPS(LIGOTimeGPS *t, const char *nptr, char **endptr);
char *XLALGPSToStr(char *, const LIGOTimeGPS *t); char *XLALGPSToStr(char *, const LIGOTimeGPS *t);
/* This function returns the current GPS time according to the system clock */ /* This function returns the current GPS time according to the system clock */
LIGOTimeGPS * LIGOTimeGPS *
XLALGPSTimeNow ( XLALGPSTimeNow (
LIGOTimeGPS *gpstime LIGOTimeGPS *gpstime
); );
int int
 End of changes. 14 change blocks. 
57 lines changed or deleted 55 lines changed or added


 DetResponse.h   DetResponse.h 
skipping to change at line 40 skipping to change at line 40
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/Date.h> #include <lal/Date.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
/** /** \addtogroup DetResponse_h
\author David Chin <dwchin@umich.edu>, Kipp Cannon <kipp@gravity.phys.uwm.e \author David Chin <dwchin@umich.edu>, Kipp Cannon <kipp@gravity.phys.u
du> wm.edu>
\addtogroup DetResponse_h
\brief Provides routines to compute gravitational wave detector response to \brief Provides routines to compute gravitational wave detector respons
polarized planar gravitational wave originating from a given source, e to
detected at a given time. polarized planar gravitational wave originating from a given source,
detected at a given time.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/DetResponse.h> #include <lal/DetResponse.h>
\endcode \endcode
\heading{Description} \heading{Description}
These routines compute the antenna beam pattern for all supported detector These routines compute the antenna beam pattern for all supported detector
skipping to change at line 69 skipping to change at line 68
vector of response for some length of time. vector of response for some length of time.
\heading{Algorithm} \heading{Algorithm}
This code is a translation of the algorithm in the Maple worksheet by This code is a translation of the algorithm in the Maple worksheet by
Anderson, <em>et al.</em> [\ref Anderson_2000]. We compute the \f$h\f$-ten sors for Anderson, <em>et al.</em> [\ref Anderson_2000]. We compute the \f$h\f$-ten sors for
\f$+\f$- and \f$\times\f$-polarized in the Earth-fixed frame, and then cont ract \f$+\f$- and \f$\times\f$-polarized in the Earth-fixed frame, and then cont ract
them (take the scalar product) with the detector response tensors as them (take the scalar product) with the detector response tensors as
described in the \ref LALDetectors_h section of the \c tools package. described in the \ref LALDetectors_h section of the \c tools package.
\ref LALDetectors_h in the \c tools package provides predefined \ref LALDetectors_h provides predefined
\c LALDetector structures representing most current detectors, \c LALDetector structures representing most current detectors,
including LIGO (Hanford and Livingston), and GEO. including LIGO (Hanford and Livingston), and GEO.
\heading{Uses}
LALGPStoGMST1()
\heading{Notes} \heading{Notes}
For examples of usage, please see the test programs in the \c test For examples of usage, please see the test programs in the \c test director
directory. y.
*/ */
/*@{*/
/** @{ */
/** \name Error Codes */ /** \name Error Codes */
/*@{*/ /*@{*/
#define DETRESPONSEH_ENULLINPUT 1 /**< Input is NULL */ #define DETRESPONSEH_ENULLINPUT 1 /**< Input is NULL */
#define DETRESPONSEH_ENULLOUTPUT 2 /**< Output is NULL */ #define DETRESPONSEH_ENULLOUTPUT 2 /**< Output is NULL */
#define DETRESPONSEH_ESRCNOTEQUATORIAL 3 /**< Source coordinates not in Equatorial system */ #define DETRESPONSEH_ESRCNOTEQUATORIAL 3 /**< Source coordinates not in Equatorial system */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define DETRESPONSEH_MSGENULLINPUT "Input is NULL" #define DETRESPONSEH_MSGENULLINPUT "Input is NULL"
skipping to change at line 220 skipping to change at line 214
REAL4TimeSeries **fcross, REAL4TimeSeries **fcross,
REAL4 D[3][3], REAL4 D[3][3],
const double ra, const double ra,
const double dec, const double dec,
const double psi, const double psi,
const LIGOTimeGPS *start, const LIGOTimeGPS *start,
const double deltaT, const double deltaT,
const int n const int n
); );
/** @} */ /*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* !defined _DETRESPONSE_H */ #endif /* !defined _DETRESPONSE_H */
 End of changes. 7 change blocks. 
16 lines changed or deleted 12 lines changed or added


 DetectorSite.h   DetectorSite.h 
skipping to change at line 37 skipping to change at line 37
#ifndef _DETECTORSITE_H #ifndef _DETECTORSITE_H
#define _DETECTORSITE_H #define _DETECTORSITE_H
#include <lal/LALDetectors.h> #include <lal/LALDetectors.h>
/* C++ protection. */ /* C++ protection. */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** Legacy code: should now use data in LALDetectors.h */ /* Legacy code: should now use data in LALDetectors.h */
enum enum
{ {
LALDetectorIndexLHODIFF = LAL_LHO_4K_DETECTOR, LALDetectorIndexLHODIFF = LAL_LHO_4K_DETECTOR,
LALDetectorIndexLLODIFF = LAL_LLO_4K_DETECTOR, LALDetectorIndexLLODIFF = LAL_LLO_4K_DETECTOR,
LALDetectorIndexVIRGODIFF = LAL_VIRGO_DETECTOR, LALDetectorIndexVIRGODIFF = LAL_VIRGO_DETECTOR,
LALDetectorIndexGEO600DIFF = LAL_GEO_600_DETECTOR, LALDetectorIndexGEO600DIFF = LAL_GEO_600_DETECTOR,
LALDetectorIndexTAMA300DIFF = LAL_TAMA_300_DETECTOR, LALDetectorIndexTAMA300DIFF = LAL_TAMA_300_DETECTOR,
LALDetectorIndexCIT40DIFF = LAL_CIT_40_DETECTOR, LALDetectorIndexCIT40DIFF = LAL_CIT_40_DETECTOR,
LALNumCachedDetectors = LAL_NUM_DETECTORS LALNumCachedDetectors = LAL_NUM_DETECTORS
}; };
 End of changes. 1 change blocks. 
1 lines changed or deleted 1 lines changed or added


 FrequencySeries.h   FrequencySeries.h 
skipping to change at line 32 skipping to change at line 32
#include <stddef.h> #include <stddef.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/* COMPLEX8 prototypes */ /**
\addtogroup FrequencySeriesManipulation
void XLALDestroyCOMPLEX8FrequencySeries ( \author Kipp Cannon <kipp@gravity.phys.uwm.edu>
COMPLEX8FrequencySeries *series
);
COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
COMPLEX8FrequencySeries *XLALCutCOMPLEX8FrequencySeries (
const COMPLEX8FrequencySeries *series,
size_t first,
size_t length
);
COMPLEX8FrequencySeries *XLALResizeCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series,
int first,
size_t length
);
COMPLEX8FrequencySeries *XLALShrinkCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series,
size_t first,
size_t length
);
COMPLEX8FrequencySeries *XLALAddCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *arg1,
const COMPLEX8FrequencySeries *arg2
);
COMPLEX8FrequencySeries *XLALConjugateCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series
);
COMPLEX8FrequencySeries *XLALMultiplyCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *arg1,
const COMPLEX8FrequencySeries *arg2
);
/* COMPLEX 16 prototypes */
void XLALDestroyCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series
);
COMPLEX16FrequencySeries *XLALCreateCOMPLEX16FrequencySeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
COMPLEX16FrequencySeries *XLALCutCOMPLEX16FrequencySeries (
const COMPLEX16FrequencySeries *series,
size_t first,
size_t length
);
COMPLEX16FrequencySeries *XLALResizeCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series,
int first,
size_t length
);
COMPLEX16FrequencySeries *XLALShrinkCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series,
size_t first,
size_t length
);
COMPLEX16FrequencySeries *XLALAddCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *arg1,
const COMPLEX16FrequencySeries *arg2
);
COMPLEX16FrequencySeries *XLALConjugateCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *series
);
COMPLEX16FrequencySeries *XLALMultiplyCOMPLEX16FrequencySeries (
COMPLEX16FrequencySeries *arg1,
const COMPLEX16FrequencySeries *arg2
);
/* REAL4 prototypes */
void XLALDestroyREAL4FrequencySeries (
REAL4FrequencySeries *series
);
REAL4FrequencySeries *XLALCreateREAL4FrequencySeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
REAL4FrequencySeries *XLALCutREAL4FrequencySeries (
const REAL4FrequencySeries *series,
size_t first,
size_t length
);
REAL4FrequencySeries *XLALResizeREAL4FrequencySeries (
REAL4FrequencySeries *series,
int first,
size_t length
);
REAL4FrequencySeries *XLALShrinkREAL4FrequencySeries (
REAL4FrequencySeries *series,
size_t first,
size_t length
);
REAL4FrequencySeries *XLALAddREAL4FrequencySeries (
REAL4FrequencySeries *arg1,
const REAL4FrequencySeries *arg2
);
REAL4FrequencySeries *XLALMultiplyREAL4FrequencySeries (
REAL4FrequencySeries *arg1,
const REAL4FrequencySeries *arg2
);
/* REAL8 prototypes */
void XLALDestroyREAL8FrequencySeries (
REAL8FrequencySeries *series
);
REAL8FrequencySeries *XLALCreateREAL8FrequencySeries ( \brief This is a suite of functions for creating, destroying, and manipulat
const CHAR *name, ing LAL
const LIGOTimeGPS *epoch, frequency series. One pair of functions (the XLAL version and its LAL
REAL8 f0, counterpart) is available for each method and frequency series type. For
REAL8 deltaF, example XLALCreateREAL4FrequencySeries() is available for creating
const LALUnit *sampleUnits, frequency series of \c REAL4 data, and the LAL-stype wrapper
size_t length LALCreateREAL4FrequencySeries() is provided which is equivalent to
); the XLAL version in all respects except that it adheres to the LAL calling
conventions (eg.\ it takes a \c LALStatus pointer as its first
argument, its return type is \c void, etc.).
REAL8FrequencySeries *XLALCutREAL8FrequencySeries ( */
const REAL8FrequencySeries *series, /*@{*/
size_t first,
size_t length
);
REAL8FrequencySeries *XLALResizeREAL8FrequencySeries ( /** \name Creation Functions
REAL8FrequencySeries *series,
int first,
size_t length
);
REAL8FrequencySeries *XLALShrinkREAL8FrequencySeries ( \heading{Synopsis}
REAL8FrequencySeries *series,
size_t first,
size_t length
);
REAL8FrequencySeries *XLALAddREAL8FrequencySeries ( \code
REAL8FrequencySeries *arg1, #include <lal/FrequencySeries.h>
const REAL8FrequencySeries *arg2
);
REAL8FrequencySeries *XLALMultiplyREAL8FrequencySeries ( XLALCreate<frequencyseriestype>()
REAL8FrequencySeries *arg1, LALCreate<frequencyseriestype>()
const REAL8FrequencySeries *arg2 \endcode
);
/* INT2 prototypes */ \heading{Description}
void XLALDestroyINT2FrequencySeries ( These functions create LAL frequency series. An XLAL function returns a
INT2FrequencySeries *series pointer to the newly created series or \c NULL on failure. The LAL
); counterpart accepts the address of a pointer which it fills with the
address of the newly created series or \c NULL on failure.
Additionally, the LAL wrapper provides standard LAL-style error checking
via a \c LALStatus pointer.
INT2FrequencySeries *XLALCreateINT2FrequencySeries ( */
const CHAR *name, /*@{*/
const LIGOTimeGPS *epoch, COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries ( const CHAR *na
REAL8 f0, me, const LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sample
REAL8 deltaF, Units, size_t length );
const LALUnit *sampleUnits, COMPLEX16FrequencySeries *XLALCreateCOMPLEX16FrequencySeries ( const CHAR *
size_t length name, const LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *samp
); leUnits, size_t length );
REAL4FrequencySeries *XLALCreateREAL4FrequencySeries ( const CHAR *name, co
nst LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits,
size_t length );
REAL8FrequencySeries *XLALCreateREAL8FrequencySeries ( const CHAR *name, co
nst LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits,
size_t length );
INT2FrequencySeries *XLALCreateINT2FrequencySeries ( const CHAR *name, cons
t LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits, s
ize_t length );
INT4FrequencySeries *XLALCreateINT4FrequencySeries ( const CHAR *name, cons
t LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits, s
ize_t length );
INT8FrequencySeries *XLALCreateINT8FrequencySeries ( const CHAR *name, cons
t LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits, s
ize_t length );
UINT2FrequencySeries *XLALCreateUINT2FrequencySeries ( const CHAR *name, co
nst LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits,
size_t length );
UINT4FrequencySeries *XLALCreateUINT4FrequencySeries ( const CHAR *name, co
nst LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits,
size_t length );
UINT8FrequencySeries *XLALCreateUINT8FrequencySeries ( const CHAR *name, co
nst LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaF, const LALUnit *sampleUnits,
size_t length );
/*@}*/
INT2FrequencySeries *XLALCutINT2FrequencySeries ( /** \name Destruction Functions
const INT2FrequencySeries *series,
size_t first,
size_t length
);
INT2FrequencySeries *XLALResizeINT2FrequencySeries ( \heading{Synopsis}
INT2FrequencySeries *series,
int first,
size_t length
);
INT2FrequencySeries *XLALShrinkINT2FrequencySeries ( \code
INT2FrequencySeries *series, #include <lal/FrequencySeries.h>
size_t first,
size_t length
);
INT2FrequencySeries *XLALAddINT2FrequencySeries ( XLALDestroy<frequencyseriestype>()
INT2FrequencySeries *arg1, LALDestroy<frequencyseriestype>()
const INT2FrequencySeries *arg2 \endcode
);
INT2FrequencySeries *XLALMultiplyINT2FrequencySeries ( \heading{Description}
INT2FrequencySeries *arg1,
const INT2FrequencySeries *arg2
);
/* INT4 prototypes */ These functions free all memory associated with a LAL frequency series. It
is safe to pass \c NULL to these functions.
void XLALDestroyINT4FrequencySeries ( */
INT4FrequencySeries *series /*@{*/
); void XLALDestroyCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *series )
;
void XLALDestroyCOMPLEX16FrequencySeries ( COMPLEX16FrequencySeries *series
);
void XLALDestroyREAL4FrequencySeries ( REAL4FrequencySeries *series );
void XLALDestroyREAL8FrequencySeries ( REAL8FrequencySeries *series );
void XLALDestroyINT2FrequencySeries ( INT2FrequencySeries *series );
void XLALDestroyINT4FrequencySeries ( INT4FrequencySeries *series );
void XLALDestroyINT8FrequencySeries ( INT8FrequencySeries *series );
void XLALDestroyUINT2FrequencySeries ( UINT2FrequencySeries *series );
void XLALDestroyUINT4FrequencySeries ( UINT4FrequencySeries *series );
void XLALDestroyUINT8FrequencySeries ( UINT8FrequencySeries *series );
/*@}*/
INT4FrequencySeries *XLALCreateINT4FrequencySeries ( /** \name Cutting Functions
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
INT4FrequencySeries *XLALCutINT4FrequencySeries ( \heading{Synopsis}
const INT4FrequencySeries *series,
size_t first,
size_t length
);
INT4FrequencySeries *XLALResizeINT4FrequencySeries ( \code
INT4FrequencySeries *series, #include <lal/FrequencySeries.h>
int first,
size_t length
);
INT4FrequencySeries *XLALShrinkINT4FrequencySeries ( XLALCut<frequencyseriestype>()
INT4FrequencySeries *series, \endcode
size_t first,
size_t length
);
INT4FrequencySeries *XLALAddINT4FrequencySeries ( \heading{Description}
INT4FrequencySeries *arg1,
const INT4FrequencySeries *arg2
);
INT4FrequencySeries *XLALMultiplyINT4FrequencySeries ( These functions create a new frequency series by extracting a section of an
INT4FrequencySeries *arg1, existing frequency series.
const INT4FrequencySeries *arg2
);
/* INT8 prototypes */ */
/*@{*/
COMPLEX8FrequencySeries *XLALCutCOMPLEX8FrequencySeries ( const COMPLEX8Fre
quencySeries *series, size_t first, size_t length );
COMPLEX16FrequencySeries *XLALCutCOMPLEX16FrequencySeries ( const COMPLEX16
FrequencySeries *series, size_t first, size_t length );
REAL4FrequencySeries *XLALCutREAL4FrequencySeries ( const REAL4FrequencySer
ies *series, size_t first, size_t length );
REAL8FrequencySeries *XLALCutREAL8FrequencySeries ( const REAL8FrequencySer
ies *series, size_t first, size_t length );
INT2FrequencySeries *XLALCutINT2FrequencySeries ( const INT2FrequencySeries
*series, size_t first, size_t length );
INT4FrequencySeries *XLALCutINT4FrequencySeries ( const INT4FrequencySeries
*series, size_t first, size_t length );
INT8FrequencySeries *XLALCutINT8FrequencySeries ( const INT8FrequencySeries
*series, size_t first, size_t length );
UINT2FrequencySeries *XLALCutUINT2FrequencySeries ( const UINT2FrequencySer
ies *series, size_t first, size_t length );
UINT4FrequencySeries *XLALCutUINT4FrequencySeries ( const UINT4FrequencySer
ies *series, size_t first, size_t length );
UINT8FrequencySeries *XLALCutUINT8FrequencySeries ( const UINT8FrequencySer
ies *series, size_t first, size_t length );
/*@}*/
void XLALDestroyINT8FrequencySeries ( /** \name Resizing Functions
INT8FrequencySeries *series
);
INT8FrequencySeries *XLALCreateINT8FrequencySeries ( \heading{Synopsis}
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
INT8FrequencySeries *XLALCutINT8FrequencySeries ( \code
const INT8FrequencySeries *series, #include <lal/FrequencySeries.h>
size_t first,
size_t length
);
INT8FrequencySeries *XLALResizeINT8FrequencySeries ( XLALResize<frequencyseriestype>()
INT8FrequencySeries *series, XLALShrink<frequencyseriestype>()
int first, LALShrink<frequencyseriestype>()
size_t length \endcode
);
INT8FrequencySeries *XLALShrinkINT8FrequencySeries ( \heading{Description}
INT8FrequencySeries *series,
size_t first,
size_t length
);
INT8FrequencySeries *XLALAddINT8FrequencySeries ( These functions resize an existing frequency series. The new frequency
INT8FrequencySeries *arg1, series will have the given length, and its contents will consist of that
const INT8FrequencySeries *arg2 part of the original time series that started at sample \c first. If
); \c first is negative, then the new time series is padded at the start
by that many samples. The frequency series' heterodyne frequency,
(f_{0}), is adjusted appropriately.
INT8FrequencySeries *XLALMultiplyINT8FrequencySeries ( The "Shrink" functions accept non-negative values for the parameter
INT8FrequencySeries *arg1, \c first, and are retained only for historical purposes. New code
const INT8FrequencySeries *arg2 should use the "Resize" variants.
);
/* UINT2 prototypes */ */
/*@{*/
COMPLEX8FrequencySeries *XLALResizeCOMPLEX8FrequencySeries ( COMPLEX8Freque
ncySeries *series, int first, size_t length );
COMPLEX16FrequencySeries *XLALResizeCOMPLEX16FrequencySeries ( COMPLEX16Fre
quencySeries *series, int first, size_t length );
REAL4FrequencySeries *XLALResizeREAL4FrequencySeries ( REAL4FrequencySeries
*series, int first, size_t length );
REAL8FrequencySeries *XLALResizeREAL8FrequencySeries ( REAL8FrequencySeries
*series, int first, size_t length );
INT2FrequencySeries *XLALResizeINT2FrequencySeries ( INT2FrequencySeries *s
eries, int first, size_t length );
INT4FrequencySeries *XLALResizeINT4FrequencySeries ( INT4FrequencySeries *s
eries, int first, size_t length );
INT8FrequencySeries *XLALResizeINT8FrequencySeries ( INT8FrequencySeries *s
eries, int first, size_t length );
UINT2FrequencySeries *XLALResizeUINT2FrequencySeries ( UINT2FrequencySeries
*series, int first, size_t length );
UINT4FrequencySeries *XLALResizeUINT4FrequencySeries ( UINT4FrequencySeries
*series, int first, size_t length );
UINT8FrequencySeries *XLALResizeUINT8FrequencySeries ( UINT8FrequencySeries
*series, int first, size_t length );
void XLALDestroyUINT2FrequencySeries ( COMPLEX8FrequencySeries *XLALShrinkCOMPLEX8FrequencySeries ( COMPLEX8Freque
UINT2FrequencySeries *series ncySeries *series, size_t first, size_t length );
); COMPLEX16FrequencySeries *XLALShrinkCOMPLEX16FrequencySeries ( COMPLEX16Fre
quencySeries *series, size_t first, size_t length );
REAL4FrequencySeries *XLALShrinkREAL4FrequencySeries ( REAL4FrequencySeries
*series, size_t first, size_t length );
REAL8FrequencySeries *XLALShrinkREAL8FrequencySeries ( REAL8FrequencySeries
*series, size_t first, size_t length );
INT2FrequencySeries *XLALShrinkINT2FrequencySeries ( INT2FrequencySeries *s
eries, size_t first, size_t length );
INT4FrequencySeries *XLALShrinkINT4FrequencySeries ( INT4FrequencySeries *s
eries, size_t first, size_t length );
INT8FrequencySeries *XLALShrinkINT8FrequencySeries ( INT8FrequencySeries *s
eries, size_t first, size_t length );
UINT2FrequencySeries *XLALShrinkUINT2FrequencySeries ( UINT2FrequencySeries
*series, size_t first, size_t length );
UINT4FrequencySeries *XLALShrinkUINT4FrequencySeries ( UINT4FrequencySeries
*series, size_t first, size_t length );
UINT8FrequencySeries *XLALShrinkUINT8FrequencySeries ( UINT8FrequencySeries
*series, size_t first, size_t length );
/*@}*/
UINT2FrequencySeries *XLALCreateUINT2FrequencySeries ( /** \name Addition Functions
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
UINT2FrequencySeries *XLALCutUINT2FrequencySeries ( \heading{Synopsis}
const UINT2FrequencySeries *series,
size_t first,
size_t length
);
UINT2FrequencySeries *XLALResizeUINT2FrequencySeries ( \code
UINT2FrequencySeries *series, #include <lal/FrequencySeries.h>
int first,
size_t length
);
UINT2FrequencySeries *XLALShrinkUINT2FrequencySeries ( XLALAdd<frequencyseriestype>()
UINT2FrequencySeries *series, \endcode
size_t first,
size_t length
);
UINT2FrequencySeries *XLALAddUINT2FrequencySeries ( \heading{Description}
UINT2FrequencySeries *arg1,
const UINT2FrequencySeries *arg2
);
UINT2FrequencySeries *XLALMultiplyUINT2FrequencySeries ( These functions add the second argument to the first argument, returning a
UINT2FrequencySeries *arg1, pointer to the first argument on success or NULL on failure. The two
const UINT2FrequencySeries *arg2 series must have the same epoch and frequency resolution, and have units
); that differ only by a dimensionless factor.
/* UINT4 prototypes */ */
/*@{*/
COMPLEX8FrequencySeries *XLALAddCOMPLEX8FrequencySeries ( COMPLEX8Frequency
Series *arg1, const COMPLEX8FrequencySeries *arg2 );
COMPLEX16FrequencySeries *XLALAddCOMPLEX16FrequencySeries ( COMPLEX16Freque
ncySeries *arg1, const COMPLEX16FrequencySeries *arg2 );
REAL4FrequencySeries *XLALAddREAL4FrequencySeries ( REAL4FrequencySeries *a
rg1, const REAL4FrequencySeries *arg2 );
REAL8FrequencySeries *XLALAddREAL8FrequencySeries ( REAL8FrequencySeries *a
rg1, const REAL8FrequencySeries *arg2 );
INT2FrequencySeries *XLALAddINT2FrequencySeries ( INT2FrequencySeries *arg1
, const INT2FrequencySeries *arg2 );
INT4FrequencySeries *XLALAddINT4FrequencySeries ( INT4FrequencySeries *arg1
, const INT4FrequencySeries *arg2 );
INT8FrequencySeries *XLALAddINT8FrequencySeries ( INT8FrequencySeries *arg1
, const INT8FrequencySeries *arg2 );
UINT2FrequencySeries *XLALAddUINT2FrequencySeries ( UINT2FrequencySeries *a
rg1, const UINT2FrequencySeries *arg2 );
UINT4FrequencySeries *XLALAddUINT4FrequencySeries ( UINT4FrequencySeries *a
rg1, const UINT4FrequencySeries *arg2 );
UINT8FrequencySeries *XLALAddUINT8FrequencySeries ( UINT8FrequencySeries *a
rg1, const UINT8FrequencySeries *arg2 );
/*@}*/
void XLALDestroyUINT4FrequencySeries ( /** \name Conjugation Functions
UINT4FrequencySeries *series
);
UINT4FrequencySeries *XLALCreateUINT4FrequencySeries ( \heading{Synopsis}
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
UINT4FrequencySeries *XLALCutUINT4FrequencySeries ( \code
const UINT4FrequencySeries *series, #include <lal/FrequencySeries.h>
size_t first,
size_t length
);
UINT4FrequencySeries *XLALResizeUINT4FrequencySeries ( XLALConjugate<frequencyseriestype>()
UINT4FrequencySeries *series, \endcode
int first,
size_t length
);
UINT4FrequencySeries *XLALShrinkUINT4FrequencySeries ( \heading{Description}
UINT4FrequencySeries *series,
size_t first,
size_t length
);
UINT4FrequencySeries *XLALAddUINT4FrequencySeries ( These functions replace a frequency series with its complex conjugate.
UINT4FrequencySeries *arg1,
const UINT4FrequencySeries *arg2
);
UINT4FrequencySeries *XLALMultiplyUINT4FrequencySeries ( */
UINT4FrequencySeries *arg1, /*@{*/
const UINT4FrequencySeries *arg2 COMPLEX8FrequencySeries *XLALConjugateCOMPLEX8FrequencySeries ( COMPLEX8Fre
); quencySeries *series );
COMPLEX16FrequencySeries *XLALConjugateCOMPLEX16FrequencySeries ( COMPLEX16
FrequencySeries *series );
/*@}*/
/* UINT8 prototypes */ /** \name Multiplication Functions
void XLALDestroyUINT8FrequencySeries ( \heading{Synopsis}
UINT8FrequencySeries *series
);
UINT8FrequencySeries *XLALCreateUINT8FrequencySeries ( \code
const CHAR *name, #include <lal/FrequencySeries.h>
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaF,
const LALUnit *sampleUnits,
size_t length
);
UINT8FrequencySeries *XLALCutUINT8FrequencySeries ( XLALMultiply<frequencyseriestype>()
const UINT8FrequencySeries *series, \endcode
size_t first,
size_t length
);
UINT8FrequencySeries *XLALResizeUINT8FrequencySeries ( \heading{Description}
UINT8FrequencySeries *series,
int first,
size_t length
);
UINT8FrequencySeries *XLALShrinkUINT8FrequencySeries ( These functions multiply the first argument by the second argument,
UINT8FrequencySeries *series, returning a pointer to the first argument on success or NULL on failure.
size_t first, The two series must have the same epoch and frequency resolution, and have
size_t length units that differ only by a dimensionless factor.
);
UINT8FrequencySeries *XLALAddUINT8FrequencySeries ( */
UINT8FrequencySeries *arg1, /*@{*/
const UINT8FrequencySeries *arg2 COMPLEX8FrequencySeries *XLALMultiplyCOMPLEX8FrequencySeries ( COMPLEX8Freq
); uencySeries *arg1, const COMPLEX8FrequencySeries *arg2 );
COMPLEX16FrequencySeries *XLALMultiplyCOMPLEX16FrequencySeries ( COMPLEX16F
requencySeries *arg1, const COMPLEX16FrequencySeries *arg2 );
REAL4FrequencySeries *XLALMultiplyREAL4FrequencySeries ( REAL4FrequencySeri
es *arg1, const REAL4FrequencySeries *arg2 );
REAL8FrequencySeries *XLALMultiplyREAL8FrequencySeries ( REAL8FrequencySeri
es *arg1, const REAL8FrequencySeries *arg2 );
INT2FrequencySeries *XLALMultiplyINT2FrequencySeries ( INT2FrequencySeries
*arg1, const INT2FrequencySeries *arg2 );
INT4FrequencySeries *XLALMultiplyINT4FrequencySeries ( INT4FrequencySeries
*arg1, const INT4FrequencySeries *arg2 );
INT8FrequencySeries *XLALMultiplyINT8FrequencySeries ( INT8FrequencySeries
*arg1, const INT8FrequencySeries *arg2 );
UINT2FrequencySeries *XLALMultiplyUINT2FrequencySeries ( UINT2FrequencySeri
es *arg1, const UINT2FrequencySeries *arg2 );
UINT4FrequencySeries *XLALMultiplyUINT4FrequencySeries ( UINT4FrequencySeri
es *arg1, const UINT4FrequencySeries *arg2 );
UINT8FrequencySeries *XLALMultiplyUINT8FrequencySeries ( UINT8FrequencySeri
es *arg1, const UINT8FrequencySeries *arg2 );
/*@}*/
UINT8FrequencySeries *XLALMultiplyUINT8FrequencySeries ( /*@}*/
UINT8FrequencySeries *arg1,
const UINT8FrequencySeries *arg2
);
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _FREQUENCYSERIES_H */ #endif /* _FREQUENCYSERIES_H */
 End of changes. 55 change blocks. 
383 lines changed or deleted 264 lines changed or added


 GSLSupport.h   GSLSupport.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**
* \author Karl Wette
* \file
* \brief Support routines for GSL
*/
#ifndef _GSLSUPPORT_H #ifndef _GSLSUPPORT_H
#define _GSLSUPPORT_H #define _GSLSUPPORT_H
#include <gsl/gsl_vector.h> #include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h> #include <gsl/gsl_matrix.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
* \addtogroup GSLSupport_h
* \author Karl Wette
* \brief Support routines for GSL
*/
/*@{*/
/*
* Functions * Functions
*/ */
gsl_vector *XLALGSLVectorFromVAList(INT4, REAL8, ...); gsl_vector *XLALGSLVectorFromVAList(INT4, REAL8, ...);
gsl_vector *XLALGSLVectorFromLALStringVector(LALStringVector*); gsl_vector *XLALGSLVectorFromLALStringVector(LALStringVector*);
gsl_matrix *XLALResizeGSLMatrix(gsl_matrix*, size_t, size_t, double); gsl_matrix *XLALResizeGSLMatrix(gsl_matrix*, size_t, size_t, double);
gsl_vector *XLALResizeGSLVector(gsl_vector*, size_t, double); gsl_vector *XLALResizeGSLVector(gsl_vector*, size_t, double);
gsl_vector_int *XLALResizeGSLVectorInt(gsl_vector_int*, size_t, int); gsl_vector_int *XLALResizeGSLVectorInt(gsl_vector_int*, size_t, int);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif
/** /*
* Macros * Macros
*/ */
/* Allocate, print, and free 1D things */ /** \name Allocate, print, and free 1D things */
/*@{*/
#define ALLOC_GSL_1D(type, var, n, errval) \ #define ALLOC_GSL_1D(type, var, n, errval) \
if ((var = gsl_ ## type ## _alloc(n)) == NULL) { \ if ((var = gsl_ ## type ## _alloc(n)) == NULL) { \
XLALPrintError("%s: Could not allocate '%s'", __func__, #var); \ XLALPrintError("%s: Could not allocate '%s'", __func__, #var); \
XLAL_ERROR_VAL(errval, XLAL_ENOMEM); \ XLAL_ERROR_VAL(errval, XLAL_ENOMEM); \
} }
#define PRINT_GSL_1D(type, var, format) \ #define PRINT_GSL_1D(type, var, format) \
{ \ { \
size_t GSLSUPPORT_i; \ size_t GSLSUPPORT_i; \
printf("%s: ", #var); \ printf("%s: ", #var); \
if (var) \ if (var) \
for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size; ++GSLSUPPORT_i) \ for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size; ++GSLSUPPORT_i) \
printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i)); \ printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i)); \
else \ else \
printf("NULL"); \ printf("NULL"); \
printf("\n"); \ printf("\n"); \
} }
#define FREE_GSL_1D(type, var) \ #define FREE_GSL_1D(type, var) \
if (var != NULL) \ if (var != NULL) \
gsl_ ## type ## _free(var); gsl_ ## type ## _free(var);
/*@}*/
/* Allocate, print, and free 2D things */ /** \name Allocate, print, and free 2D things */
/*@{*/
#define ALLOC_GSL_2D(type, var, m, n, errval) \ #define ALLOC_GSL_2D(type, var, m, n, errval) \
if ((var = gsl_ ## type ## _alloc(m, n)) == NULL) { \ if ((var = gsl_ ## type ## _alloc(m, n)) == NULL) { \
XLALPrintError("%s: Could not allocate '%s'", __func__, #var); \ XLALPrintError("%s: Could not allocate '%s'", __func__, #var); \
XLAL_ERROR_VAL(errval, XLAL_ENOMEM); \ XLAL_ERROR_VAL(errval, XLAL_ENOMEM); \
} }
#define PRINT_GSL_2D(type, var, format) \ #define PRINT_GSL_2D(type, var, format) \
{ \ { \
size_t GSLSUPPORT_i, GSLSUPPORT_j; \ size_t GSLSUPPORT_i, GSLSUPPORT_j; \
printf("%s:\n", #var); \ printf("%s:\n", #var); \
if (var) \ if (var) \
skipping to change at line 101 skipping to change at line 105
printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i, GSLSUPPORT_j )); \ printf(format, gsl_ ## type ## _get(var, GSLSUPPORT_i, GSLSUPPORT_j )); \
printf("\n"); \ printf("\n"); \
} \ } \
else \ else \
printf("NULL\n"); \ printf("NULL\n"); \
} }
#define FREE_GSL_2D(type, var) \ #define FREE_GSL_2D(type, var) \
if (var != NULL) \ if (var != NULL) \
gsl_ ## type ## _free(var); gsl_ ## type ## _free(var);
/* Allocate, print, and free gsl_vector */ /*@}*/
/** \name Allocate, print, and free gsl_vector */
/*@{*/
#define ALLOC_GSL_VECTOR(var, n, errval) ALLOC_GSL_1D(vector, var, n, errva l) #define ALLOC_GSL_VECTOR(var, n, errval) ALLOC_GSL_1D(vector, var, n, errva l)
#define PRINT_GSL_VECTOR(var) PRINT_GSL_1D(vector, var, "%g ") #define PRINT_GSL_VECTOR(var) PRINT_GSL_1D(vector, var, "%g ")
#define FREE_GSL_VECTOR(var) FREE_GSL_1D(vector, var) #define FREE_GSL_VECTOR(var) FREE_GSL_1D(vector, var)
/*@}*/
/* Allocate, print, and free gsl_vector_int */ /** \name Allocate, print, and free gsl_vector_int */
/*@{*/
#define ALLOC_GSL_VECTOR_INT(var, n, errval) ALLOC_GSL_1D(vector_int, var, n, errval) #define ALLOC_GSL_VECTOR_INT(var, n, errval) ALLOC_GSL_1D(vector_int, var, n, errval)
#define PRINT_GSL_VECTOR_INT(var) PRINT_GSL_1D(vector_int, var, "%i ") #define PRINT_GSL_VECTOR_INT(var) PRINT_GSL_1D(vector_int, var, "%i ")
#define FREE_GSL_VECTOR_INT(var) FREE_GSL_1D(vector_int, var) #define FREE_GSL_VECTOR_INT(var) FREE_GSL_1D(vector_int, var)
/*@}*/
/* Allocate, print, and free gsl_matrix */ /** \name Allocate, print, and free gsl_matrix */
/*@{*/
#define ALLOC_GSL_MATRIX(var, m, n, errval) ALLOC_GSL_2D(matrix, var, m, n, errval) #define ALLOC_GSL_MATRIX(var, m, n, errval) ALLOC_GSL_2D(matrix, var, m, n, errval)
#define PRINT_GSL_MATRIX(var) PRINT_GSL_2D(matrix, var, "%g " ) #define PRINT_GSL_MATRIX(var) PRINT_GSL_2D(matrix, var, "%g " )
#define FREE_GSL_MATRIX(var) FREE_GSL_2D(matrix, var) #define FREE_GSL_MATRIX(var) FREE_GSL_2D(matrix, var)
/*@}*/
/* Allocate, print, and free gsl_matrix_int */ /** \name Allocate, print, and free gsl_matrix_int */
/*@{*/
#define ALLOC_GSL_MATRIX_INT(var, m, n, errval) ALLOC_GSL_2D(matrix_int, va r, m, n, errval) #define ALLOC_GSL_MATRIX_INT(var, m, n, errval) ALLOC_GSL_2D(matrix_int, va r, m, n, errval)
#define PRINT_GSL_MATRIX_INT(var) PRINT_GSL_2D(matrix_int, va r, "%i ") #define PRINT_GSL_MATRIX_INT(var) PRINT_GSL_2D(matrix_int, va r, "%i ")
#define FREE_GSL_MATRIX_INT(var) FREE_GSL_2D(matrix_int, var ) #define FREE_GSL_MATRIX_INT(var) FREE_GSL_2D(matrix_int, var )
/*@}*/
/* Allocate, print, and free gsl_combination */ /** \name Allocate, print, and free gsl_combination */
/*@{*/
#define ALLOC_GSL_COMBINATION(var, n, errval) ALLOC_GSL_1D(combination, var , n, errval) #define ALLOC_GSL_COMBINATION(var, n, errval) ALLOC_GSL_1D(combination, var , n, errval)
#define PRINT_GSL_COMBINATION(var) PRINT_GSL_1D(combination, var , "%i ") #define PRINT_GSL_COMBINATION(var) PRINT_GSL_1D(combination, var , "%i ")
#define FREE_GSL_COMBINATION(var) FREE_GSL_1D(combination, var) #define FREE_GSL_COMBINATION(var) FREE_GSL_1D(combination, var)
/*@}*/
/* Allocate, print, and free gsl_permutation */ /** \name Allocate, print, and free gsl_permutation */
/*@{*/
#define ALLOC_GSL_PERMUTATION(var, n, errval) ALLOC_GSL_1D(permutation, var , n, errval) #define ALLOC_GSL_PERMUTATION(var, n, errval) ALLOC_GSL_1D(permutation, var , n, errval)
#define PRINT_GSL_PERMUTATION(var) PRINT_GSL_1D(permutation, var , "%i ") #define PRINT_GSL_PERMUTATION(var) PRINT_GSL_1D(permutation, var , "%i ")
#define FREE_GSL_PERMUTATION(var) FREE_GSL_1D(permutation, var) #define FREE_GSL_PERMUTATION(var) FREE_GSL_1D(permutation, var)
/*@}*/
/*@}*/
 End of changes. 18 change blocks. 
16 lines changed or deleted 33 lines changed or added


 IIRFilter.h   IIRFilter.h 
skipping to change at line 38 skipping to change at line 38
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/ZPGFilter.h> #include <lal/ZPGFilter.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /**
\author Creighton, T. D.
\addtogroup IIRFilter_h \addtogroup IIRFilter_h
\author Creighton, T. D.
\brief Provides routines to make and apply IIR filters. \brief Provides routines to make and apply IIR filters.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
\endcode \endcode
This header covers routines that create, destroy, and apply This header covers routines that create, destroy, and apply
generic time-domain filters, given by objects of type generic time-domain filters, given by objects of type
skipping to change at line 128 skipping to change at line 128
/** /**
@{ @{
\defgroup CreateIIRFilter_c Module CreateIIRFilter.c \defgroup CreateIIRFilter_c Module CreateIIRFilter.c
\defgroup DestroyIIRFilter_c Module DestroyIIRFilter.c \defgroup DestroyIIRFilter_c Module DestroyIIRFilter.c
\defgroup IIRFilter_c Module IIRFilter.c \defgroup IIRFilter_c Module IIRFilter.c
\defgroup IIRFilterVector_c Module IIRFilterVector.c \defgroup IIRFilterVector_c Module IIRFilterVector.c
\defgroup IIRFilterVectorR_c Module IIRFilterVectorR.c \defgroup IIRFilterVectorR_c Module IIRFilterVectorR.c
@} @}
*/ */
/** \name Error Codes */ /*@{*/ /** \name Error Codes */
/*@{*/
#define IIRFILTERH_ENUL 1 /**< Unexpected null pointer in arguments */ #define IIRFILTERH_ENUL 1 /**< Unexpected null pointer in arguments */
#define IIRFILTERH_EOUT 2 /**< Output handle points to a non-null poin ter */ #define IIRFILTERH_EOUT 2 /**< Output handle points to a non-null poin ter */
#define IIRFILTERH_EMEM 3 /**< Memory allocation error */ #define IIRFILTERH_EMEM 3 /**< Memory allocation error */
#define IIRFILTERH_EPAIR 4 /**< Input has unpaired nonreal poles or zer os */ #define IIRFILTERH_EPAIR 4 /**< Input has unpaired nonreal poles or zer os */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define IIRFILTERH_MSGENUL "Unexpected null pointer in arguments" #define IIRFILTERH_MSGENUL "Unexpected null pointer in arguments"
#define IIRFILTERH_MSGEOUT "Output handle points to a non-null pointer" #define IIRFILTERH_MSGEOUT "Output handle points to a non-null pointer"
#define IIRFILTERH_MSGEMEM "Memory allocation error" #define IIRFILTERH_MSGEMEM "Memory allocation error"
 End of changes. 3 change blocks. 
2 lines changed or deleted 3 lines changed or added


 Inject.h   Inject.h 
skipping to change at line 33 skipping to change at line 33
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/Random.h> #include <lal/Random.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /**
\author Creighton, T. D.
\addtogroup Inject_h \addtogroup Inject_h
\author Creighton, T. D.
\brief Provides routines to inject a signal into detector output. \brief Provides routines to inject a signal into detector output.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/Inject.h> #include <lal/Inject.h>
\endcode \endcode
This header provides simple routines to inject a signal, stored as a This header provides simple routines to inject a signal, stored as a
floating-point time series, into an integer time series that floating-point time series, into an integer time series that
skipping to change at line 105 skipping to change at line 105
include data derived by applying floating-point operations on ADC include data derived by applying floating-point operations on ADC
channels (e.g.\ digital filters, linear combinations of channels, channels (e.g.\ digital filters, linear combinations of channels,
etc.), but not data that simply represents ADC output in etc.), but not data that simply represents ADC output in
floating-point format. The assumption here is that the numerical floating-point format. The assumption here is that the numerical
post-processing of the ADC data completely masks any statistical post-processing of the ADC data completely masks any statistical
signiatures of the digitization. signiatures of the digitization.
@{ @{
\defgroup InjectVector_c Module InjectVector.c \defgroup InjectVector_c Module InjectVector.c
\defgroup InjectTimeSeries_c Module InjectTimeSeries.c \defgroup InjectTimeSeries_c Module InjectTimeSeries.c
@}
*/ */
/** \name Error Codes */ /**@{*/ /*@{*/
/** \name Error Codes */
/*@{*/
#define INJECTH_ENUL 1 /**< Unexpected null pointer in arguments. * / #define INJECTH_ENUL 1 /**< Unexpected null pointer in arguments. * /
#define INJECTH_EBAD 2 /**< A sampling interval is (effectively) zero */ #define INJECTH_EBAD 2 /**< A sampling interval is (effectively) zero */
#define INJECTH_EUNIT 3 /**< Input or output is not in units of ADC counts */ #define INJECTH_EUNIT 3 /**< Input or output is not in units of ADC counts */
/** @}*/ /*@}*/
/** @}*/ /*@}*/
#define INJECTH_MSGENUL "Unexpected null pointer in arguments" #define INJECTH_MSGENUL "Unexpected null pointer in arguments"
#define INJECTH_MSGEBAD "A sampling interval is (effectively) zero" #define INJECTH_MSGEBAD "A sampling interval is (effectively) zero"
#define INJECTH_MSGEUNIT "Input or output is not in units of ADC counts" #define INJECTH_MSGEUNIT "Input or output is not in units of ADC counts"
/* Function prototypes. */ /* Function prototypes. */
void void
LALSI2InjectVector( LALStatus *, LALSI2InjectVector( LALStatus *,
INT2Vector *output, INT2Vector *output,
 End of changes. 5 change blocks. 
4 lines changed or deleted 8 lines changed or added


 Interpolate.h   Interpolate.h 
skipping to change at line 134 skipping to change at line 134
tagSInterpolatePar tagSInterpolatePar
{ {
SWIGLAL_STRUCT(SInterpolatePar); SWIGLAL_STRUCT(SInterpolatePar);
UINT4 n; /**< The number of points in the arrays to use in the interp olation */ UINT4 n; /**< The number of points in the arrays to use in the interp olation */
REAL4 *x; /**< The array of domain values */ REAL4 *x; /**< The array of domain values */
REAL4 *y; /**< The array of values to interpolate */ REAL4 *y; /**< The array of values to interpolate */
} }
SInterpolatePar; SInterpolatePar;
/** These structures contain the interpolation parameters; These are the ar rays /** These structures contain the interpolation parameters; These are the ar rays
* of \c n domain values \f$x[0]\ldotsx[n-1]\f$ and their * of \c n domain values \f$x[0]\ldots x[n-1]\f$ and their
* corresponding values \f$y[0]\ldotsy[n-1]\f$ * corresponding values \f$y[0]\ldots y[n-1]\f$
*/ */
typedef struct typedef struct
tagDInterpolatePar tagDInterpolatePar
{ {
SWIGLAL_STRUCT(DInterpolatePar); SWIGLAL_STRUCT(DInterpolatePar);
UINT4 n; /**< The number of points in the arrays to use in the interp olation */ UINT4 n; /**< The number of points in the arrays to use in the interp olation */
REAL8 *x; /**< The array of domain values */ REAL8 *x; /**< The array of domain values */
REAL8 *y; /**< The array of values to interpolate */ REAL8 *y; /**< The array of values to interpolate */
} }
DInterpolatePar; DInterpolatePar;
 End of changes. 1 change blocks. 
2 lines changed or deleted 2 lines changed or added


 LALAdaptiveRungeKutta4.h   LALAdaptiveRungeKutta4.h 
skipping to change at line 21 skipping to change at line 21
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
/**
\addtogroup LALAdaptiveRungeKutta4_h
\author Vallisneri, M.
\brief Adaptive Runge-Kutta4
<ul>
<li> \c integrator Integration structure (quasi-class). Created using <tt>X
LALAdaptiveRungeKutta4Init()</tt>.
...</li>
</ul>
\heading{Description}
The code \ref LALAdaptiveRungeKutta4.c evolves a system of \f$n\f$ coupled
first--order differential equations.
Internally, it uses GSL routines to perform adaptive-step evolution, and th
en interpolates the resulting
trajectories to a fixed step size.
Prior to evolving a system using <tt>XLALAdaptiveRungeKutta4()</tt>, it is
necessary to create an integrator structure using
<tt>XLALAdaptiveRungeKutta4Init()</tt>. Once you are done with the integrat
or, free it with <tt>XLALAdaptiveRungeKutta4Free()</tt>.
\heading{Algorithm}
TBF.
\heading{Uses}
For updated SpinTaylor waveforms.
\heading{Notes}
None so far...
*/
/*@{*/
#define XLAL_BEGINGSL \ #define XLAL_BEGINGSL \
{ \ { \
gsl_error_handler_t *saveGSLErrorHandler_; \ gsl_error_handler_t *saveGSLErrorHandler_; \
XLALGSL_PTHREAD_MUTEX_LOCK; \ XLALGSL_PTHREAD_MUTEX_LOCK; \
saveGSLErrorHandler_ = gsl_set_error_handler_off(); saveGSLErrorHandler_ = gsl_set_error_handler_off();
#define XLAL_ENDGSL \ #define XLAL_ENDGSL \
gsl_set_error_handler( saveGSLErrorHandler_ ); \ gsl_set_error_handler( saveGSLErrorHandler_ ); \
XLALGSL_PTHREAD_MUTEX_UNLOCK; \ XLALGSL_PTHREAD_MUTEX_UNLOCK; \
} }
skipping to change at line 65 skipping to change at line 94
); );
void XLALAdaptiveRungeKutta4Free( ark4GSLIntegrator *integrator ); void XLALAdaptiveRungeKutta4Free( ark4GSLIntegrator *integrator );
int XLALAdaptiveRungeKutta4( ark4GSLIntegrator *integrator, int XLALAdaptiveRungeKutta4( ark4GSLIntegrator *integrator,
void *params, void *params,
REAL8 *yinit, REAL8 *yinit,
REAL8 tinit, REAL8 tend, REAL8 deltat, REAL8 tinit, REAL8 tend, REAL8 deltat,
REAL8Array **yout REAL8Array **yout
); );
/** int XLALAdaptiveRungeKutta4Hermite( ark4GSLIntegrator *integrator,
* Fourth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg (RKF4 void *params,
5) REAL8 *yinit,
* steps with adaptive step size control. Intended for use in various REAL8 tinit,
* waveform generation routines such as SpinTaylorT4 and various EOB models REAL8 tend_in,
. REAL8 deltat,
* REAL8Array **yout
* The method is described in
*
* Abramowitz & Stegun, Handbook of Mathematical Functions, Tenth Printing,
* National Bureau of Standards, Washington, DC, 1972
* (available online at http://people.math.sfu.ca/~cbm/aands/ )
*
* This function also includes "on-the-fly" interpolation of the
* differential equations at regular intervals in-between integration
* steps. This "on-the-fly" interpolation method is derived and
* described in the Mathematica notebook "RKF_with_interpolation.nb";
* see
* https://www.lsc-group.phys.uwm.edu/ligovirgo/cbcnote/InspiralPipelineDev
elopment/120312111836InspiralPipelineDevelopmentImproved%20Adaptive%20Runge
-Kutta%20integrator
*
* This method is functionally equivalent to XLALAdaptiveRungeKutta4,
* but is nearly always faster due to the improved interpolation.
*/
int XLALAdaptiveRungeKutta4Hermite( ark4GSLIntegrator *integrator, /**< str
uct holding dydt, stopping test, stepper, etc. */
void *params, /**< params struct used t
o compute dydt and stopping test */
REAL8 *yinit, /**< pass in initial valu
es of all variables - overwritten to final values */
REAL8 tinit, /**< integration start tim
e */
REAL8 tend_in, /**< maximum integration
time */
REAL8 deltat, /**< step size for evenly
sampled output */
REAL8Array **yout /**< array holding th
e evenly sampled output */
); );
/*@}*/
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _LALADAPTIVERUNGEKUTTA4_H */ #endif /* _LALADAPTIVERUNGEKUTTA4_H */
 End of changes. 3 change blocks. 
39 lines changed or deleted 43 lines changed or added


 LALBarycenter.h   LALBarycenter.h 
skipping to change at line 39 skipping to change at line 39
#include <math.h> #include <math.h>
#include <lal/LALStdio.h> #include <lal/LALStdio.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** \name Error codes */
/*@{*/ /** \ingroup Barycenter_h */
#define LALBARYCENTERH_ENULL 2
#define LALBARYCENTERH_EOUTOFRANGEE 4
#define LALBARYCENTERH_EOUTOFRANGES 8
#define LALBARYCENTERH_EBADSOURCEPOS 16
#define LALBARYCENTERH_EXLAL 32
#define LALBARYCENTERH_MSGENULL "Null input to Barycenter routine."
#define LALBARYCENTERH_MSGEOUTOFRANGEE "tgps not in range of earth.dat fil
e"
#define LALBARYCENTERH_MSGEOUTOFRANGES "tgps not in range of sun.dat file"
#define LALBARYCENTERH_MSGEBADSOURCEPOS "source position not in standard ra
nge"
#define LALBARYCENTERH_MSGEXLAL "XLAL function failed."
/*@}*/
/** /**
* \defgroup LALBarycenter_h Barycentering * \defgroup LALBarycenter_h Barycentering
* \ingroup pulsarCommon
* \author Curt Cutler * \author Curt Cutler
* \date 2001 * \date 2001
* \ingroup pulsarCommon *
* \brief Provides routines for transforming from arrival time at detector (GPS) to pulse emission time (TDB); ie * \brief Provides routines for transforming from arrival time at detector (GPS) to pulse emission time (TDB); ie
* for ``barycentering'' the measured astronomical time series. * for ``barycentering'' the measured astronomical time series.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/LALInitBarycenter.h> * #include <lal/LALInitBarycenter.h>
* #include <lal/LALBarycenter.h> * #include <lal/LALBarycenter.h>
* \endcode * \endcode
* *
*/ */
/*@{*/ /*@{*/
/** \name Error codes */
/*@{*/
#define LALBARYCENTERH_ENULL 2 /**< Null input to Barycenter routin
e. */
#define LALBARYCENTERH_EOUTOFRANGEE 4 /**< tgps not in range of earth.dat
file */
#define LALBARYCENTERH_EOUTOFRANGES 8 /**< tgps not in range of sun.dat fi
le */
#define LALBARYCENTERH_EBADSOURCEPOS 16 /**< source position not in
standard range */
#define LALBARYCENTERH_EXLAL 32 /**< XLAL function failed. */
/*@}*/
/** \cond DONT_DOXYGEN */
#define LALBARYCENTERH_MSGENULL "Null input to Barycenter routine."
#define LALBARYCENTERH_MSGEOUTOFRANGEE "tgps not in range of earth.dat fil
e"
#define LALBARYCENTERH_MSGEOUTOFRANGES "tgps not in range of sun.dat file"
#define LALBARYCENTERH_MSGEBADSOURCEPOS "source position not in standard ra
nge"
#define LALBARYCENTERH_MSGEXLAL "XLAL function failed."
/** \endcond */
/** \brief [DEPRECATED] Used as input for LALInitBarycenter(), this structu re contains /** \brief [DEPRECATED] Used as input for LALInitBarycenter(), this structu re contains
* two pointers to the ephemeris data files containing arrays * two pointers to the ephemeris data files containing arrays
* of center-of-mass positions for the Earth and Sun, respectively. * of center-of-mass positions for the Earth and Sun, respectively.
* *
* The tables are derived from the JPL ephemeris. * The tables are derived from the JPL ephemeris.
* *
* Files tabulate positions for one calendar year * Files tabulate positions for one calendar year
* (actually, a little more than one year, to deal * (actually, a little more than one year, to deal
* with overlaps). The first line of each table summarizes * with overlaps). The first line of each table summarizes
* what is in it. Subsequent lines give the time (GPS) and the * what is in it. Subsequent lines give the time (GPS) and the
skipping to change at line 206 skipping to change at line 209
REAL8 tDot; /**< d(emission time in TDB)/d(arrival time in GPS) */ REAL8 tDot; /**< d(emission time in TDB)/d(arrival time in GPS) */
REAL8 rDetector[3]; /**< Cartesian coords (0=x,1=y,2=z) of detector pos ition REAL8 rDetector[3]; /**< Cartesian coords (0=x,1=y,2=z) of detector pos ition
* at $t_a$ (GPS), in ICRS J2000 coords. Units = se c. */ * at $t_a$ (GPS), in ICRS J2000 coords. Units = se c. */
REAL8 vDetector[3]; /* Cartesian coords (0=x,1=y,2=z) of detector veloc ity REAL8 vDetector[3]; /* Cartesian coords (0=x,1=y,2=z) of detector veloc ity
* at \f$t_a\f$ (GPS), in ICRS J2000 coords. Dimens ionless. */ * at \f$t_a\f$ (GPS), in ICRS J2000 coords. Dimens ionless. */
} }
EmissionTime; EmissionTime;
/*@}*/
/*Curt: probably best to take 1.0 OUT of tDot--ie., output tDot-1. /*Curt: probably best to take 1.0 OUT of tDot--ie., output tDot-1.
But most users would immediately add back the one anyway. But most users would immediately add back the one anyway.
*/ */
/*Curt: rem te is ``time pulse would arrive at a GPS clock /*Curt: rem te is ``time pulse would arrive at a GPS clock
way out in empty space, if you renormalized and zero-ed the latter way out in empty space, if you renormalized and zero-ed the latter
to give, on average, the same arrival time as the GPS clock on Earth'' */ to give, on average, the same arrival time as the GPS clock on Earth'' */
/* Function prototypes. */ /* Function prototypes. */
int XLALBarycenterEarth ( EarthState *earth, const LIGOTimeGPS *tGPS, const EphemerisData *edat); int XLALBarycenterEarth ( EarthState *earth, const LIGOTimeGPS *tGPS, const EphemerisData *edat);
int XLALBarycenter ( EmissionTime *emit, const BarycenterInput *baryinput, const EarthState *earth); int XLALBarycenter ( EmissionTime *emit, const BarycenterInput *baryinput, const EarthState *earth);
void LALBarycenterEarth ( LALStatus *status, EarthState *earth, const LIGOT imeGPS *tGPS, const EphemerisData *edat); void LALBarycenterEarth ( LALStatus *status, EarthState *earth, const LIGOT imeGPS *tGPS, const EphemerisData *edat);
void LALBarycenter ( LALStatus *status, EmissionTime *emit, const Barycente rInput *baryinput, const EarthState *earth); void LALBarycenter ( LALStatus *status, EmissionTime *emit, const Barycente rInput *baryinput, const EarthState *earth);
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* Close C++ protection */ #endif /* Close C++ protection */
#endif /* Close double-include protection */ #endif /* Close double-include protection */
 End of changes. 6 change blocks. 
20 lines changed or deleted 27 lines changed or added


 LALCalibration.h   LALCalibration.h 
skipping to change at line 34 skipping to change at line 34
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** \addtogroup Calibration_h */
/*@{*/
/** Structure containing calibration information (reference spectra and /** Structure containing calibration information (reference spectra and
* factors for updating calibraiton to a particular time). */ * factors for updating calibraiton to a particular time). */
typedef struct tagLALCalData typedef struct tagLALCalData
{ {
SWIGLAL_STRUCT(LALCalData); SWIGLAL_STRUCT(LALCalData);
REAL4TimeSeries *cavityFactors; REAL4TimeSeries *cavityFactors;
REAL4TimeSeries *openLoopFactors; REAL4TimeSeries *openLoopFactors;
COMPLEX8FrequencySeries *responseReference; COMPLEX8FrequencySeries *responseReference;
COMPLEX8FrequencySeries *cavityGainReference; COMPLEX8FrequencySeries *cavityGainReference;
COMPLEX8FrequencySeries *openLoopGainReference; COMPLEX8FrequencySeries *openLoopGainReference;
skipping to change at line 97 skipping to change at line 100
); );
/** Computes a response function at a requested frequency resolution /** Computes a response function at a requested frequency resolution
* that is valid at a requested epoch. */ * that is valid at a requested epoch. */
int XLALUpdateResponse( int XLALUpdateResponse(
COMPLEX8FrequencySeries *response, /**< response function to return */ COMPLEX8FrequencySeries *response, /**< response function to return */
REAL8 duration, /**< duration for averaging factors */ REAL8 duration, /**< duration for averaging factors */
LALCalData *caldata /**< calibration reference data */ LALCalData *caldata /**< calibration reference data */
); );
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _LALCALIBRATION_H */ #endif /* _LALCALIBRATION_H */
 End of changes. 2 change blocks. 
0 lines changed or deleted 5 lines changed or added


 LALConfig.h   LALConfig.h 
/* include/lal/LALConfig.h. Generated from LALConfig.h.in by configure. * / /* include/lal/LALConfig.h. Generated from LALConfig.h.in by configure. * /
/* only include this file if LAL's config.h has not been included */ /* only include this file if LAL's config.h has not been included */
#ifndef CONFIG_H__LAL #ifndef CONFIG_H__LAL
#ifndef _LALCONFIG_H #ifndef _LALCONFIG_H
#define _LALCONFIG_H #define _LALCONFIG_H
/* LAL Version */ /* LAL Version */
#define LAL_VERSION "6.7.0" #define LAL_VERSION "6.7.1"
/* LAL Version Major Number */ /* LAL Version Major Number */
#define LAL_VERSION_MAJOR 6 #define LAL_VERSION_MAJOR 6
/* LAL Version Minor Number */ /* LAL Version Minor Number */
#define LAL_VERSION_MINOR 7 #define LAL_VERSION_MINOR 7
/* LAL Version Micro Number */ /* LAL Version Micro Number */
#define LAL_VERSION_MICRO 0 #define LAL_VERSION_MICRO 1
/* LAL Version Devel Number */ /* LAL Version Devel Number */
#define LAL_VERSION_DEVEL 0 #define LAL_VERSION_DEVEL 0
/* LAL Configure Arguments */ /* LAL Configure Arguments */
#define LAL_CONFIGURE_ARGS " '--enable-shared' '--prefix=/home/andrey/upstr eam-tracker/testing/lal/6.7.0' '--exec-prefix=/home/andrey/upstream-tracker /testing/lal/6.7.0' '--sysconfdir=/home/andrey/upstream-tracker/testing/lal /6.7.0' '--datadir=/home/andrey/upstream-tracker/testing/lal/6.7.0' 'CFLAGS =-w -fpermissive' 'CXXFLAGS=-w -fpermissive'" #define LAL_CONFIGURE_ARGS " '--enable-shared' '--prefix=/home/andrey/upstr eam-tracker/testing/lal/6.7.1' '--exec-prefix=/home/andrey/upstream-tracker /testing/lal/6.7.1' '--sysconfdir=/home/andrey/upstream-tracker/testing/lal /6.7.1' '--datadir=/home/andrey/upstream-tracker/testing/lal/6.7.1' 'CFLAGS =-w -fpermissive' 'CXXFLAGS=-w -fpermissive'"
/* LAL Configure Date */ /* LAL Configure Date */
#define LAL_CONFIGURE_DATE "2012-05-12T12:05:59+0400" #define LAL_CONFIGURE_DATE "2012-05-12T11:44:34+0400"
/* LAL Install Prefix */ /* LAL Install Prefix */
#define LAL_PREFIX "/usr/local" #define LAL_PREFIX "/usr/local"
/* Suppress debugging code */ /* Suppress debugging code */
/* #undef LAL_NDEBUG */ /* #undef LAL_NDEBUG */
/* Use functions rather than macros */ /* Use functions rather than macros */
/* #undef NOLALMACROS */ /* #undef NOLALMACROS */
 End of changes. 4 change blocks. 
4 lines changed or deleted 4 lines changed or added


 LALCorrelation.h   LALCorrelation.h 
skipping to change at line 36 skipping to change at line 36
#endif #endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
/* ****** INCLUDE ANY OTHER LAL HEADERS needed for header (NOT module) **** / /* ****** INCLUDE ANY OTHER LAL HEADERS needed for header (NOT module) **** /
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
\author Yakushin, Igor
\addtogroup LALCorrelation_h \addtogroup LALCorrelation_h
\author Yakushin, Igor
\brief [One sentence briefly defining scope of the header] \brief [One sentence briefly defining scope of the header]
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/LALCorrelation.h> #include <lal/LALCorrelation.h>
\endcode \endcode
[Generic documentation on the header; this is the main place to [Generic documentation on the header; this is the main place to
document any stuff not specific to the module] document any stuff not specific to the module]
*/ */
/** @{ */ /*@{*/
/**\name Error Codes */ /*@{*/ /**\name Error Codes */
/*@{*/
#define LALCORRELATIONH_ENULLP 1 /**< Null pointer */ #define LALCORRELATIONH_ENULLP 1 /**< Null pointer */
#define LALCORRELATIONH_ESTART 2 /**< Time series do not start simultaneously */ #define LALCORRELATIONH_ESTART 2 /**< Time series do not start simultaneously */
#define LALCORRELATIONH_ESAMPLING 3 /**< Time series are not sampled with the same rate */ #define LALCORRELATIONH_ESAMPLING 3 /**< Time series are not sampled with the same rate */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define LALCORRELATIONH_MSGENULLP "Null pointer" #define LALCORRELATIONH_MSGENULLP "Null pointer"
#define LALCORRELATIONH_MSGESTART "Time series do not start simultaneous ly" #define LALCORRELATIONH_MSGESTART "Time series do not start simultaneous ly"
#define LALCORRELATIONH_MSGESAMPLING "Time series are not sampled with the same rate" #define LALCORRELATIONH_MSGESAMPLING "Time series are not sampled with the same rate"
/** \endcond */ /** \endcond */
/* ***** DEFINE OTHER GLOBAL CONSTANTS OR MACROS ************/ /* ***** DEFINE OTHER GLOBAL CONSTANTS OR MACROS ************/
/* ***** DEFINE NEW STRUCTURES AND TYPES ************/ /* ***** DEFINE NEW STRUCTURES AND TYPES ************/
/** UNDOCUMENTED */
typedef struct typedef struct
tagCorrelationParams tagCorrelationParams
{ {
SWIGLAL_STRUCT(CorrelationParams); SWIGLAL_STRUCT(CorrelationParams);
REAL4 maxTimeShiftNan; REAL4 maxTimeShiftNan;
} }
CorrelationParams; CorrelationParams;
/** UNDOCUMENTED */
typedef struct typedef struct
tagInputCorrelation tagInputCorrelation
{ {
SWIGLAL_STRUCT(InputCorrelation); SWIGLAL_STRUCT(InputCorrelation);
REAL4TimeSeries *one; REAL4TimeSeries *one;
REAL4TimeSeries *two; REAL4TimeSeries *two;
} }
InputCorrelation; InputCorrelation;
/** OutputCorrelation structure */ /** OutputCorrelation structure */
skipping to change at line 114 skipping to change at line 117
OutputCorrelation; OutputCorrelation;
/* ***** INCLUDE EXTERNAL GLOBAL VARIABLES ************/ /* ***** INCLUDE EXTERNAL GLOBAL VARIABLES ************/
void void
LALCorrelation( LALStatus *status, LALCorrelation( LALStatus *status,
OutputCorrelation **output, OutputCorrelation **output,
const InputCorrelation *input, const InputCorrelation *input,
const CorrelationParams *params); const CorrelationParams *params);
/** @} */ /*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _LDASCAMPMOMENT_H */ #endif /* _LDASCAMPMOMENT_H */
 End of changes. 7 change blocks. 
4 lines changed or deleted 7 lines changed or added


 LALDetectors.h   LALDetectors.h 
skipping to change at line 34 skipping to change at line 34
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /** \addtogroup LALDetectors_h
\author J. T. Whelan and J. D. E. Creighton \author J. T. Whelan and J. D. E. Creighton
\addtogroup LALDetectors_h
\brief This header defines structures to hold the basic data describing \brief This header defines structures to hold the basic data describing
a gravitational wave detector. a gravitational wave detector.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/LALDetectors.h> #include <lal/LALDetectors.h>
\endcode \endcode
According to the common frame format specification According to the common frame format specification
[\ref LIGOVIRGO_2000] the geometry of an interferometric [\ref LIGOVIRGO_2000] the geometry of an interferometric
detector will be stored in a \c ::FrDetector structure, specifying detector will be stored in a \c FrDetector structure, specifying
the location of the detector vertex and the orientation of its arms in the location of the detector vertex and the orientation of its arms in
geodetic coördinates suited to geographical surveying. Resonant geodetic coördinates suited to geographical surveying. Resonant
bars and other sorts of detectors, if they write their data to frames, bars and other sorts of detectors, if they write their data to frames,
are expected to fill this structure with their location and are expected to fill this structure with their location and
orientation in some way suited to the detector type. orientation in some way suited to the detector type.
For most data analysis tasks, however, any gravitational wave detector For most data analysis tasks, however, any gravitational wave detector
can be described by its location in an Earth-fixed rotating reference can be described by its location in an Earth-fixed rotating reference
frame, as well as a <em>response tensor</em> \f$d^{ab}\f$, constant in the frame, as well as a <em>response tensor</em> \f$d^{ab}\f$, constant in the
same frame, which defines the "strain" \f$h\f$ measured by the detector in same frame, which defines the "strain" \f$h\f$ measured by the detector in
terms of the metric perturbation \f$h_{ab}\f$ as terms of the metric perturbation \f$h_{ab}\f$ as
\f{equation}{ \f{equation}{
h = h_{ab} \, d^{ab} h = h_{ab} \, d^{ab}
\ . \ .
\f} \f}
This header defines a \c ::LALFrDetector structure which contains This header defines a \c ::LALFrDetector structure which contains
essentially the same information as the \c ::FrDetector structure, essentially the same information as the \c FrDetector structure,
as well as a \c LALDetector structure which contains the as well as a \c LALDetector structure which contains the
Cartesian coördinates of the detector along with the components of Cartesian coördinates of the detector along with the components of
the response tensor \f$d^{ab}\f$ in the same coördinate system. the response tensor \f$d^{ab}\f$ in the same coördinate system.
\heading{The Geodetic Coördinate System} \heading{The Geodetic Coördinate System}
Geodetic coördinates are spheroidal coördinates Geodetic coördinates are spheroidal coördinates
based on the WGS-84 Earth Model, which is an based on the WGS-84 Earth Model, which is an
oblate spheroid with equatorial radius \f$a=6.378137\times oblate spheroid with equatorial radius \f$a=6.378137\times
10^6\,\textrm{m}\f$ and polar radius \f$b=6.356752314\times 10^6\,\textrm{m}\f$ and polar radius \f$b=6.356752314\times
skipping to change at line 157 skipping to change at line 155
* The <tt>LALCreateDetector()</tt> routine will first look through the * The <tt>LALCreateDetector()</tt> routine will first look through the
* \c lalCachedDetectors array for a \c LALDetector structure * \c lalCachedDetectors array for a \c LALDetector structure
* with matching \c type and <tt>frDetector.name</tt> fields; if it * with matching \c type and <tt>frDetector.name</tt> fields; if it
* finds one, it returns a copy of that; if not, it creates one. * finds one, it returns a copy of that; if not, it creates one.
* *
* For example, the \c LALDetector representing LIGO Hanford 4km (H1) in * For example, the \c LALDetector representing LIGO Hanford 4km (H1) in
* differential mode is <tt>lalCachedDetectors[LAL_LHO_4K_DETECTOR]</tt>. * differential mode is <tt>lalCachedDetectors[LAL_LHO_4K_DETECTOR]</tt>.
* *
* *
*/ */
/** @{ */ /*@{*/
/** \name Error Codes */ /*@{*/ /** \name Error Codes */
/*@{*/
#define LALDETECTORSH_ENULLP 1 /**< Null pointer */ #define LALDETECTORSH_ENULLP 1 /**< Null pointer */
#define LALDETECTORSH_ETYPE 2 /**< Unsupported detector type */ #define LALDETECTORSH_ETYPE 2 /**< Unsupported detector type */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define LALDETECTORSH_MSGENULLP "Null pointer" #define LALDETECTORSH_MSGENULLP "Null pointer"
#define LALDETECTORSH_MSGETYPE "Unsupported detector type" #define LALDETECTORSH_MSGETYPE "Unsupported detector type"
#define LALDETECTORSH_PRINTF 0 #define LALDETECTORSH_PRINTF 0
/** \endcond */ /** \endcond */
skipping to change at line 188 skipping to change at line 187
LAL_LLO_4K_DETECTOR = 5, LAL_LLO_4K_DETECTOR = 5,
LAL_CIT_40_DETECTOR = 6, LAL_CIT_40_DETECTOR = 6,
LAL_ALLEGRO_DETECTOR = 7, LAL_ALLEGRO_DETECTOR = 7,
LAL_AURIGA_DETECTOR = 8, LAL_AURIGA_DETECTOR = 8,
LAL_EXPLORER_DETECTOR = 9, LAL_EXPLORER_DETECTOR = 9,
LAL_NIOBE_DETECTOR = 10, LAL_NIOBE_DETECTOR = 10,
LAL_NAUTILUS_DETECTOR = 11, LAL_NAUTILUS_DETECTOR = 11,
LAL_NUM_DETECTORS = 12 LAL_NUM_DETECTORS = 12
}; };
/**< Detector DQ bit assignments (2 bits per detector) */ /** Detector DQ bit assignments (2 bits per detector) */
enum { enum {
LAL_TAMA_300_DETECTOR_BIT = 1 << 2 * LAL_TAMA_300_DETECT OR, LAL_TAMA_300_DETECTOR_BIT = 1 << 2 * LAL_TAMA_300_DETECT OR,
LAL_VIRGO_DETECTOR_BIT = 1 << 2 * LAL_VIRGO_DETECTOR, LAL_VIRGO_DETECTOR_BIT = 1 << 2 * LAL_VIRGO_DETECTOR,
LAL_GEO_600_DETECTOR_BIT = 1 << 2 * LAL_GEO_600_DETECTO R, LAL_GEO_600_DETECTOR_BIT = 1 << 2 * LAL_GEO_600_DETECTO R,
LAL_LHO_2K_DETECTOR_BIT = 1 << 2 * LAL_LHO_2K_DETECTOR , LAL_LHO_2K_DETECTOR_BIT = 1 << 2 * LAL_LHO_2K_DETECTOR ,
LAL_LHO_4K_DETECTOR_BIT = 1 << 2 * LAL_LHO_4K_DETECTOR , LAL_LHO_4K_DETECTOR_BIT = 1 << 2 * LAL_LHO_4K_DETECTOR ,
LAL_LLO_4K_DETECTOR_BIT = 1 << 2 * LAL_LLO_4K_DETECTOR , LAL_LLO_4K_DETECTOR_BIT = 1 << 2 * LAL_LLO_4K_DETECTOR ,
LAL_CIT_40_DETECTOR_BIT = 1 << 2 * LAL_CIT_40_DETECTOR , LAL_CIT_40_DETECTOR_BIT = 1 << 2 * LAL_CIT_40_DETECTOR ,
LAL_ALLEGRO_DETECTOR_BIT = 1 << 2 * LAL_ALLEGRO_DETECTO R, LAL_ALLEGRO_DETECTOR_BIT = 1 << 2 * LAL_ALLEGRO_DETECTO R,
LAL_AURIGA_DETECTOR_BIT = 1 << 2 * LAL_AURIGA_DETECTOR , LAL_AURIGA_DETECTOR_BIT = 1 << 2 * LAL_AURIGA_DETECTOR ,
skipping to change at line 266 skipping to change at line 265
LALFrDetector frDetector; /**< The original LALFrDetector stru cture from which this was created */ LALFrDetector frDetector; /**< The original LALFrDetector stru cture from which this was created */
} }
LALDetector; LALDetector;
/** Pre-existing detectors. */ /** Pre-existing detectors. */
extern const LALDetector lalCachedDetectors[LAL_NUM_DETECTORS]; extern const LALDetector lalCachedDetectors[LAL_NUM_DETECTORS];
#ifdef SWIG /* SWIG interface directives */ #ifdef SWIG /* SWIG interface directives */
SWIGLAL_GLOBAL_CONST_FIXED_1DARRAY_ELEM(LALDetector, lalCachedDetectors); SWIGLAL_GLOBAL_CONST_FIXED_1DARRAY_ELEM(LALDetector, lalCachedDetectors);
#endif #endif
/*@}*/
/* Routine to create a LALDetector. */ /* Routine to create a LALDetector. */
LALDetector * XLALCreateDetector( LALDetector *detector, const LALFrDetecto r *frDetector, LALDetectorType type ); LALDetector * XLALCreateDetector( LALDetector *detector, const LALFrDetecto r *frDetector, LALDetectorType type );
void LALCreateDetector( LALStatus *status, LALDetector *output, const LALFr Detector *input, const LALDetectorType type ); void LALCreateDetector( LALStatus *status, LALDetector *output, const LALFr Detector *input, const LALDetectorType type );
/** @} */
/* Interferometric Detectors */ /* Interferometric Detectors */
/** /** \defgroup DetectorConstants Detector Constants
* \defgroup DetectorConstants Detector Constants
* \ingroup LALDetectors_h * \ingroup LALDetectors_h
* \brief Constants describing various gravitational wave detectors * \brief Constants describing various gravitational wave detectors
* *
* The \ref LALDetectors_h also defines numerical constants that describe t he location and * The \ref LALDetectors_h also defines numerical constants that describe t he location and
* geometry of several operating gravitational wave detectors. * geometry of several operating gravitational wave detectors.
* These detectors are both resonant mass (bar) detectors and interferometr ic * These detectors are both resonant mass (bar) detectors and interferometr ic
* detectors. * detectors.
* <ul> * <ul>
* <li> Data for the resonant mass detectors is taken from: * <li> Data for the resonant mass detectors is taken from:
* http://igec.lnl.infn.it/cgi-bin/browser.pl?Level=0,3,1 * http://igec.lnl.infn.it/cgi-bin/browser.pl?Level=0,3,1
skipping to change at line 306 skipping to change at line 304
* <li> Data for the TAMA detector is provided by Masa-Katsu Fujimoto * <li> Data for the TAMA detector is provided by Masa-Katsu Fujimoto
* *
* <li> Data for the Caltech detector is taken from [\ref Allen_1996] * <li> Data for the Caltech detector is taken from [\ref Allen_1996]
* </ul> * </ul>
* *
* See the technical document [\ref ABCCRW_2001] for details. * See the technical document [\ref ABCCRW_2001] for details.
* *
* Data in this file (e.g., angle conventions etc.) is intended * Data in this file (e.g., angle conventions etc.) is intended
* to conform to the conventions of the Frame format specification [\ref LI GOVIRGO_2000] * to conform to the conventions of the Frame format specification [\ref LI GOVIRGO_2000]
* *
* @{
*/ */
/*@{*/
/** \name TAMA 300m Interferometric Detector constants /** \name TAMA 300m Interferometric Detector constants
* The following constants describe the location and geometry of the * The following constants describe the location and geometry of the
* TAMA 300m Interferometric Detector. */ * TAMA 300m Interferometric Detector. */
/*@{*/ /*@{*/
#define LAL_TAMA_300_DETECTOR_NAME "TAMA_300" /**< TAMA_300 detector name string */ #define LAL_TAMA_300_DETECTOR_NAME "TAMA_300" /**< TAMA_300 detector name string */
#define LAL_TAMA_300_DETECTOR_PREFIX "T1" /**< TAMA_30 0 detector prefix string */ #define LAL_TAMA_300_DETECTOR_PREFIX "T1" /**< TAMA_30 0 detector prefix string */
#define LAL_TAMA_300_DETECTOR_LONGITUDE_RAD 2.43536359469 /**< TAMA_300 vertex longitude (rad) */ #define LAL_TAMA_300_DETECTOR_LONGITUDE_RAD 2.43536359469 /**< TAMA_300 vertex longitude (rad) */
#define LAL_TAMA_300_DETECTOR_LATITUDE_RAD 0.62267336022 /**< TAMA_300 vertex latitude (rad) */ #define LAL_TAMA_300_DETECTOR_LATITUDE_RAD 0.62267336022 /**< TAMA_300 vertex latitude (rad) */
#define LAL_TAMA_300_DETECTOR_ELEVATION_SI 90 /**< TAMA_30 0 vertex elevation (m) */ #define LAL_TAMA_300_DETECTOR_ELEVATION_SI 90 /**< TAMA_30 0 vertex elevation (m) */
skipping to change at line 514 skipping to change at line 512
#define LAL_ALLEGRO_320_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< ALLEGRO_320 x arm altitude (rad) */ #define LAL_ALLEGRO_320_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< ALLEGRO_320 x arm altitude (rad) */
#define LAL_ALLEGRO_320_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< ALLEGRO_320 y arm altitude (rad) UNUSED FOR BARS */ #define LAL_ALLEGRO_320_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< ALLEGRO_320 y arm altitude (rad) UNUSED FOR BARS */
#define LAL_ALLEGRO_320_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< ALLEGRO_320 x arm midpoint (m) UNUSED FOR BARS */ #define LAL_ALLEGRO_320_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< ALLEGRO_320 x arm midpoint (m) UNUSED FOR BARS */
#define LAL_ALLEGRO_320_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< ALLEGRO_320 y arm midpoint (m) UNUSED FOR BARS */ #define LAL_ALLEGRO_320_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< ALLEGRO_320 y arm midpoint (m) UNUSED FOR BARS */
#define LAL_ALLEGRO_320_VERTEX_LOCATION_X_SI -1.13258964140e+05 /**< ALLEGRO_320 x-component of vertex location in Earth-centered frame (m) */ #define LAL_ALLEGRO_320_VERTEX_LOCATION_X_SI -1.13258964140e+05 /**< ALLEGRO_320 x-component of vertex location in Earth-centered frame (m) */
#define LAL_ALLEGRO_320_VERTEX_LOCATION_Y_SI -5.50408337391e+06 /**< ALLEGRO_320 y-component of vertex location in Earth-centered frame (m) */ #define LAL_ALLEGRO_320_VERTEX_LOCATION_Y_SI -5.50408337391e+06 /**< ALLEGRO_320 y-component of vertex location in Earth-centered frame (m) */
#define LAL_ALLEGRO_320_VERTEX_LOCATION_Z_SI 3.20989567981e+06 /**< ALLEGRO_320 z-component of vertex location in Earth-centered frame (m) */ #define LAL_ALLEGRO_320_VERTEX_LOCATION_Z_SI 3.20989567981e+06 /**< ALLEGRO_320 z-component of vertex location in Earth-centered frame (m) */
#define LAL_ALLEGRO_320_AXIS_DIRECTION_X -0.63467362345 /**< ALLEGRO_320 x-component of unit vector pointing along axis in Earth-center ed frame */ #define LAL_ALLEGRO_320_AXIS_DIRECTION_X -0.63467362345 /**< ALLEGRO_320 x-component of unit vector pointing along axis in Earth-center ed frame */
#define LAL_ALLEGRO_320_AXIS_DIRECTION_Y 0.40093077976 /**< ALLEGRO_320 y-component of unit vector pointing along axis in Earth-center ed frame */ #define LAL_ALLEGRO_320_AXIS_DIRECTION_Y 0.40093077976 /**< ALLEGRO_320 y-component of unit vector pointing along axis in Earth-center ed frame */
#define LAL_ALLEGRO_320_AXIS_DIRECTION_Z 0.66063901000 /**< ALLEGRO_320 z-component of unit vector pointing along axis in Earth-center ed frame */ #define LAL_ALLEGRO_320_AXIS_DIRECTION_Z 0.66063901000 /**< ALLEGRO_320 z-component of unit vector pointing along axis in Earth-center ed frame */
/*@}*/
/** \name AURIGA Resonant Mass Detector constants /** \name AURIGA Resonant Mass Detector constants
* The following constants describe the location and geometry of the * The following constants describe the location and geometry of the
* AURIGA Resonant Mass Detector. */ * AURIGA Resonant Mass Detector. */
/*@{*/ /*@{*/
#define LAL_AURIGA_DETECTOR_NAME "AURIGA" /**< AURIGA detector name string */ #define LAL_AURIGA_DETECTOR_NAME "AURIGA" /**< AURIGA detector name string */
#define LAL_AURIGA_DETECTOR_PREFIX "O1" /**< AURIGA detector prefix string */ #define LAL_AURIGA_DETECTOR_PREFIX "O1" /**< AURIGA detector prefix string */
#define LAL_AURIGA_DETECTOR_LONGITUDE_RAD 0.20853775679 /**< AURIGA vertex longitude (rad) */ #define LAL_AURIGA_DETECTOR_LONGITUDE_RAD 0.20853775679 /**< AURIGA vertex longitude (rad) */
#define LAL_AURIGA_DETECTOR_LATITUDE_RAD 0.79156499342 /**< AURIGA vertex latitude (rad) */ #define LAL_AURIGA_DETECTOR_LATITUDE_RAD 0.79156499342 /**< AURIGA vertex latitude (rad) */
#define LAL_AURIGA_DETECTOR_ELEVATION_SI 0 /**< AURIGA vertex elevation (m) */ #define LAL_AURIGA_DETECTOR_ELEVATION_SI 0 /**< AURIGA vertex elevation (m) */
skipping to change at line 536 skipping to change at line 535
#define LAL_AURIGA_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< AURIGA x arm altitude (rad) */ #define LAL_AURIGA_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< AURIGA x arm altitude (rad) */
#define LAL_AURIGA_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< AURIGA y arm altitude (rad) UNUSED FOR BARS */ #define LAL_AURIGA_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< AURIGA y arm altitude (rad) UNUSED FOR BARS */
#define LAL_AURIGA_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< AURIGA x arm midpoint (m) UNUSED FOR BARS */ #define LAL_AURIGA_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< AURIGA x arm midpoint (m) UNUSED FOR BARS */
#define LAL_AURIGA_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< AURIGA y arm midpoint (m) UNUSED FOR BARS */ #define LAL_AURIGA_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< AURIGA y arm midpoint (m) UNUSED FOR BARS */
#define LAL_AURIGA_VERTEX_LOCATION_X_SI 4.39246733007e+06 /**< AURIGA x-component of vertex location in Earth-centered frame (m) */ #define LAL_AURIGA_VERTEX_LOCATION_X_SI 4.39246733007e+06 /**< AURIGA x-component of vertex location in Earth-centered frame (m) */
#define LAL_AURIGA_VERTEX_LOCATION_Y_SI 9.29508666967e+05 /**< AURIGA y-component of vertex location in Earth-centered frame (m) */ #define LAL_AURIGA_VERTEX_LOCATION_Y_SI 9.29508666967e+05 /**< AURIGA y-component of vertex location in Earth-centered frame (m) */
#define LAL_AURIGA_VERTEX_LOCATION_Z_SI 4.51502913071e+06 /**< AURIGA z-component of vertex location in Earth-centered frame (m) */ #define LAL_AURIGA_VERTEX_LOCATION_Z_SI 4.51502913071e+06 /**< AURIGA z-component of vertex location in Earth-centered frame (m) */
#define LAL_AURIGA_AXIS_DIRECTION_X -0.64450412225 /**< AURIGA x-component of unit vector pointing along axis in Earth-centered fr ame */ #define LAL_AURIGA_AXIS_DIRECTION_X -0.64450412225 /**< AURIGA x-component of unit vector pointing along axis in Earth-centered fr ame */
#define LAL_AURIGA_AXIS_DIRECTION_Y 0.57365538956 /**< AURIGA y-component of unit vector pointing along axis in Earth-centered fr ame */ #define LAL_AURIGA_AXIS_DIRECTION_Y 0.57365538956 /**< AURIGA y-component of unit vector pointing along axis in Earth-centered fr ame */
#define LAL_AURIGA_AXIS_DIRECTION_Z 0.50550364038 /**< AURIGA z-component of unit vector pointing along axis in Earth-centered fr ame */ #define LAL_AURIGA_AXIS_DIRECTION_Z 0.50550364038 /**< AURIGA z-component of unit vector pointing along axis in Earth-centered fr ame */
/*@}*/
/** \name EXPLORER Resonant Mass Detector constants /** \name EXPLORER Resonant Mass Detector constants
* The following constants describe the location and geometry of the * The following constants describe the location and geometry of the
* EXPLORER Resonant Mass Detector. */ * EXPLORER Resonant Mass Detector. */
/*@{*/ /*@{*/
#define LAL_EXPLORER_DETECTOR_NAME "EXPLORER" /**< EXPLORER detector name string */ #define LAL_EXPLORER_DETECTOR_NAME "EXPLORER" /**< EXPLORER detector name string */
#define LAL_EXPLORER_DETECTOR_PREFIX "E1" /**< EXPLORE R detector prefix string */ #define LAL_EXPLORER_DETECTOR_PREFIX "E1" /**< EXPLORE R detector prefix string */
#define LAL_EXPLORER_DETECTOR_LONGITUDE_RAD 0.10821041362 /**< EXPLORER vertex longitude (rad) */ #define LAL_EXPLORER_DETECTOR_LONGITUDE_RAD 0.10821041362 /**< EXPLORER vertex longitude (rad) */
#define LAL_EXPLORER_DETECTOR_LATITUDE_RAD 0.81070543755 /**< EXPLORER vertex latitude (rad) */ #define LAL_EXPLORER_DETECTOR_LATITUDE_RAD 0.81070543755 /**< EXPLORER vertex latitude (rad) */
#define LAL_EXPLORER_DETECTOR_ELEVATION_SI 0 /**< EXPLORE R vertex elevation (m) */ #define LAL_EXPLORER_DETECTOR_ELEVATION_SI 0 /**< EXPLORE R vertex elevation (m) */
skipping to change at line 558 skipping to change at line 558
#define LAL_EXPLORER_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< EXPLORER x arm altitude (rad) */ #define LAL_EXPLORER_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< EXPLORER x arm altitude (rad) */
#define LAL_EXPLORER_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< EXPLORER y arm altitude (rad) UNUSED FOR BARS */ #define LAL_EXPLORER_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< EXPLORER y arm altitude (rad) UNUSED FOR BARS */
#define LAL_EXPLORER_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< EXPLORER x arm midpoint (m) UNUSED FOR BARS */ #define LAL_EXPLORER_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< EXPLORER x arm midpoint (m) UNUSED FOR BARS */
#define LAL_EXPLORER_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< EXPLORER y arm midpoint (m) UNUSED FOR BARS */ #define LAL_EXPLORER_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< EXPLORER y arm midpoint (m) UNUSED FOR BARS */
#define LAL_EXPLORER_VERTEX_LOCATION_X_SI 4.37645395452e+06 /**< EXPLORER x-component of vertex location in Earth-centered frame (m ) */ #define LAL_EXPLORER_VERTEX_LOCATION_X_SI 4.37645395452e+06 /**< EXPLORER x-component of vertex location in Earth-centered frame (m ) */
#define LAL_EXPLORER_VERTEX_LOCATION_Y_SI 4.75435044067e+05 /**< EXPLORER y-component of vertex location in Earth-centered frame (m ) */ #define LAL_EXPLORER_VERTEX_LOCATION_Y_SI 4.75435044067e+05 /**< EXPLORER y-component of vertex location in Earth-centered frame (m ) */
#define LAL_EXPLORER_VERTEX_LOCATION_Z_SI 4.59985274450e+06 /**< EXPLORER z-component of vertex location in Earth-centered frame (m ) */ #define LAL_EXPLORER_VERTEX_LOCATION_Z_SI 4.59985274450e+06 /**< EXPLORER z-component of vertex location in Earth-centered frame (m ) */
#define LAL_EXPLORER_AXIS_DIRECTION_X -0.62792641437 /**< EXPLORER x-component of unit vector pointing along axis in Earth-centered frame */ #define LAL_EXPLORER_AXIS_DIRECTION_X -0.62792641437 /**< EXPLORER x-component of unit vector pointing along axis in Earth-centered frame */
#define LAL_EXPLORER_AXIS_DIRECTION_Y 0.56480832712 /**< EXPLORER y-component of unit vector pointing along axis in Earth-centered frame */ #define LAL_EXPLORER_AXIS_DIRECTION_Y 0.56480832712 /**< EXPLORER y-component of unit vector pointing along axis in Earth-centered frame */
#define LAL_EXPLORER_AXIS_DIRECTION_Z 0.53544371484 /**< EXPLORER z-component of unit vector pointing along axis in Earth-centered frame */ #define LAL_EXPLORER_AXIS_DIRECTION_Z 0.53544371484 /**< EXPLORER z-component of unit vector pointing along axis in Earth-centered frame */
/*@}*/
/** \name Nautilus Resonant Mass Detector constants /** \name Nautilus Resonant Mass Detector constants
* The following constants describe the location and geometry of the * The following constants describe the location and geometry of the
* Nautilus Resonant Mass Detector. */ * Nautilus Resonant Mass Detector. */
/*@{*/ /*@{*/
#define LAL_NAUTILUS_DETECTOR_NAME "Nautilus" /**< Nautilus detector name string */ #define LAL_NAUTILUS_DETECTOR_NAME "Nautilus" /**< Nautilus detector name string */
#define LAL_NAUTILUS_DETECTOR_PREFIX "N1" /**< Nautilu s detector prefix string */ #define LAL_NAUTILUS_DETECTOR_PREFIX "N1" /**< Nautilu s detector prefix string */
#define LAL_NAUTILUS_DETECTOR_LONGITUDE_RAD 0.22117684946 /**< Nautilus vertex longitude (rad) */ #define LAL_NAUTILUS_DETECTOR_LONGITUDE_RAD 0.22117684946 /**< Nautilus vertex longitude (rad) */
#define LAL_NAUTILUS_DETECTOR_LATITUDE_RAD 0.72996456710 /**< Nautilus vertex latitude (rad) */ #define LAL_NAUTILUS_DETECTOR_LATITUDE_RAD 0.72996456710 /**< Nautilus vertex latitude (rad) */
#define LAL_NAUTILUS_DETECTOR_ELEVATION_SI 0 /**< Nautilu s vertex elevation (m) */ #define LAL_NAUTILUS_DETECTOR_ELEVATION_SI 0 /**< Nautilu s vertex elevation (m) */
skipping to change at line 580 skipping to change at line 581
#define LAL_NAUTILUS_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< Nautilus x arm altitude (rad) */ #define LAL_NAUTILUS_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< Nautilus x arm altitude (rad) */
#define LAL_NAUTILUS_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< Nautilus y arm altitude (rad) UNUSED FOR BARS */ #define LAL_NAUTILUS_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< Nautilus y arm altitude (rad) UNUSED FOR BARS */
#define LAL_NAUTILUS_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< Nautilus x arm midpoint (m) UNUSED FOR BARS */ #define LAL_NAUTILUS_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< Nautilus x arm midpoint (m) UNUSED FOR BARS */
#define LAL_NAUTILUS_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< Nautilus y arm midpoint (m) UNUSED FOR BARS */ #define LAL_NAUTILUS_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< Nautilus y arm midpoint (m) UNUSED FOR BARS */
#define LAL_NAUTILUS_VERTEX_LOCATION_X_SI 4.64410999868e+06 /**< Nautilus x-component of vertex location in Earth-centered frame (m ) */ #define LAL_NAUTILUS_VERTEX_LOCATION_X_SI 4.64410999868e+06 /**< Nautilus x-component of vertex location in Earth-centered frame (m ) */
#define LAL_NAUTILUS_VERTEX_LOCATION_Y_SI 1.04425342477e+06 /**< Nautilus y-component of vertex location in Earth-centered frame (m ) */ #define LAL_NAUTILUS_VERTEX_LOCATION_Y_SI 1.04425342477e+06 /**< Nautilus y-component of vertex location in Earth-centered frame (m ) */
#define LAL_NAUTILUS_VERTEX_LOCATION_Z_SI 4.23104713307e+06 /**< Nautilus z-component of vertex location in Earth-centered frame (m ) */ #define LAL_NAUTILUS_VERTEX_LOCATION_Z_SI 4.23104713307e+06 /**< Nautilus z-component of vertex location in Earth-centered frame (m ) */
#define LAL_NAUTILUS_AXIS_DIRECTION_X -0.62039441384 /**< Nautilus x-component of unit vector pointing along axis in Earth-centered frame */ #define LAL_NAUTILUS_AXIS_DIRECTION_X -0.62039441384 /**< Nautilus x-component of unit vector pointing along axis in Earth-centered frame */
#define LAL_NAUTILUS_AXIS_DIRECTION_Y 0.57250373141 /**< Nautilus y-component of unit vector pointing along axis in Earth-centered frame */ #define LAL_NAUTILUS_AXIS_DIRECTION_Y 0.57250373141 /**< Nautilus y-component of unit vector pointing along axis in Earth-centered frame */
#define LAL_NAUTILUS_AXIS_DIRECTION_Z 0.53605060283 /**< Nautilus z-component of unit vector pointing along axis in Earth-centered frame */ #define LAL_NAUTILUS_AXIS_DIRECTION_Z 0.53605060283 /**< Nautilus z-component of unit vector pointing along axis in Earth-centered frame */
/*@}*/
/** \name NIOBE Resonant Mass Detector constants /** \name NIOBE Resonant Mass Detector constants
* The following constants describe the location and geometry of the * The following constants describe the location and geometry of the
* NIOBE Resonant Mass Detector. */ * NIOBE Resonant Mass Detector. */
/*@{*/ /*@{*/
#define LAL_NIOBE_DETECTOR_NAME "NIOBE" /**< NIOBE detector name string */ #define LAL_NIOBE_DETECTOR_NAME "NIOBE" /**< NIOBE detector name string */
#define LAL_NIOBE_DETECTOR_PREFIX "B1" /**< NIOBE detector prefix string */ #define LAL_NIOBE_DETECTOR_PREFIX "B1" /**< NIOBE detector prefix string */
#define LAL_NIOBE_DETECTOR_LONGITUDE_RAD 2.02138216202 /**< NIOBE v ertex longitude (rad) */ #define LAL_NIOBE_DETECTOR_LONGITUDE_RAD 2.02138216202 /**< NIOBE v ertex longitude (rad) */
#define LAL_NIOBE_DETECTOR_LATITUDE_RAD -0.55734180780 /**< NIOBE v ertex latitude (rad) */ #define LAL_NIOBE_DETECTOR_LATITUDE_RAD -0.55734180780 /**< NIOBE v ertex latitude (rad) */
#define LAL_NIOBE_DETECTOR_ELEVATION_SI 0 /**< NIOBE vertex el evation (m) */ #define LAL_NIOBE_DETECTOR_ELEVATION_SI 0 /**< NIOBE vertex el evation (m) */
skipping to change at line 602 skipping to change at line 604
#define LAL_NIOBE_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< NIOBE x arm altitude (rad) */ #define LAL_NIOBE_DETECTOR_ARM_X_ALTITUDE_RAD 0.00000000000 /**< NIOBE x arm altitude (rad) */
#define LAL_NIOBE_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< NIOBE y arm altitude (rad) UNUSED FOR BARS */ #define LAL_NIOBE_DETECTOR_ARM_Y_ALTITUDE_RAD 0.00000000000 /**< NIOBE y arm altitude (rad) UNUSED FOR BARS */
#define LAL_NIOBE_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< NIOBE x arm midpoint (m) UNUSED FOR BARS */ #define LAL_NIOBE_DETECTOR_ARM_X_MIDPOINT_SI 0.00000000000 /**< NIOBE x arm midpoint (m) UNUSED FOR BARS */
#define LAL_NIOBE_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< NIOBE y arm midpoint (m) UNUSED FOR BARS */ #define LAL_NIOBE_DETECTOR_ARM_Y_MIDPOINT_SI 0.00000000000 /**< NIOBE y arm midpoint (m) UNUSED FOR BARS */
#define LAL_NIOBE_VERTEX_LOCATION_X_SI -2.35948871453e+06 /**< NIOBE x-component of vertex location in Earth-centered frame (m) */ #define LAL_NIOBE_VERTEX_LOCATION_X_SI -2.35948871453e+06 /**< NIOBE x-component of vertex location in Earth-centered frame (m) */
#define LAL_NIOBE_VERTEX_LOCATION_Y_SI 4.87721571259e+06 /**< NIOBE y-component of vertex location in Earth-centered frame (m) */ #define LAL_NIOBE_VERTEX_LOCATION_Y_SI 4.87721571259e+06 /**< NIOBE y-component of vertex location in Earth-centered frame (m) */
#define LAL_NIOBE_VERTEX_LOCATION_Z_SI -3.35416003274e+06 /**< NIOBE z-component of vertex location in Earth-centered frame (m) */ #define LAL_NIOBE_VERTEX_LOCATION_Z_SI -3.35416003274e+06 /**< NIOBE z-component of vertex location in Earth-centered frame (m) */
#define LAL_NIOBE_AXIS_DIRECTION_X -0.23034623759 /**< NIOBE x -component of unit vector pointing along axis in Earth-centered frame */ #define LAL_NIOBE_AXIS_DIRECTION_X -0.23034623759 /**< NIOBE x -component of unit vector pointing along axis in Earth-centered frame */
#define LAL_NIOBE_AXIS_DIRECTION_Y 0.47614056486 /**< NIOBE y -component of unit vector pointing along axis in Earth-centered frame */ #define LAL_NIOBE_AXIS_DIRECTION_Y 0.47614056486 /**< NIOBE y -component of unit vector pointing along axis in Earth-centered frame */
#define LAL_NIOBE_AXIS_DIRECTION_Z 0.84866411101 /**< NIOBE z -component of unit vector pointing along axis in Earth-centered frame */ #define LAL_NIOBE_AXIS_DIRECTION_Z 0.84866411101 /**< NIOBE z -component of unit vector pointing along axis in Earth-centered frame */
/** @} */ /*@}*/
/** @} */ /*@}*//* end: DetectorConstants */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _LALDETECTORS_H */ #endif /* _LALDETECTORS_H */
 End of changes. 19 change blocks. 
21 lines changed or deleted 24 lines changed or added


 LALMoment.h   LALMoment.h 
skipping to change at line 33 skipping to change at line 33
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
/* C++ protection. */ /* C++ protection. */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
\author Tibbits, M. M.
\addtogroup LALMoment_h \addtogroup LALMoment_h
\author Tibbits, M. M.
\brief This header provides the prototype for the LALDMoment() and LALSMome nt() function. \brief This header provides the prototype for the LALDMoment() and LALSMome nt() function.
\code \code
(S - single precision ) (S - single precision )
(D - double precision ) (D - double precision )
\endcode \endcode
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/LALMoment.h> #include <lal/LALMoment.h>
\endcode \endcode
\heading{Description}
The data structure passed in is either a REAL8 or a REAL4 Sequence. The on
ly parameter is which
moment to calculate. The function the sums the data, calculates the average
and then it returns the
average for the first moment, it returns the variance for the second moment
, and it returns the n-th
moment about the mean for higher order moments.
\heading{Algorithm}
<ul>
<li> Find the mean (here referred to as \f$ \overline{x} \f$).</li>
<li> Sum, over all the elements, the quantity: \f$(x[k] - \overline{x})^{n}
\f$</li>
<li> Divide the sum just made by N-1. Call it moment-n</li>
<li> If n is greater than 2:</li>
<ul>
<li> Sum, over all the elements, the quantity: \f$(x[k] - \overline{x})^
{n}\f$</li>
<li> <em>Divide the sum just made by N. Call it moment-n</em></li>
</ul>
<li>Return moment-n</li>
</ul>
\heading{Uses}
Determination of a specific moment of a set of data.
\heading{Notes}
<ul>
<li> <em>Moments less than two are not allowed.</em></li>
<li> <em>The result structure must be Non-NULL when passed in.</em></li>
<li> <em>The function assumes that the length member of the data passed in
is correct.</em></li>
</ul>
*/ */
/** @{ */ /*@{*/
/**\name Error Codes */ /*@{*/
/**\name Error Codes */
/*@{*/
#define LALMOMENTH_ENULL 1 /**< NULL pointer */ #define LALMOMENTH_ENULL 1 /**< NULL pointer */
#define LALMOMENTH_ENNUL 2 /**< Non-NULL pointer */ #define LALMOMENTH_ENNUL 2 /**< Non-NULL pointer */
#define LALMOMENTH_ELNTH 3 /**< Must have more than one data point */ #define LALMOMENTH_ELNTH 3 /**< Must have more than one data point */
#define LALMOMENTH_ESEGZ 4 /**< Invalid number of segments */ #define LALMOMENTH_ESEGZ 4 /**< Invalid number of segments */
#define LALMOMENTH_ENUMZ 5 /**< Invalid number of points in segment */ #define LALMOMENTH_ENUMZ 5 /**< Invalid number of points in segment */
#define LALMOMENTH_EALOC 6 /**< Memory Allocation Error */ #define LALMOMENTH_EALOC 6 /**< Memory Allocation Error */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define LALMOMENTH_MSGENULL "NULL pointer." #define LALMOMENTH_MSGENULL "NULL pointer."
skipping to change at line 90 skipping to change at line 124
/** Determine specific moment of a set of REAL8 data. /** Determine specific moment of a set of REAL8 data.
*/ */
void LALDMoment void LALDMoment
( (
LALStatus *status, LALStatus *status,
REAL8 *result, REAL8 *result,
REAL8Sequence *data, REAL8Sequence *data,
INT4 whichMoment INT4 whichMoment
); );
/** @} */ /*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection. */ #endif /* C++ protection. */
#endif /* Double-include protection. _LALMOMENT_H_ */ #endif /* Double-include protection. _LALMOMENT_H_ */
 End of changes. 5 change blocks. 
4 lines changed or deleted 44 lines changed or added


 LALRunningMedian.h   LALRunningMedian.h 
skipping to change at line 35 skipping to change at line 35
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
\author Somya D. Mohanty, B. Machenschalk
\addtogroup LALRunningMedian_h \addtogroup LALRunningMedian_h
\author Somya D. Mohanty, B. Machenschalk
\brief Provides routines to efficiently calculate the running median \brief Provides routines to efficiently calculate the running median
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/LALRunningMedian.h> #include <lal/LALRunningMedian.h>
\endcode \endcode
This header covers routines to efficiently calculate the This header covers routines to efficiently calculate the
running median of REAL4 and REAL8 sequences running median of REAL4 and REAL8 sequences
skipping to change at line 112 skipping to change at line 112
*/ */
typedef struct tagLALRunningMedianPar typedef struct tagLALRunningMedianPar
{ {
SWIGLAL_STRUCT(LALRunningMedianPar); SWIGLAL_STRUCT(LALRunningMedianPar);
UINT4 blocksize; /**< the number of elements a single median is calcu lated from */ UINT4 blocksize; /**< the number of elements a single median is calcu lated from */
} }
LALRunningMedianPar; LALRunningMedianPar;
/* Function prototypes. */ /* Function prototypes. */
/** \see See LALRunningMedian_h for documentation */ /** See LALRunningMedian_h for documentation */
void void
LALDRunningMedian( LALStatus *status, LALDRunningMedian( LALStatus *status,
REAL8Sequence *medians, REAL8Sequence *medians,
const REAL8Sequence *input, const REAL8Sequence *input,
LALRunningMedianPar param); LALRunningMedianPar param);
/** \see See LALRunningMedian_h for documentation */ /** See LALRunningMedian_h for documentation */
void void
LALSRunningMedian( LALStatus *status, LALSRunningMedian( LALStatus *status,
REAL4Sequence *medians, REAL4Sequence *medians,
const REAL4Sequence *input, const REAL4Sequence *input,
LALRunningMedianPar param); LALRunningMedianPar param);
/** \see See LALRunningMedian_h for documentation */ /** See LALRunningMedian_h for documentation */
void void
LALDRunningMedian2( LALStatus *status, LALDRunningMedian2( LALStatus *status,
REAL8Sequence *medians, REAL8Sequence *medians,
const REAL8Sequence *input, const REAL8Sequence *input,
LALRunningMedianPar param); LALRunningMedianPar param);
/** \see See LALRunningMedian_h for documentation */ /** See LALRunningMedian_h for documentation */
void void
LALSRunningMedian2( LALStatus *status, LALSRunningMedian2( LALStatus *status,
REAL4Sequence *medians, REAL4Sequence *medians,
const REAL4Sequence *input, const REAL4Sequence *input,
LALRunningMedianPar param); LALRunningMedianPar param);
/*@}*/ /*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
 End of changes. 6 change blocks. 
5 lines changed or deleted 5 lines changed or added


 LALVCSInfo.h   LALVCSInfo.h 
skipping to change at line 38 skipping to change at line 38
#endif #endif
#include <lal/LALConfig.h> #include <lal/LALConfig.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* vcs information defines */ /* vcs information defines */
#define LAL_NAME "LAL" #define LAL_NAME "LAL"
#define LAL_VCS_ID "711028f35c53197b1241956fdbba9a43113b8dc0" #define LAL_VCS_ID "5de7951cb4c0d9ab4c6a9c4b8f36e16d2cc2b4ed"
#define LAL_VCS_DATE "2012-04-10 20:38:40 +0000" #define LAL_VCS_DATE "2012-05-11 16:55:41 +0000"
#define LAL_VCS_BRANCH "None" #define LAL_VCS_BRANCH "None"
#define LAL_VCS_TAG "lal-v6.7.0" #define LAL_VCS_TAG "lal-v6.7.1"
#define LAL_VCS_AUTHOR "Adam Mercer <adam.mercer@ligo.org>" #define LAL_VCS_AUTHOR "Adam Mercer <adam.mercer@ligo.org>"
#define LAL_VCS_COMMITTER "Adam Mercer <adam.mercer@ligo.org>" #define LAL_VCS_COMMITTER "Adam Mercer <adam.mercer@ligo.org>"
#define LAL_VCS_STATUS "CLEAN: All modifications committed" #define LAL_VCS_STATUS "CLEAN: All modifications committed"
/* vcs information defines - identable*/ /* vcs information defines - identable*/
#define LAL_VCS_IDENT_ID "$" "LALId: 711028f35c53197b1241956fdbba9a43113b8d #define LAL_VCS_IDENT_ID "$" "LALId: 5de7951cb4c0d9ab4c6a9c4b8f36e16d2cc2b4
c0 " "$" ed " "$"
#define LAL_VCS_IDENT_DATE "$" "LALDate: 2012-04-10 20:38:40 +0000 " "$" #define LAL_VCS_IDENT_DATE "$" "LALDate: 2012-05-11 16:55:41 +0000 " "$"
#define LAL_VCS_IDENT_BRANCH "$" "LALBranch: None " "$" #define LAL_VCS_IDENT_BRANCH "$" "LALBranch: None " "$"
#define LAL_VCS_IDENT_TAG "$" "LALTag: lal-v6.7.0 " "$" #define LAL_VCS_IDENT_TAG "$" "LALTag: lal-v6.7.1 " "$"
#define LAL_VCS_IDENT_AUTHOR "$" "LALAuthor: Adam Mercer <adam.mercer@ligo. org> " "$" #define LAL_VCS_IDENT_AUTHOR "$" "LALAuthor: Adam Mercer <adam.mercer@ligo. org> " "$"
#define LAL_VCS_IDENT_COMMITTER "$" "LALCommitter: Adam Mercer <adam.mercer @ligo.org> " "$" #define LAL_VCS_IDENT_COMMITTER "$" "LALCommitter: Adam Mercer <adam.mercer @ligo.org> " "$"
#define LAL_VCS_IDENT_STATUS "$" "LALStatus: CLEAN: All modifications commi tted " "$" #define LAL_VCS_IDENT_STATUS "$" "LALStatus: CLEAN: All modifications commi tted " "$"
/* global variables for vcs information, defined in LALVCSInfo.c */ /* global variables for vcs information, defined in LALVCSInfo.c */
extern const char *const lalVCSVersion; extern const char *const lalVCSVersion;
extern const char *const lalVCSId; extern const char *const lalVCSId;
extern const char *const lalVCSDate; extern const char *const lalVCSDate;
extern const char *const lalVCSBranch; extern const char *const lalVCSBranch;
extern const char *const lalVCSTag; extern const char *const lalVCSTag;
 End of changes. 4 change blocks. 
7 lines changed or deleted 7 lines changed or added


 LPC.h   LPC.h 
skipping to change at line 52 skipping to change at line 52
\endcode \endcode
*/ */
/*@{*/ /*@{*/
/**\name Error Codes */ /**\name Error Codes */
/*@{*/ /*@{*/
#define LPCH_EIN 1 /**< invalid input */ #define LPCH_EIN 1 /**< invalid input */
#define LPCH_EMEM 2 /**< memory error */ #define LPCH_EMEM 2 /**< memory error */
#define LPCH_ENUM 3 /**< numerical error */ #define LPCH_ENUM 3 /**< numerical error */
/*@}*/ /*@}*/
/*@}*/
/** \cond DONT_DOXYGEN */
#define LPCH_MSGEIN "invalid input" #define LPCH_MSGEIN "invalid input"
#define LPCH_MSGEMEM "memory error" #define LPCH_MSGEMEM "memory error"
#define LPCH_MSGENUM "numerical error" #define LPCH_MSGENUM "numerical error"
/** \endcond */
void LALPolystab(LALStatus *status, void LALPolystab(LALStatus *status,
REAL4Vector *a); REAL4Vector *a);
void LALLPC(LALStatus *status, void LALLPC(LALStatus *status,
REAL4Vector *aout, /* returned filter coefficients */ REAL4Vector *aout, /* returned filter coefficients */
REAL4Vector *x, /* training data */ REAL4Vector *x, /* training data */
UINT4 p /* filter order */ UINT4 p /* filter order */
); );
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection. */ #endif /* C++ protection. */
#endif #endif
 End of changes. 4 change blocks. 
1 lines changed or deleted 4 lines changed or added


 Matrix.h   Matrix.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
#include <math.h>
#include <lal/LALStdlib.h>
#include <lal/SeqFactories.h>
#include <lal/AVFactories.h>
#ifndef __MATLAB_MATRIX_H__
#define __MATLAB_MATRIX_H__
#ifdef __cplusplus
extern "C" {
#endif
/** /**
* \author Matthew M. Tibbits
* \addtogroup Matrix_h * \addtogroup Matrix_h
* \author Matthew M. Tibbits
* *
* \brief Matlab Routines to handle Matrices \& Vectors. * \brief Matlab Routines to handle Matrices \& Vectors.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/Matrix.h> * #include <lal/Matrix.h>
* \endcode * \endcode
* *
* @{ * @{
* \defgroup MatrixMultiply_c Module MatrixMultiply.c * \defgroup MatrixMultiply_c Module MatrixMultiply.c
* \defgroup MatrixDivide_c Module MatrixDivide.c * \defgroup MatrixDivide_c Module MatrixDivide.c
* \defgroup MatrixPower_c Module MatrixPower.c * \defgroup MatrixPower_c Module MatrixPower.c
* \defgroup MiscMatlab_c Module MiscMatlab.c * \defgroup MiscMatlab_c Module MiscMatlab.c
* *
*/ */
#include <math.h> /**\name Error Codes */
#include <lal/LALStdlib.h> /*@{*/
#include <lal/SeqFactories.h>
#include <lal/AVFactories.h>
#ifndef __MATLAB_MATRIX_H__
#define __MATLAB_MATRIX_H__
#ifdef __cplusplus
extern "C" {
#endif
/**\name Error Codes */ /*@{*/
#define MATLABMATRIXH_EARG 1 /**< Error parsing command-line argu ments */ #define MATLABMATRIXH_EARG 1 /**< Error parsing command-line argu ments */
#define MATLABMATRIXH_ECHK 2 /**< Error checking failed to catch bad data */ #define MATLABMATRIXH_ECHK 2 /**< Error checking failed to catch bad data */
#define MATLABMATRIXH_EFLS 3 /**< Incorrect answer for valid data */ #define MATLABMATRIXH_EFLS 3 /**< Incorrect answer for valid data */
#define MATLABMATRIXH_EUSE 4 /**< Bad user-entered data */ #define MATLABMATRIXH_EUSE 4 /**< Bad user-entered data */
#define MATLABMATRIXH_ENULL 5 /**< Null Pointer */ #define MATLABMATRIXH_ENULL 5 /**< Null Pointer */
#define MATLABMATRIXH_EALOC 6 /**< Memory Allocation Error */ #define MATLABMATRIXH_EALOC 6 /**< Memory Allocation Error */
#define MATLABMATRIXH_EFPMS 7 /**< Filter Parameter Structure Erro r */ #define MATLABMATRIXH_EFPMS 7 /**< Filter Parameter Structure Erro r */
#define MATLABMATRIXH_ENUMZ 8 /**< Incorrect number of command line argume nts */ #define MATLABMATRIXH_ENUMZ 8 /**< Incorrect number of command line argume nts */
#define MATLABMATRIXH_ELNTH 9 /**< Vector/Array of Improper Length */ #define MATLABMATRIXH_ELNTH 9 /**< Vector/Array of Improper Length */
#define MATLABMATRIXH_ENNUL 10 /**< Non-Null Pointer that should be NULL */ #define MATLABMATRIXH_ENNUL 10 /**< Non-Null Pointer that should be NULL */
/** @} */ /*@}*/
/** @} */
/*@}*/
/** \cond DONT_DOXYGEN */
#define MATLABMATRIXH_MSGEARG "Error parsing command-line arguments" #define MATLABMATRIXH_MSGEARG "Error parsing command-line arguments"
#define MATLABMATRIXH_MSGECHK "Error checking failed to catch bad da ta" #define MATLABMATRIXH_MSGECHK "Error checking failed to catch bad da ta"
#define MATLABMATRIXH_MSGEFLS "Incorrect answer for valid data" #define MATLABMATRIXH_MSGEFLS "Incorrect answer for valid data"
#define MATLABMATRIXH_MSGEUSE "Bad user-entered data" #define MATLABMATRIXH_MSGEUSE "Bad user-entered data"
#define MATLABMATRIXH_MSGENULL "Null Pointer." #define MATLABMATRIXH_MSGENULL "Null Pointer."
#define MATLABMATRIXH_MSGEALOC "Memory Allocation Error" #define MATLABMATRIXH_MSGEALOC "Memory Allocation Error"
#define MATLABMATRIXH_MSGEFPMS "Filter Parameter Structure Error" #define MATLABMATRIXH_MSGEFPMS "Filter Parameter Structure Error"
#define MATLABMATRIXH_MSGENUMZ "Incorrect number of command line arguments" #define MATLABMATRIXH_MSGENUMZ "Incorrect number of command line arguments"
#define MATLABMATRIXH_MSGELNTH "Vector/Array of Improper Length" #define MATLABMATRIXH_MSGELNTH "Vector/Array of Improper Length"
#define MATLABMATRIXH_MSGENNUL "Non-Null Pointer that should be NULL" #define MATLABMATRIXH_MSGENNUL "Non-Null Pointer that should be NULL"
/** \endcond */
/* Multiply */ /* ---------- Function prototypes ---------- */
/** \addtogroup MatrixMultiply_c /**
* @{ \addtogroup MatrixMultiply_c
*/ \author Tibbits, M. M.
\brief This file is dedicated to reproducing the matlab function ".*" .
This file has several declarations of the same function taking all forms of
available
input. This being said, I have yet to script the complex actions and their
counterparts.
\heading{Description}
This file is to help make the conversion from Matlab to c much earier.
In this file, we have created all of the versions of .* that we plan on
using.
\heading{Algorithms}
The algorithm is the same as it is in matlab. The dot in front of an opera
tor
in matlab signifies that if either or both of the operands are vectors, the
n
the operation will be carried out member by member. For instance
\code
vector a[25];
vector b[25];
vector c[25];
c = a .* b;
The result of this is:
c[0] = a[0] * b[0];
c[1] = a[1] * b[1];
. . .
. . .
. . .
etc.
\endcode
\heading{Notes}
At the current time none of the operations have been specified for neither
the
complex datatypes nor the unsigned datatypes.
*/
/*@{*/
void LALDDotStarDVector ( void LALDDotStarDVector (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
REAL8 B, REAL8 B,
REAL8Vector *A REAL8Vector *A
); );
void LALDVectorDotStarDVector ( void LALDVectorDotStarDVector (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
skipping to change at line 500 skipping to change at line 548
INT8 A, INT8 A,
INT8Array *B INT8Array *B
); );
void LALI8ArrayDotStarI8Array ( void LALI8ArrayDotStarI8Array (
LALStatus *status, LALStatus *status,
INT8Array **result, INT8Array **result,
INT8Array *A, INT8Array *A,
INT8Array *B INT8Array *B
); );
/*@}*/ /* end: MatrixMultiply_c */
/** @} */ /**
\addtogroup MatrixDivide_c
\author Tibbits, M. M.
/* Matrix Division */ \brief This file is dedicated to reproducing the matlab function "./" .
/** \addtogroup MatrixDivide_c
* @{ This file has several declarations of the same function taking all forms of
*/ available
input. This being said, I have yet to script the complex actions and their
counterparts.
\heading{Description}
This file is to help make the conversion from Matlab to c much earier.
In this file, we have created all of the versions of ./ that we plan on
using.
\heading{Algorithms}
The algorithm is the same as it is in matlab. The dot in front of an opera
tor
in matlab signifies that if either or both of the operands are vectors, the
n
the operation will be carried out member by member. For instance
\code
vector a[25];
vector b[25];
vector c[25];
c = a ./ b;
The result of this is:
c[0] = a[0] / b[0];
c[1] = a[1] / b[1];
. . .
. . .
. . .
etc.
\endcode
\heading{Notes}
At the current time none of the operations have been specified for neither
the
complex datatypes nor the unsigned datatypes.
*/
/*@{*/
void LALDDotSlashDVector ( void LALDDotSlashDVector (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
REAL8 A, REAL8 A,
REAL8Vector *B REAL8Vector *B
); );
void LALDVectorDotSlashD ( void LALDVectorDotSlashD (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
skipping to change at line 1138 skipping to change at line 1227
INT8 B INT8 B
); );
void LALI8ArrayDotSlashI8Array ( void LALI8ArrayDotSlashI8Array (
LALStatus *status, LALStatus *status,
INT8Array **result, INT8Array **result,
INT8Array *A, INT8Array *A,
INT8Array *B INT8Array *B
); );
/** @} */ /*@}*/ /* end: MatrixDivide_c */
/* Matrix Power */ /**
/** \addtogroup MatrixPower_c \addtogroup MatrixPower_c
* @{ \author Tibbits, M. M.
*/
\brief This file is dedicated to reproducing the matlab function ".^" .
This file has several declarations of the same function taking all forms of
available
input. This being said, I have yet to script the complex actions and their
counterparts.
\heading{Description}
This file is to help make the conversion from Matlab to c much earier.
In this file, we have created all of the versions of .^ that we plan on
using.
\heading{Algorithms}
The algorithm is the same as it is in matlab. The dot in front of an opera
tor
in matlab signifies that if either or both of the operands are vectors, the
n
the operation will be carried out member by member. For instance
\code
vector a[25];
vector b[25];
vector c[25];
c = a .^ b;
The result of this is:
\(c[0] = a[0]^(b[0]);
\(c[1] = a[1]^(b[1]);
. . .
. . .
. . .
etc.
\endcode
\heading{Notes}
At the current time none of the operations have been specified for neither
the
complex datatypes nor the unsigned datatypes.
*/
/*@{*/
void LALDDotPowerDVector ( void LALDDotPowerDVector (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
REAL8 A, REAL8 A,
REAL8Vector *B REAL8Vector *B
); );
void LALDVectorDotPowerD ( void LALDVectorDotPowerD (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
skipping to change at line 1773 skipping to change at line 1905
INT8Array *A, INT8Array *A,
INT8 B INT8 B
); );
void LALI8ArrayDotPowerI8Array ( void LALI8ArrayDotPowerI8Array (
LALStatus *status, LALStatus *status,
REAL8Array **result, REAL8Array **result,
INT8Array *A, INT8Array *A,
INT8Array *B INT8Array *B
); );
/** @} */ /*@}*/ /* end: MatrixPower_c */
/* Miscellaneous Routines */ /**
/** \addtogroup MiscMatlab_c \addtogroup MiscMatlab_c
* @{ \author Tibbits, M. M.
*/
\brief This file reproduces the last few matlab functions that we needed fo
r our purposes.
It creates useable forms of cumsum, sum, max, and finally an implemenation
of the
array addressing in matlab. Matlab has an easy of inverting a vector, (end
: -1: 1)
and the final function, FlipVector returns a result vector that has been fl
ipped in
that same manner.
\heading{Description}
This file reproduces the last few matlab functions that we needed for our p
urposes.
It creates useable forms of cumsum, sum, max, and finally an implemenation
of the
array addressing in matlab. Matlab has an easy of inverting a vector, (end
: -1: 1)
and the final function, FlipVector returns a result vector that has been fl
ipped in
that same manner.
\heading{Algorithms}
The algorithms are the same as in matlab. Flip vector was discussed above.
Sum
takes the sum of all of the elements in a vector. Cum sum takes an input v
ector:
\code
vector input[25];
vector output[25];
output[0] = input[0];
output[1] = input[0] + input[1];
output[2] = input[0] + input[1] + input[2];
etc
\endcode
\heading{Notes}
At the current time none of the operations have been specified for neither
the
complex datatypes nor the unsigned datatypes.
Also, the prototypes are out of order as I have used m4 to create all of th
e
functions from one codebase.
*/
/*@{*/
void LALDCumSum ( void LALDCumSum (
LALStatus *status, LALStatus *status,
REAL8Vector **result, REAL8Vector **result,
REAL8Vector *data REAL8Vector *data
); );
void LALDSum ( void LALDSum (
LALStatus *status, LALStatus *status,
REAL8 *result, REAL8 *result,
REAL8Vector *data REAL8Vector *data
skipping to change at line 1904 skipping to change at line 2076
INT8Vector *data, INT8Vector *data,
INT4 *myindex INT4 *myindex
); );
void LALI8FlipVector ( void LALI8FlipVector (
LALStatus *status, LALStatus *status,
INT8Vector **result, INT8Vector **result,
INT8Vector *data INT8Vector *data
); );
/** @} */ /*@}*/ /* end: MiscMatlab_c */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection */ #endif /* C++ protection */
#endif #endif
 End of changes. 17 change blocks. 
37 lines changed or deleted 233 lines changed or added


 MatrixUtils.h   MatrixUtils.h 
skipping to change at line 30 skipping to change at line 30
#ifndef _MATRIXUTILS_H #ifndef _MATRIXUTILS_H
#define _MATRIXUTILS_H #define _MATRIXUTILS_H
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
\author Creighton, T. D.
\addtogroup MatrixUtils_h \addtogroup MatrixUtils_h
\author Creighton, T. D.
\brief Provides routines to solve linear systems. \brief Provides routines to solve linear systems.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/MatrixUtils.h> #include <lal/MatrixUtils.h>
\endcode \endcode
This header covers routines to solve linear systems of equations and This header covers routines to solve linear systems of equations and
eigensystems, using algorithms adapted from Chapters~2 and~11 of eigensystems, using algorithms adapted from Chapters~2 and~11 of
skipping to change at line 97 skipping to change at line 97
\heading{Properties} \heading{Properties}
The basic matrix operations are addition, scalar multiplication, and The basic matrix operations are addition, scalar multiplication, and
vector multiplication. We assume the reader is familiar with these. vector multiplication. We assume the reader is familiar with these.
In addition, we will refer to the following unary operations on In addition, we will refer to the following unary operations on
\e square matrices: \e square matrices:
\e Inversion: The inverse \f$(\mathsf{A}^{-1}){}^a{}_b\f$ of a \e Inversion: The inverse \f$(\mathsf{A}^{-1}){}^a{}_b\f$ of a
matrix \f$\mathsf{A}^a{}_b\f$ is one such that their matrix product is the matrix \f$\mathsf{A}^a{}_b\f$ is one such that their matrix product is the
identity matrix \f$\bd^a{}_b\f$ (whose elements \f$\delta^i{}_j\f$ are just identity matrix \f$\delta^a{}_b\f$ (whose elements \f$\delta^i{}_j\f$ are j ust
the Kronecker delta function). the Kronecker delta function).
\e Transposition: The transpose \f$(\mathsf{A}^T){}^a{}_b\f$ of a \e Transposition: The transpose \f$(\mathsf{A}^T){}^a{}_b\f$ of a
matrix \f$\mathsf{A}^a{}_b\f$ is given by interchanging the indecies on matrix \f$\mathsf{A}^a{}_b\f$ is given by interchanging the indecies on
each component: \f$(A^T){}^i{}_j=A^j{}_i\f$. each component: \f$(A^T){}^i{}_j=A^j{}_i\f$.
\e Conjugation: The Hermitian conjugate (adjoint) \e Conjugation: The Hermitian conjugate (adjoint)
\f$(\mathsf{A}^\dag){}^a{}_b\f$ of a matrix \f$\mathsf{A}^a{}_b\f$ is given by \f$(\mathsf{A}^\dag){}^a{}_b\f$ of a matrix \f$\mathsf{A}^a{}_b\f$ is given by
interchanging the indecies and taking the complex conjugate of each interchanging the indecies and taking the complex conjugate of each
component: \f$(A^\dag){}^i{}_j={A^j{}_i}^*\f$. component: \f$(A^\dag){}^i{}_j={A^j{}_i}^*\f$.
skipping to change at line 122 skipping to change at line 122
is identical to its own Hermitian conjugate is called \e Hermitian is identical to its own Hermitian conjugate is called \e Hermitian
(or <em>self-adjoint</em>. A matrix whose Hermitian conjugate is (or <em>self-adjoint</em>. A matrix whose Hermitian conjugate is
identical to the original matrix's inverse is called \e unitary. identical to the original matrix's inverse is called \e unitary.
At present, the routines under this header only deal with \e real At present, the routines under this header only deal with \e real
matrices (i.e.\ matrices, vectors, and scalars whose components are matrices (i.e.\ matrices, vectors, and scalars whose components are
all real). In this case, symmetric is equivalent to Hermitian, and all real). In this case, symmetric is equivalent to Hermitian, and
orthogonal is equivalent to unitary. orthogonal is equivalent to unitary.
*/ */
/* @{ */ /*@{*/
/** \name Error Codes */ /** \name Error Codes */
/*@{*/ /*@{*/
#define MATRIXUTILSH_ENUL 1 /**< Unexpected null pointer in argu ments */ #define MATRIXUTILSH_ENUL 1 /**< Unexpected null pointer in argu ments */
#define MATRIXUTILSH_EDIM 2 /**< Bad matrix dimensions */ #define MATRIXUTILSH_EDIM 2 /**< Bad matrix dimensions */
#define MATRIXUTILSH_EITER 3 /**< Did not converge after maximum iterations */ #define MATRIXUTILSH_EITER 3 /**< Did not converge after maximum iterations */
#define MATRIXUTILSH_ESING 4 /**< Singular matrix */ #define MATRIXUTILSH_ESING 4 /**< Singular matrix */
#define MATRIXUTILSH_EMEM 5 /**< Memory allocation error */ #define MATRIXUTILSH_EMEM 5 /**< Memory allocation error */
/*@}*/ /*@}*/
/*@}*/ /*@}*/
#define MATRIXUTILSH_MSGENUL "Unexpected null pointer in arguments" #define MATRIXUTILSH_MSGENUL "Unexpected null pointer in arguments"
#define MATRIXUTILSH_MSGEDIM "Bad matrix dimensions" #define MATRIXUTILSH_MSGEDIM "Bad matrix dimensions"
#define MATRIXUTILSH_MSGEITER "Did not converge after maximum iterations" #define MATRIXUTILSH_MSGEITER "Did not converge after maximum iterations"
#define MATRIXUTILSH_MSGESING "Singular matrix" #define MATRIXUTILSH_MSGESING "Singular matrix"
#define MATRIXUTILSH_MSGEMEM "Memory allocation error" #define MATRIXUTILSH_MSGEMEM "Memory allocation error"
/* Function prototypes. */ /* ---------- Function prototypes. ---------- */
/** \addtogroup MatrixOps_c */
/*@{*/
void void
LALI2MatrixAdd( LALStatus *, INT2Array *out, INT2Array *in1, INT2Array *in2 ); LALI2MatrixAdd( LALStatus *, INT2Array *out, INT2Array *in1, INT2Array *in2 );
void void
LALI4MatrixAdd( LALStatus *, INT4Array *out, INT4Array *in1, INT4Array *in2 ); LALI4MatrixAdd( LALStatus *, INT4Array *out, INT4Array *in1, INT4Array *in2 );
void void
LALI8MatrixAdd( LALStatus *, INT8Array *out, INT8Array *in1, INT8Array *in2 ); LALI8MatrixAdd( LALStatus *, INT8Array *out, INT8Array *in1, INT8Array *in2 );
void void
LALU2MatrixAdd( LALStatus *, UINT2Array *out, UINT2Array *in1, UINT2Array * in2 ); LALU2MatrixAdd( LALStatus *, UINT2Array *out, UINT2Array *in1, UINT2Array * in2 );
void void
LALU4MatrixAdd( LALStatus *, UINT4Array *out, UINT4Array *in1, UINT4Array * in2 ); LALU4MatrixAdd( LALStatus *, UINT4Array *out, UINT4Array *in1, UINT4Array * in2 );
skipping to change at line 209 skipping to change at line 211
LALDMatrixTranspose( LALStatus *, REAL8Array *out, REAL8Array *in1 ); LALDMatrixTranspose( LALStatus *, REAL8Array *out, REAL8Array *in1 );
void void
LALCMatrixTranspose( LALStatus *, COMPLEX8Array *out, COMPLEX8Array *in1 ); LALCMatrixTranspose( LALStatus *, COMPLEX8Array *out, COMPLEX8Array *in1 );
void void
LALZMatrixTranspose( LALStatus *, COMPLEX16Array *out, COMPLEX16Array *in1 ); LALZMatrixTranspose( LALStatus *, COMPLEX16Array *out, COMPLEX16Array *in1 );
void void
LALCMatrixAdjoint( LALStatus *, COMPLEX8Array *out, COMPLEX8Array *in1 ); LALCMatrixAdjoint( LALStatus *, COMPLEX8Array *out, COMPLEX8Array *in1 );
void void
LALZMatrixAdjoint( LALStatus *, COMPLEX16Array *out, COMPLEX16Array *in1 ); LALZMatrixAdjoint( LALStatus *, COMPLEX16Array *out, COMPLEX16Array *in1 );
/*@}*/
void void
LALSMatrixDeterminant( LALStatus *, REAL4 *det, REAL4Array *matrix ); LALSMatrixDeterminant( LALStatus *, REAL4 *det, REAL4Array *matrix );
void void
LALSMatrixInverse( LALStatus *, REAL4 *det, REAL4Array *matrix, REAL4Array *inverse ); LALSMatrixInverse( LALStatus *, REAL4 *det, REAL4Array *matrix, REAL4Array *inverse );
void void
LALSMatrixDeterminantErr( LALStatus *, REAL4 det[2], REAL4Array *matrix, RE AL4Array *matrixErr ); LALSMatrixDeterminantErr( LALStatus *, REAL4 det[2], REAL4Array *matrix, RE AL4Array *matrixErr );
 End of changes. 6 change blocks. 
4 lines changed or deleted 7 lines changed or added


 ODE.h   ODE.h 
skipping to change at line 37 skipping to change at line 37
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /**
* \author J. D. E. Creighton
* \addtogroup ODE_h * \addtogroup ODE_h
* \author J. D. E. Creighton
* *
* \brief Routines for solving ordinary differential equations (ODEs). * \brief Routines for solving ordinary differential equations (ODEs).
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/ODE.h> * #include <lal/ODE.h>
* \endcode * \endcode
* *
* These routines solve ordinary differential equations (ODEs) of the form: * These routines solve ordinary differential equations (ODEs) of the form:
* \f[ * \f[
skipping to change at line 98 skipping to change at line 98
void ( *ode )( LALStatus *, REAL4Vector *, REAL4Vector *, REAL4ODEIndep * ); /**< Pointer to the function that computes the RHS of the ODE */ void ( *ode )( LALStatus *, REAL4Vector *, REAL4Vector *, REAL4ODEIndep * ); /**< Pointer to the function that computes the RHS of the ODE */
REAL4ODEIndep *indep; /**< The independent variables of used by th is function */ REAL4ODEIndep *indep; /**< The independent variables of used by th is function */
REAL4 tstep; /**< The suggested time step to use */ REAL4 tstep; /**< The suggested time step to use */
REAL4Vector *xdot; /**< The value of the LHS of the ODE at the current time */ REAL4Vector *xdot; /**< The value of the LHS of the ODE at the current time */
REAL4Vector *xerr; /**< The estimated errors from the last ODE step */ REAL4Vector *xerr; /**< The estimated errors from the last ODE step */
REAL4 eps; /**< The allowed fractional error per step; if \c eps is \< \c LAL_REAL4_EPS, then the latter is used */ REAL4 eps; /**< The allowed fractional error per step; if \c eps is \< \c LAL_REAL4_EPS, then the latter is used */
REAL4VectorSequence *dx; /**< Workspace storage for use in the the st ep integrator; the length of the sequence depends on which integrator is us ed */ REAL4VectorSequence *dx; /**< Workspace storage for use in the the st ep integrator; the length of the sequence depends on which integrator is us ed */
} }
REAL4ODEParams; REAL4ODEParams;
/** \see See ODE_h for documentation */ /** See ODE_h for documentation */
void LALSRungeKutta4( void LALSRungeKutta4(
LALStatus *status, LALStatus *status,
REAL4Vector *output, REAL4Vector *output,
REAL4Vector *input, REAL4Vector *input,
REAL4ODEParams *params REAL4ODEParams *params
); );
/** \see See ODE_h for documentation */ /** See ODE_h for documentation */
void LALSRungeKutta5( void LALSRungeKutta5(
LALStatus *status, LALStatus *status,
REAL4Vector *output, REAL4Vector *output,
REAL4Vector *input, REAL4Vector *input,
REAL4ODEParams *params REAL4ODEParams *params
); );
/** \see See ODE_h for documentation */ /** See ODE_h for documentation */
void LALSRungeKutta5Adapt( void LALSRungeKutta5Adapt(
LALStatus *status, LALStatus *status,
REAL4Vector *output, REAL4Vector *output,
REAL4Vector *input, REAL4Vector *input,
REAL4ODEParams *params REAL4ODEParams *params
); );
/*@}*/ /*@}*/
#if 0 #if 0
 End of changes. 5 change blocks. 
4 lines changed or deleted 4 lines changed or added


 Random.h   Random.h 
skipping to change at line 36 skipping to change at line 36
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/AVFactories.h> #include <lal/AVFactories.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
* \author Creighton, J. D. E. and Tibbits, M. M.
* \addtogroup Random_h * \addtogroup Random_h
* \author Creighton, J. D. E. and Tibbits, M. M.
* *
* \brief Generates random numbers. * \brief Generates random numbers.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/Random.h> * #include <lal/Random.h>
* \endcode * \endcode
* *
* This header covers the routines for generating random numbers. * This header covers the routines for generating random numbers.
* *
skipping to change at line 64 skipping to change at line 64
#define RANDOMH_ENNUL 2 /**< Non-null pointer */ #define RANDOMH_ENNUL 2 /**< Non-null pointer */
#define RANDOMH_ESIZE 4 /**< Invalid size */ #define RANDOMH_ESIZE 4 /**< Invalid size */
#define RANDOMH_ELNTH 8 /**< Must have more than one data po int */ #define RANDOMH_ELNTH 8 /**< Must have more than one data po int */
#define RANDOMH_ESEGZ 16 /**< Invalid number of segments */ #define RANDOMH_ESEGZ 16 /**< Invalid number of segments */
#define RANDOMH_ENUMZ 32 /**< Invalid number of points in seg ment */ #define RANDOMH_ENUMZ 32 /**< Invalid number of points in seg ment */
#define RANDOMH_EALOC 64 /**< Memory Allocation Error */ #define RANDOMH_EALOC 64 /**< Memory Allocation Error */
#define RANDOMH_EINIT 128 /**< Params must be initialized with CreateParams first */ #define RANDOMH_EINIT 128 /**< Params must be initialized with CreateParams first */
#define RANDOMH_EZERO 256 /**< Output Vector length must be gr eater than zero */ #define RANDOMH_EZERO 256 /**< Output Vector length must be gr eater than zero */
#define RANDOMH_ESEED 512 /**< Improper seed value */ #define RANDOMH_ESEED 512 /**< Improper seed value */
/*@}*/ /*@}*/
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */
#define RANDOMH_MSGENULL "Null pointer" #define RANDOMH_MSGENULL "Null pointer"
#define RANDOMH_MSGENNUL "Non-null pointer" #define RANDOMH_MSGENNUL "Non-null pointer"
#define RANDOMH_MSGESIZE "Invalid size" #define RANDOMH_MSGESIZE "Invalid size"
#define RANDOMH_MSGELNTH "Must have more than one data point" #define RANDOMH_MSGELNTH "Must have more than one data point"
#define RANDOMH_MSGESEGZ "Invalid number of segments" #define RANDOMH_MSGESEGZ "Invalid number of segments"
#define RANDOMH_MSGENUMZ "Invalid number of points in segment" #define RANDOMH_MSGENUMZ "Invalid number of points in segment"
#define RANDOMH_MSGEALOC "Memory Allocation Error" #define RANDOMH_MSGEALOC "Memory Allocation Error"
#define RANDOMH_MSGEINIT "Params must be initialized with CreateParams firs t" #define RANDOMH_MSGEINIT "Params must be initialized with CreateParams firs t"
#define RANDOMH_MSGEZERO "Output Vector length must be greater than zero" #define RANDOMH_MSGEZERO "Output Vector length must be greater than zero"
#define RANDOMH_MSGESEED "Improper seed value" #define RANDOMH_MSGESEED "Improper seed value"
/** \endcond */
/** \ingroup Random_h /** \ingroup Random_h
* \brief This structure contains the parameters necessary for generating t he current * \brief This structure contains the parameters necessary for generating t he current
* sequence of random numbers (based on the initial seed). * sequence of random numbers (based on the initial seed).
* \note The contents should not be manually adjusted. * \note The contents should not be manually adjusted.
*/ */
typedef struct typedef struct
tagRandomParams tagRandomParams
{ {
SWIGLAL_STRUCT(RandomParams); SWIGLAL_STRUCT(RandomParams);
 End of changes. 5 change blocks. 
1 lines changed or deleted 4 lines changed or added


 RealFFT.h   RealFFT.h 
skipping to change at line 41 skipping to change at line 41
#ifdef __cplusplus #ifdef __cplusplus
#ifdef __GNUC__ #ifdef __GNUC__
#define RESTRICT __restrict__ #define RESTRICT __restrict__
#else #else
#define RESTRICT #define RESTRICT
#endif #endif
#else #else
#define RESTRICT restrict #define RESTRICT restrict
#endif #endif
/** Plan to perform FFT of REAL4 data */
typedef struct tagREAL4FFTPlan REAL4FFTPlan;
/** Plan to perform FFT of REAL8 data */
typedef struct tagREAL8FFTPlan REAL8FFTPlan;
#define tagRealFFTPlan tagREAL4FFTPlan
#define RealFFTPlan REAL4FFTPlan
/** /**
* *
* \addtogroup RealFFT_h * \addtogroup RealFFT_h
* \brief Performs real-to-complex and complex-to-real FFTs. * \brief Performs real-to-complex and complex-to-real FFTs.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/RealFFT.h> * #include <lal/RealFFT.h>
* \endcode * \endcode
* *
skipping to change at line 98 skipping to change at line 91
* \endcode * \endcode
* *
* \heading{Description} * \heading{Description}
* *
* The \c REAL4 routines are described below. These use single-precision * The \c REAL4 routines are described below. These use single-precision
* FFTs, i.e., they convert \c REAL4Vectors into \c COMPLEX8Vectors * FFTs, i.e., they convert \c REAL4Vectors into \c COMPLEX8Vectors
* and vice-versa. The \c REAL8 versions of the routines are the same * and vice-versa. The \c REAL8 versions of the routines are the same
* but they are double-precision versions, i.e., they convert * but they are double-precision versions, i.e., they convert
* \c REAL8Vectors into \c COMPLEX16Vectors. * \c REAL8Vectors into \c COMPLEX16Vectors.
* *
* The routine XLALCreateREAL4FFTPlan() creates a ::REAL4FFTPlan * The routine XLALCreateREAL4FFTPlan() creates a REAL4FFTPlan
* structure to perform FFTs of vectors of length \c size. If * structure to perform FFTs of vectors of length \c size. If
* \c fwdflg is non-zero then the plan is created to perform forward * \c fwdflg is non-zero then the plan is created to perform forward
* (real-to-complex) FFTs with a negative exponential sign. Otherwise * (real-to-complex) FFTs with a negative exponential sign. Otherwise
* the plan is created to perform reverse (complex-to-real) FFTs with a * the plan is created to perform reverse (complex-to-real) FFTs with a
* positive exponential sign. The value of \c measurelvl determines * positive exponential sign. The value of \c measurelvl determines
* how much optimization of the plan FFTW will do with the most optimizatio n * how much optimization of the plan FFTW will do with the most optimizatio n
* taking the most amount of time. Reasonable values for \c measurelvl * taking the most amount of time. Reasonable values for \c measurelvl
* would be 0 for the fasted plan creation (FFTW does not measure the speed * would be 0 for the fasted plan creation (FFTW does not measure the speed
* of any transform with this level but rather estimates which plan will * of any transform with this level but rather estimates which plan will
* be the fastet) or 1 to measure a few likely plans to determine the faste st. * be the fastet) or 1 to measure a few likely plans to determine the faste st.
skipping to change at line 173 skipping to change at line 166
* for XLALREAL4VectorFFT(), * for XLALREAL4VectorFFT(),
* #XLAL_EBADLEN if the input and output vectors and the plan have * #XLAL_EBADLEN if the input and output vectors and the plan have
* incompatible lengths, * incompatible lengths,
* #XLAL_ENOMEM if a memory allocation of temporary internal memory * #XLAL_ENOMEM if a memory allocation of temporary internal memory
* fails. * fails.
* *
* As before, the \c REAL8 versions of these routines behave the * As before, the \c REAL8 versions of these routines behave the
* same way but for double-precision transforms. * same way but for double-precision transforms.
* *
*/ */
/*@{ */ /*@{*/
/** \name Error Codes */ /*@{*/
/** Plan to perform FFT of REAL4 data */
typedef struct tagREAL4FFTPlan REAL4FFTPlan;
/** Plan to perform FFT of REAL8 data */
typedef struct tagREAL8FFTPlan REAL8FFTPlan;
#define tagRealFFTPlan tagREAL4FFTPlan
#define RealFFTPlan REAL4FFTPlan
/** \name Error Codes */
/*@{*/
#define REALFFTH_ENULL 1 /**< Null pointer */ #define REALFFTH_ENULL 1 /**< Null pointer */
#define REALFFTH_ENNUL 2 /**< Non-null pointer */ #define REALFFTH_ENNUL 2 /**< Non-null pointer */
#define REALFFTH_ESIZE 4 /**< Invalid input size */ #define REALFFTH_ESIZE 4 /**< Invalid input size */
#define REALFFTH_ESZMM 8 /**< Size mismatch */ #define REALFFTH_ESZMM 8 /**< Size mismatch */
#define REALFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */ #define REALFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */
#define REALFFTH_ESAME 32 /**< Input/Output data vectors are the same */ #define REALFFTH_ESAME 32 /**< Input/Output data vectors are the same */
#define REALFFTH_ESIGN 64 /**< Incorrect plan sign */ #define REALFFTH_ESIGN 64 /**< Incorrect plan sign */
#define REALFFTH_EDATA 128 /**< Bad input data: DC/Nyquist should be re al */ #define REALFFTH_EDATA 128 /**< Bad input data: DC/Nyquist should be re al */
#define REALFFTH_EALOC 256 /**< Memory allocation failed */ #define REALFFTH_EALOC 256 /**< Memory allocation failed */
#define REALFFTH_EFFTW 512 /**< Error in FFTW */ #define REALFFTH_EFFTW 512 /**< Error in FFTW */
#define REALFFTH_ESNGL 1024 /**< FFTW library is not single-precision */ #define REALFFTH_ESNGL 1024 /**< FFTW library is not single-precision */
#define REALFFTH_EINTL 2048 /**< Error in Intel FFT library */ #define REALFFTH_EINTL 2048 /**< Error in Intel FFT library */
/*@}*/ /*@}*/
/*@}*/
/** \cond DONT_DOXYGEN */
#define REALFFTH_MSGENULL "Null pointer" #define REALFFTH_MSGENULL "Null pointer"
#define REALFFTH_MSGENNUL "Non-null pointer" #define REALFFTH_MSGENNUL "Non-null pointer"
#define REALFFTH_MSGESIZE "Invalid input size" #define REALFFTH_MSGESIZE "Invalid input size"
#define REALFFTH_MSGESZMM "Size mismatch" #define REALFFTH_MSGESZMM "Size mismatch"
#define REALFFTH_MSGESLEN "Invalid/mismatched sequence lengths" #define REALFFTH_MSGESLEN "Invalid/mismatched sequence lengths"
#define REALFFTH_MSGESAME "Input/Output data vectors are the same" #define REALFFTH_MSGESAME "Input/Output data vectors are the same"
#define REALFFTH_MSGESIGN "Incorrect plan sign" #define REALFFTH_MSGESIGN "Incorrect plan sign"
#define REALFFTH_MSGEDATA "Bad input data: DC/Nyquist should be real" #define REALFFTH_MSGEDATA "Bad input data: DC/Nyquist should be real"
#define REALFFTH_MSGEALOC "Memory allocation failed" #define REALFFTH_MSGEALOC "Memory allocation failed"
#define REALFFTH_MSGEFFTW "Error in FFTW" #define REALFFTH_MSGEFFTW "Error in FFTW"
#define REALFFTH_MSGESNGL "FFTW library is not single-precision" #define REALFFTH_MSGESNGL "FFTW library is not single-precision"
#define REALFFTH_MSGEINTL "Error in Intel FFT library" #define REALFFTH_MSGEINTL "Error in Intel FFT library"
/** \endcond */
/** \addtogroup RealFFT_h */
/*@{ */
/* /*
* *
* XLAL REAL4 functions * XLAL REAL4 functions
* *
*/ */
/** Returns a new REAL4FFTPlan /** Returns a new REAL4FFTPlan
* *
* A REAL4FFTPlan is required to perform a FFT that involves real data. * A REAL4FFTPlan is required to perform a FFT that involves real data.
skipping to change at line 226 skipping to change at line 226
* and for each direction of transform (forward or reverse). * and for each direction of transform (forward or reverse).
* A forward transform performs * A forward transform performs
* \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f] * \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f]
* where N, the size of the transform, is the length of the vector x. * where N, the size of the transform, is the length of the vector x.
* A reverse transform performs * A reverse transform performs
* \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f] * \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f]
* where N, the size of the transform, is the length of the vector y. * where N, the size of the transform, is the length of the vector y.
* *
* @note * @note
* The reverse transform of the forward transform of some data is * The reverse transform of the forward transform of some data is
* equal to N times the original data (we therefore call it a "reverse" * equal to N times the original data (we therefore call it a \"reverse\"
* transform rather than an "inverse" transform). * transform rather than an \"inverse\" transform).
* *
* @param[in] size The number of points in the real data. * @param[in] size The number of points in the real data.
* @param[in] fwdflg Set non-zero for a forward FFT plan; * @param[in] fwdflg Set non-zero for a forward FFT plan;
* otherwise create a reverse plan * otherwise create a reverse plan
* @param[in] measurelvl Measurement level for plan creation: * @param[in] measurelvl Measurement level for plan creation:
* - 0: no measurement, just estimate the plan; * - 0: no measurement, just estimate the plan;
* - 1: measure the best plan; * - 1: measure the best plan;
* - 2: perform a lengthy measurement of the best plan ; * - 2: perform a lengthy measurement of the best plan ;
* - 3: perform an exhasutive measurement of the best plan. * - 3: perform an exhasutive measurement of the best plan.
* @return A pointer to an allocated \c REAL4FFTPlan structure is returned * @return A pointer to an allocated \c REAL4FFTPlan structure is returned
skipping to change at line 284 skipping to change at line 284
/** Returns a new REAL4FFTPlan for a reverse transform /** Returns a new REAL4FFTPlan for a reverse transform
* *
* A REAL4FFTPlan is required to perform a FFT that involves real data. * A REAL4FFTPlan is required to perform a FFT that involves real data.
* A reverse transform performs * A reverse transform performs
* \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f] * \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f]
* where N, the size of the transform, is the length of the vector y. * where N, the size of the transform, is the length of the vector y.
* *
* @note * @note
* The reverse transform of the forward transform of some data is * The reverse transform of the forward transform of some data is
* equal to N times the original data (we therefore call it a "reverse" * equal to N times the original data (we therefore call it a \"reverse\"
* transform rather than an "inverse" transform). * transform rather than an \"inverse\" transform).
* *
* @param[in] size The number of points in the real data. * @param[in] size The number of points in the real data.
* @param[in] measurelvl Measurement level for plan creation: * @param[in] measurelvl Measurement level for plan creation:
* - 0: no measurement, just estimate the plan; * - 0: no measurement, just estimate the plan;
* - 1: measure the best plan; * - 1: measure the best plan;
* - 2: perform a lengthy measurement of the best plan ; * - 2: perform a lengthy measurement of the best plan ;
* - 3: perform an exhasutive measurement of the best plan. * - 3: perform an exhasutive measurement of the best plan.
* @return A pointer to an allocated \c REAL4FFTPlan structure is returned * @return A pointer to an allocated \c REAL4FFTPlan structure is returned
* upon successful completion. Otherwise, a \c NULL pointer is returned * upon successful completion. Otherwise, a \c NULL pointer is returned
* and \c xlalErrno is set to indicate the error. * and \c xlalErrno is set to indicate the error.
skipping to change at line 321 skipping to change at line 321
/** Performs a forward FFT of REAL4 data /** Performs a forward FFT of REAL4 data
* *
* This routine performs the transformation: * This routine performs the transformation:
* \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f] * \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f]
* where N, the size of the transform, is the length of the vector x. * where N, the size of the transform, is the length of the vector x.
* *
* @note * @note
* Due to the reality of the input data x, the following identity * Due to the reality of the input data x, the following identity
* holds for the complex FFT data: \f$z[N-k]=z^\ast[k]\f$. Therefore, * holds for the complex FFT data: \f$z[N-k]=z^\ast[k]\f$. Therefore,
* the length of the output vector is equal to \f$\lfloor N/2\rfloor + 1\f$ * the length of the output vector is equal to \f$\lfloor N/2\rfloor + 1\f$
* since the remaining "negative" frequency components can be obtained from * since the remaining \"negative\" frequency components can be obtained fr
the om the
* "positive" frequency components. * \"positive\" frequency components.
* *
* @param[out] output The complex data vector z of length [N/2] + 1 * @param[out] output The complex data vector z of length [N/2] + 1
* that results from the transform * that results from the transform
* @param[in] input The real data vector x of length to be transformed * @param[in] input The real data vector x of length to be transformed
* @param[in] plan The FFT plan to use for the transform * @param[in] plan The FFT plan to use for the transform
* @return 0 upon successful completion or non-zero upon failure. * @return 0 upon successful completion or non-zero upon failure.
* @par Errors: * @par Errors:
* The \c XLALREAL4ForwardFFT() function shall fail if: * The \c XLALREAL4ForwardFFT() function shall fail if:
* - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s. * - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s.
* - [\c XLAL_EINVAL] A argument is invalid or the plan is for a * - [\c XLAL_EINVAL] A argument is invalid or the plan is for a
skipping to change at line 352 skipping to change at line 352
/** Performs a reverse FFT of REAL4 data /** Performs a reverse FFT of REAL4 data
* *
* This routine performs the transformation: * This routine performs the transformation:
* \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f] * \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f]
* where N, the size of the transform, is the length of the vector y. * where N, the size of the transform, is the length of the vector y.
* *
* @note * @note
* Due to the reality of the output data y, the following identity * Due to the reality of the output data y, the following identity
* holds for the complex data: \f$z[N-k]=z^\ast[k]\f$. Therefore, * holds for the complex data: \f$z[N-k]=z^\ast[k]\f$. Therefore,
* the length of the input vector is equal to \f$\lfloor N/2\rfloor + 1\f$ * the length of the input vector is equal to \f$\lfloor N/2\rfloor + 1\f$
* since the remaining "negative" frequency components can be obtained from * since the remaining \"negative\" frequency components can be obtained fr
the om the
* "positive" frequency components. * \"positive\" frequency components.
* *
* @param[out] output The real data vector y of length N * @param[out] output The real data vector y of length N
* that results from the transform * that results from the transform
* @param[in] input The complex data vector z of length [N/2] + 1 * @param[in] input The complex data vector z of length [N/2] + 1
* to be transformed * to be transformed
* @param[in] plan The FFT plan to use for the transform * @param[in] plan The FFT plan to use for the transform
* @return 0 upon successful completion or non-zero upon failure. * @return 0 upon successful completion or non-zero upon failure.
* @par Errors: * @par Errors:
* The \c XLALREAL4ForwardFFT() function shall fail if: * The \c XLALREAL4ForwardFFT() function shall fail if:
* - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s. * - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s.
skipping to change at line 450 skipping to change at line 450
* and for each direction of transform (forward or reverse). * and for each direction of transform (forward or reverse).
* A forward transform performs * A forward transform performs
* \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f] * \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f]
* where N, the size of the transform, is the length of the vector x. * where N, the size of the transform, is the length of the vector x.
* A reverse transform performs * A reverse transform performs
* \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f] * \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f]
* where N, the size of the transform, is the length of the vector y. * where N, the size of the transform, is the length of the vector y.
* *
* @note * @note
* The reverse transform of the forward transform of some data is * The reverse transform of the forward transform of some data is
* equal to N times the original data (we therefore call it a "reverse" * equal to N times the original data (we therefore call it a \"reverse\"
* transform rather than an "inverse" transform). * transform rather than an \"inverse\" transform).
* *
* @param[in] size The number of points in the real data. * @param[in] size The number of points in the real data.
* @param[in] fwdflg Set non-zero for a forward FFT plan; * @param[in] fwdflg Set non-zero for a forward FFT plan;
* otherwise create a reverse plan * otherwise create a reverse plan
* @param[in] measurelvl Measurement level for plan creation: * @param[in] measurelvl Measurement level for plan creation:
* - 0: no measurement, just estimate the plan; * - 0: no measurement, just estimate the plan;
* - 1: measure the best plan; * - 1: measure the best plan;
* - 2: perform a lengthy measurement of the best plan ; * - 2: perform a lengthy measurement of the best plan ;
* - 3: perform an exhasutive measurement of the best plan. * - 3: perform an exhasutive measurement of the best plan.
* @return A pointer to an allocated \c REAL8FFTPlan structure is returned * @return A pointer to an allocated \c REAL8FFTPlan structure is returned
skipping to change at line 508 skipping to change at line 508
/** Returns a new REAL8FFTPlan for a reverse transform /** Returns a new REAL8FFTPlan for a reverse transform
* *
* A REAL8FFTPlan is required to perform a FFT that involves real data. * A REAL8FFTPlan is required to perform a FFT that involves real data.
* A reverse transform performs * A reverse transform performs
* \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f] * \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f]
* where N, the size of the transform, is the length of the vector y. * where N, the size of the transform, is the length of the vector y.
* *
* @note * @note
* The reverse transform of the forward transform of some data is * The reverse transform of the forward transform of some data is
* equal to N times the original data (we therefore call it a "reverse" * equal to N times the original data (we therefore call it a \"reverse\"
* transform rather than an "inverse" transform). * transform rather than an \"inverse\" transform).
* *
* @param[in] size The number of points in the real data. * @param[in] size The number of points in the real data.
* @param[in] measurelvl Measurement level for plan creation: * @param[in] measurelvl Measurement level for plan creation:
* - 0: no measurement, just estimate the plan; * - 0: no measurement, just estimate the plan;
* - 1: measure the best plan; * - 1: measure the best plan;
* - 2: perform a lengthy measurement of the best plan ; * - 2: perform a lengthy measurement of the best plan ;
* - 3: perform an exhasutive measurement of the best plan. * - 3: perform an exhasutive measurement of the best plan.
* @return A pointer to an allocated \c REAL8FFTPlan structure is returned * @return A pointer to an allocated \c REAL8FFTPlan structure is returned
* upon successful completion. Otherwise, a \c NULL pointer is returned * upon successful completion. Otherwise, a \c NULL pointer is returned
* and \c xlalErrno is set to indicate the error. * and \c xlalErrno is set to indicate the error.
skipping to change at line 545 skipping to change at line 545
/** Performs a forward FFT of REAL8 data /** Performs a forward FFT of REAL8 data
* *
* This routine performs the transformation: * This routine performs the transformation:
* \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f] * \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j]\f]
* where N, the size of the transform, is the length of the vector x. * where N, the size of the transform, is the length of the vector x.
* *
* @note * @note
* Due to the reality of the input data x, the following identity * Due to the reality of the input data x, the following identity
* holds for the complex FFT data: \f$z[N-k]=z^\ast[k]\f$. Therefore, * holds for the complex FFT data: \f$z[N-k]=z^\ast[k]\f$. Therefore,
* the length of the output vector is equal to \f$\lfloor N/2\rfloor + 1\f$ * the length of the output vector is equal to \f$\lfloor N/2\rfloor + 1\f$
* since the remaining "negative" frequency components can be obtained from * since the remaining \"negative\" frequency components can be obtained fr
the om the
* "positive" frequency components. * \"positive\" frequency components.
* *
* @param[out] output The complex data vector z of length [N/2] + 1 * @param[out] output The complex data vector z of length [N/2] + 1
* that results from the transform * that results from the transform
* @param[in] input The real data vector x of length to be transformed * @param[in] input The real data vector x of length to be transformed
* @param[in] plan The FFT plan to use for the transform * @param[in] plan The FFT plan to use for the transform
* @return 0 upon successful completion or non-zero upon failure. * @return 0 upon successful completion or non-zero upon failure.
* @par Errors: * @par Errors:
* The \c XLALREAL8ForwardFFT() function shall fail if: * The \c XLALREAL8ForwardFFT() function shall fail if:
* - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s. * - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s.
* - [\c XLAL_EINVAL] A argument is invalid or the plan is for a * - [\c XLAL_EINVAL] A argument is invalid or the plan is for a
skipping to change at line 576 skipping to change at line 576
/** Performs a reverse FFT of REAL8 data /** Performs a reverse FFT of REAL8 data
* *
* This routine performs the transformation: * This routine performs the transformation:
* \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f] * \f[y[j] = \sum_{k=0}^{N-1} e^{+2\pi ijk/N}\,z[k]\f]
* where N, the size of the transform, is the length of the vector y. * where N, the size of the transform, is the length of the vector y.
* *
* @note * @note
* Due to the reality of the output data y, the following identity * Due to the reality of the output data y, the following identity
* holds for the complex data: \f$z[N-k]=z^\ast[k]\f$. Therefore, * holds for the complex data: \f$z[N-k]=z^\ast[k]\f$. Therefore,
* the length of the input vector is equal to \f$\lfloor N/2\rfloor + 1\f$ * the length of the input vector is equal to \f$\lfloor N/2\rfloor + 1\f$
* since the remaining "negative" frequency components can be obtained from * since the remaining \"negative\" frequency components can be obtained fr
the om the
* "positive" frequency components. * \"positive\" frequency components.
* *
* @param[out] output The real data vector y of length N * @param[out] output The real data vector y of length N
* that results from the transform * that results from the transform
* @param[in] input The complex data vector z of length [N/2] + 1 * @param[in] input The complex data vector z of length [N/2] + 1
* to be transformed * to be transformed
* @param[in] plan The FFT plan to use for the transform * @param[in] plan The FFT plan to use for the transform
* @return 0 upon successful completion or non-zero upon failure. * @return 0 upon successful completion or non-zero upon failure.
* @par Errors: * @par Errors:
* The \c XLALREAL8ForwardFFT() function shall fail if: * The \c XLALREAL8ForwardFFT() function shall fail if:
* - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s. * - [\c XLAL_EFAULT] A \c NULL pointer is provided as one of the argument s.
 End of changes. 14 change blocks. 
34 lines changed or deleted 34 lines changed or added


 ResampleTimeSeries.h   ResampleTimeSeries.h 
skipping to change at line 37 skipping to change at line 37
#ifndef _RESAMPLETIMESERIES_H #ifndef _RESAMPLETIMESERIES_H
#define _RESAMPLETIMESERIES_H #define _RESAMPLETIMESERIES_H
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /** \addtogroup ResampleTimeSeries_h
* \author Brown, D. A. * \author Brown, D. A.
* \addtogroup ResampleTimeSeries_h Header ResampleTimeSeries.h
* *
* \brief Provides routines to resample a time series. * \brief Provides routines to resample a time series.
* *
* At present only integer downsampling of ::REAL4TimeSeries by a power of two is supported. * At present only integer downsampling of ::REAL4TimeSeries by a power of two is supported.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/ResampleTimeSeries.h> * #include <lal/ResampleTimeSeries.h>
* \endcode * \endcode
* *
* This header covers routines that resample time series by applying * This header covers routines that resample time series by applying
* a low pass filter and decimating the resulting time series. Further * a low pass filter and decimating the resulting time series. Further
* documentation is given in the individual routines' modules. * documentation is given in the individual routines' modules.
* *
*/ */
/** @{ */ /*@{*/
/**\name Error Codes */ /*@{*/ /**\name Error Codes */
/*@{*/
#define RESAMPLETIMESERIESH_ENULL 1 /**< Null pointer */ #define RESAMPLETIMESERIESH_ENULL 1 /**< Null pointer */
#define RESAMPLETIMESERIESH_ENNUL 2 /**< Non-null pointer */ #define RESAMPLETIMESERIESH_ENNUL 2 /**< Non-null pointer */
#define RESAMPLETIMESERIESH_EZERO 3 /**< Length of input time series is zero */ #define RESAMPLETIMESERIESH_EZERO 3 /**< Length of input time series is zero */
#define RESAMPLETIMESERIESH_ERATE 4 /**< Sample rate is zero */ #define RESAMPLETIMESERIESH_ERATE 4 /**< Sample rate is zero */
#define RESAMPLETIMESERIESH_EUPSM 5 /**< Cannot upsample */ #define RESAMPLETIMESERIESH_EUPSM 5 /**< Cannot upsample */
#define RESAMPLETIMESERIESH_EHIGH 6 /**< Input sample rate is greater th an 32kHz */ #define RESAMPLETIMESERIESH_EHIGH 6 /**< Input sample rate is greater th an 32kHz */
#define RESAMPLETIMESERIESH_ELOG2 7 /**< Only power-of-two resampling is avaliable */ #define RESAMPLETIMESERIESH_ELOG2 7 /**< Only power-of-two resampling is avaliable */
#define RESAMPLETIMESERIESH_EFILT 8 /**< Unknown filter type */ #define RESAMPLETIMESERIESH_EFILT 8 /**< Unknown filter type */
#define RESAMPLETIMESERIESH_EINVD 9 /**< Invalid or non-integer resample factor */ #define RESAMPLETIMESERIESH_EINVD 9 /**< Invalid or non-integer resample factor */
#define RESAMPLETIMESERIESH_ELDAS 10 /**< Input resample factor with LDAS FIR */ #define RESAMPLETIMESERIESH_ELDAS 10 /**< Input resample factor with LDAS FIR */
/** @} */ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define RESAMPLETIMESERIESH_MSGENULL "Null pointer" #define RESAMPLETIMESERIESH_MSGENULL "Null pointer"
#define RESAMPLETIMESERIESH_MSGENNUL "Non-null pointer" #define RESAMPLETIMESERIESH_MSGENNUL "Non-null pointer"
#define RESAMPLETIMESERIESH_MSGEZERO "Length of input time series is zero" #define RESAMPLETIMESERIESH_MSGEZERO "Length of input time series is zero"
#define RESAMPLETIMESERIESH_MSGERATE "Sample rate is zero" #define RESAMPLETIMESERIESH_MSGERATE "Sample rate is zero"
#define RESAMPLETIMESERIESH_MSGEUPSM "Cannot upsample" #define RESAMPLETIMESERIESH_MSGEUPSM "Cannot upsample"
#define RESAMPLETIMESERIESH_MSGEHIGH "Input sample rate is greater than 32k Hz" #define RESAMPLETIMESERIESH_MSGEHIGH "Input sample rate is greater than 32k Hz"
#define RESAMPLETIMESERIESH_MSGELOG2 "Only power-of-two resampling is avali able" #define RESAMPLETIMESERIESH_MSGELOG2 "Only power-of-two resampling is avali able"
#define RESAMPLETIMESERIESH_MSGEFILT "Unknown filter type" #define RESAMPLETIMESERIESH_MSGEFILT "Unknown filter type"
skipping to change at line 130 skipping to change at line 130
typedef struct typedef struct
tagResampleTSParams tagResampleTSParams
{ {
SWIGLAL_STRUCT(ResampleTSParams); SWIGLAL_STRUCT(ResampleTSParams);
REAL8 deltaT; /**< The sample interval desired in the down sampled time series */ REAL8 deltaT; /**< The sample interval desired in the down sampled time series */
ResampleTSFilter filterType; /**< The type of filter with which t o perform the low pass filtering */ ResampleTSFilter filterType; /**< The type of filter with which t o perform the low pass filtering */
ResampleTSFilterParams filterParams; /**< Filter parameters for t he low pass filter (Presently ignored) */ ResampleTSFilterParams filterParams; /**< Filter parameters for t he low pass filter (Presently ignored) */
} }
ResampleTSParams; ResampleTSParams;
/** @} */ /*@}*/
/* ---------- Function prototypes ---------- */
int XLALResampleREAL4TimeSeries( REAL4TimeSeries *series, REAL8 dt ); int XLALResampleREAL4TimeSeries( REAL4TimeSeries *series, REAL8 dt );
int XLALResampleREAL8TimeSeries( REAL8TimeSeries *series, REAL8 dt ); int XLALResampleREAL8TimeSeries( REAL8TimeSeries *series, REAL8 dt );
void void
LALResampleREAL4TimeSeries( LALResampleREAL4TimeSeries(
LALStatus *status, LALStatus *status,
REAL4TimeSeries *ts, REAL4TimeSeries *ts,
ResampleTSParams *params ResampleTSParams *params
); );
 End of changes. 5 change blocks. 
7 lines changed or deleted 9 lines changed or added


 RngMedBias.h   RngMedBias.h 
skipping to change at line 48 skipping to change at line 48
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** /**
\author Krishnan, B., Itoh, Y.
\addtogroup RngMedBias_h \addtogroup RngMedBias_h
\author Krishnan, B., Itoh, Y.
\brief Routine for finding bias in median for exponential distribution \brief Routine for finding bias in median for exponential distribution
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/RngMedBias.h> #include <lal/RngMedBias.h>
\endcode \endcode
*/ */
/*@{*/ /*@{*/
/**\name Error Codes */ /**\name Error Codes */
/*@{*/ /*@{*/
#define RNGMEDBIASH_ENULL 1 /**< Null pointer */ #define RNGMEDBIASH_ENULL 1 /**< Null pointer */
#define RNGMEDBIASH_EVAL 5 /**< Invalid value */ #define RNGMEDBIASH_EVAL 5 /**< Invalid value */
/*@}*/ /*@}*/
/*@}*/ /** \cond DONT_DOXYGEN */
#define RNGMEDBIASH_MSGENULL "Null pointer" #define RNGMEDBIASH_MSGENULL "Null pointer"
#define RNGMEDBIASH_MSGEVAL "Invalid value" #define RNGMEDBIASH_MSGEVAL "Invalid value"
/** \endcond */
/* ****************************************************** /* ******************************************************
* 8. Macros. But, note that macros are deprecated. * 8. Macros. But, note that macros are deprecated.
* They could be moved to the modules where are needed * They could be moved to the modules where are needed
*/ */
/* ******************************************************* /* *******************************************************
* 9. Constant Declarations. (discouraged) * 9. Constant Declarations. (discouraged)
*/ */
skipping to change at line 98 skipping to change at line 99
/* /*
* 12. Functions Declarations (i.e., prototypes). * 12. Functions Declarations (i.e., prototypes).
*/ */
void LALRngMedBias (LALStatus *status, void LALRngMedBias (LALStatus *status,
REAL8 *biasFactor, REAL8 *biasFactor,
INT4 blkSize INT4 blkSize
); );
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} /* Close C++ protection */ } /* Close C++ protection */
#endif #endif
#endif /* Close double-include protection _RNGMEDBIAS_H */ #endif /* Close double-include protection _RNGMEDBIAS_H */
 End of changes. 5 change blocks. 
3 lines changed or deleted 6 lines changed or added


 Segments.h   Segments.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/** #ifndef _SEGMENTS_H
\author Peter Shawhan #define _SEGMENTS_H
\defgroup Segments_h Segments
\ingroup tools /* remove SWIG interface directives */
\brief Provides data types and functions for manipulating lists of ``segmen #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
ts'' (GPS time intervals). #define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h>
#include <lal/XLALError.h>
#if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
/** \addtogroup Segments_h
\author Peter Shawhan
\brief Provides data types and functions for manipulating lists of ``se
gments'' (GPS time intervals).
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/Segments.h> #include <lal/Segments.h>
\endcode \endcode
This header defines data structures for segments and lists of This header defines data structures for segments and lists of
segments, as well as prototypes for functions that manipulate them. segments, as well as prototypes for functions that manipulate them.
A segment is a time interval with a start time and an end time. The end ti me A segment is a time interval with a start time and an end time. The end ti me
skipping to change at line 121 skipping to change at line 137
represented by segments. The \c LALSegList structure includes fields represented by segments. The \c LALSegList structure includes fields
which record whether the segment list is sorted and/or disjoint, and these which record whether the segment list is sorted and/or disjoint, and these
are used to search the segment list more efficiently when possible. Note are used to search the segment list more efficiently when possible. Note
that a segment list could in principle be disjoint but not sorted, but that that a segment list could in principle be disjoint but not sorted, but that
case is not of interest for the code; the \c disjoint field in the case is not of interest for the code; the \c disjoint field in the
structure specifically means that the list is sorted \e and disjoint. structure specifically means that the list is sorted \e and disjoint.
Also all segments in a segment list can be time-shifted using \c XLALSegLis tShift(). Also all segments in a segment list can be time-shifted using \c XLALSegLis tShift().
*/ */
/*@{*/
#ifndef _SEGMENTS_H
#define _SEGMENTS_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h>
#include <lal/XLALError.h>
#if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
/*------------------- Compile-time parameters -------------------*/ /*------------------- Compile-time parameters -------------------*/
/** \ingroup Segments_h */ /*@{*/
#define SEGMENTSH_ALLOCBLOCK 64 /**< Initial number of LALSeg spaces to #define SEGMENTSH_ALLOCBLOCK 64 /**< Initial number of LALSeg spaces to
* allocate in memory at one time; this is * allocate in memory at one time; this is
* intended to reduce the number of memory * intended to reduce the number of memory
* reallocation calls needing to be made to * reallocation calls needing to be made to
* build up a segment list. For a large * build up a segment list. For a large
* segment list, the reallocation size * segment list, the reallocation size
* switches over to a multiplicative factor . * switches over to a multiplicative factor .
*/ */
#define SEGMENTSH_INITMAGICVAL 729415386 /**< Distinctive value set in the #define SEGMENTSH_INITMAGICVAL 729415386 /**< Distinctive value set in the
skipping to change at line 184 skipping to change at line 183
size_t arraySize; /**< Size of array for which memory is allocated */ size_t arraySize; /**< Size of array for which memory is allocated */
UINT4 length; /**< Number of segments in this segment list */ UINT4 length; /**< Number of segments in this segment list */
UINT4 dplaces; /**< Decimal places (0,3,6,9) to format GPS times */ UINT4 dplaces; /**< Decimal places (0,3,6,9) to format GPS times */
UINT4 sorted; /**< Flag to indicate whether segment list is sorted * / UINT4 sorted; /**< Flag to indicate whether segment list is sorted * /
UINT4 disjoint; /**< Flag to indicate whether segment list is disjoint */ UINT4 disjoint; /**< Flag to indicate whether segment list is disjoint */
UINT4 initMagic; /**< Internal value to help ensure list was initialize d */ UINT4 initMagic; /**< Internal value to help ensure list was initialize d */
LALSeg *lastFound; /**< Internal record of last segment found by a search */ LALSeg *lastFound; /**< Internal record of last segment found by a search */
} }
LALSegList; LALSegList;
/*@}*/
/*----------------------- Function prototypes ----------------------*/ /*----------------------- Function prototypes ----------------------*/
/** \cond DONT_DOXYGEN */
INT4 INT4
XLALSegSet( LALSeg *seg, const LIGOTimeGPS *start, const LIGOTimeGPS *end, XLALSegSet( LALSeg *seg, const LIGOTimeGPS *start, const LIGOTimeGPS *end,
const INT4 id ); const INT4 id );
LALSeg * LALSeg *
XLALSegCreate( const LIGOTimeGPS *start, const LIGOTimeGPS *end, XLALSegCreate( const LIGOTimeGPS *start, const LIGOTimeGPS *end,
const INT4 id ); const INT4 id );
int int
XLALGPSInSeg( const void *gps, const void *seg ); XLALGPSInSeg( const void *gps, const void *seg );
skipping to change at line 227 skipping to change at line 222
LALSeg * LALSeg *
XLALSegListSearch( LALSegList *seglist, const LIGOTimeGPS *gps ); XLALSegListSearch( LALSegList *seglist, const LIGOTimeGPS *gps );
INT4 INT4
XLALSegListShift( LALSegList *seglist, const LIGOTimeGPS *shift ); XLALSegListShift( LALSegList *seglist, const LIGOTimeGPS *shift );
INT4 INT4
XLALSegListKeep( LALSegList *seglist, const LIGOTimeGPS *start, const LIGO TimeGPS *end ); XLALSegListKeep( LALSegList *seglist, const LIGOTimeGPS *start, const LIGO TimeGPS *end );
/** \endcond */ /*@}*/
/*----------------------- Trailer stuff ----------------------------*/
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif /* C++ protection. */ #endif /* C++ protection. */
#endif /* Double-include protection. */ #endif /* Double-include protection. */
 End of changes. 6 change blocks. 
30 lines changed or deleted 24 lines changed or added


 SeqFactories.h   SeqFactories.h 
#ifndef _SEQFACTORIES_H
#define _SEQFACTORIES_H
/* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
#include <lal/LALDatatypes.h>
#include <lal/AVFactories.h>
#ifdef __cplusplus
extern "C" {
#endif
/** /**
\defgroup SeqFactories_h SeqFactories_h \addtogroup SeqFactories_h
\ingroup factories
\brief Provides prototype and status code information for use of CreateVect \brief Provides prototype and status code information for use of CreateVect
orSequence orSequence and DestroyVectorSequence.
and DestroyVectorSequence.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/SeqFactories.h> #include <lal/SeqFactories.h>
\endcode \endcode
\section sec_SF_XLALfcts XLAL Functions \section sec_SF_XLALfcts XLAL Functions
\code \code
REAL4VectorSequence * XLALCreateVectorSequence(UINT4 length, UINT4 veclen); REAL4VectorSequence * XLALCreateVectorSequence(UINT4 length, UINT4 veclen);
skipping to change at line 63 skipping to change at line 76
failed, or \c #XLAL_EBADLEN if the requested \c length or \c veclen failed, or \c #XLAL_EBADLEN if the requested \c length or \c veclen
is zero. is zero.
The destroy functions do not have a return value. They can fail if they ar e The destroy functions do not have a return value. They can fail if they ar e
passed a \c NULL pointer, in which case \c xlalErrno is set to passed a \c NULL pointer, in which case \c xlalErrno is set to
\c #XLAL_EFAULT, or if the vector sequency passed to the destroy routine \c #XLAL_EFAULT, or if the vector sequency passed to the destroy routine
has zero length, vector length, or \c NULL data pointer then has zero length, vector length, or \c NULL data pointer then
\c xlalErrno is set to \c #XLAL_EINVAL. \c xlalErrno is set to \c #XLAL_EINVAL.
*/ */
/*@{*/
#ifndef _SEQFACTORIES_H /**\name Error Codes */
#define _SEQFACTORIES_H /*@{*/
#define SEQFACTORIESH_ESLENGTH 1 /**< Illegal sequence length. */
/* remove SWIG interface directives */ #define SEQFACTORIESH_EVLENGTH 2 /**< Illegal vector length. */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #define SEQFACTORIESH_EALENGTH 4 /**< Illegal array dimension. */
#define SWIGLAL_STRUCT(...) #define SEQFACTORIESH_EVPTR 8 /**< Null sequence handle. */
#endif #define SEQFACTORIESH_EUPTR 16 /**< Non-null sequence pointer. */
#define SEQFACTORIESH_EDPTR 32 /**< Null sequence data. */
#include <lal/LALDatatypes.h> #define SEQFACTORIESH_EINPTR 64 /**< Null input pointer. */
#include <lal/AVFactories.h> #define SEQFACTORIESH_EMALLOC 128 /**< Malloc failure. */
/*@}*/
#ifdef __cplusplus
extern "C" {
#endif
/**\name Error Codes *//*@{*/
/** \ingroup SeqFactories_h */
#define SEQFACTORIESH_ESLENGTH 1
#define SEQFACTORIESH_EVLENGTH 2
#define SEQFACTORIESH_EALENGTH 4
#define SEQFACTORIESH_EVPTR 8
#define SEQFACTORIESH_EUPTR 16
#define SEQFACTORIESH_EDPTR 32
#define SEQFACTORIESH_EINPTR 64
#define SEQFACTORIESH_EMALLOC 128
/** \cond DONT_DOXYGEN */
#define SEQFACTORIESH_MSGESLENGTH "Illegal sequence length." #define SEQFACTORIESH_MSGESLENGTH "Illegal sequence length."
#define SEQFACTORIESH_MSGEVLENGTH "Illegal vector length." #define SEQFACTORIESH_MSGEVLENGTH "Illegal vector length."
#define SEQFACTORIESH_MSGEALENGTH "Illegal array dimension." #define SEQFACTORIESH_MSGEALENGTH "Illegal array dimension."
#define SEQFACTORIESH_MSGEVPTR "Null sequence handle." #define SEQFACTORIESH_MSGEVPTR "Null sequence handle."
#define SEQFACTORIESH_MSGEUPTR "Non-null sequence pointer." #define SEQFACTORIESH_MSGEUPTR "Non-null sequence pointer."
#define SEQFACTORIESH_MSGEDPTR "Null sequence data." #define SEQFACTORIESH_MSGEDPTR "Null sequence data."
#define SEQFACTORIESH_MSGEINPTR "Null input pointer." #define SEQFACTORIESH_MSGEINPTR "Null input pointer."
#define SEQFACTORIESH_MSGEMALLOC "Malloc failure." #define SEQFACTORIESH_MSGEMALLOC "Malloc failure."
/*@}*/ /** \endcond */
/** \ingroup SeqFactories_h /** \brief This structure stores the input required for creating a vector
* \brief This structure stores the input required for creating a vector
* sequence. This input includes the length of the sequence (i.e., the num ber of * sequence. This input includes the length of the sequence (i.e., the num ber of
* vectors) and the length of each vector. * vectors) and the length of each vector.
*/ */
typedef struct tagCreateVectorSequenceIn { typedef struct tagCreateVectorSequenceIn {
SWIGLAL_STRUCT(CreateVectorSequenceIn); SWIGLAL_STRUCT(CreateVectorSequenceIn);
UINT4 length; /**< The sequence length */ UINT4 length; /**< The sequence length */
UINT4 vectorLength; /**< The length of each vector in the sequence */ UINT4 vectorLength; /**< The length of each vector in the sequence */
} CreateVectorSequenceIn; } CreateVectorSequenceIn;
/** \ingroup SeqFactories_h /** \brief This structure stores the input required for creating an array
* \brief This structure stores the input required for creating an array
* sequence. This input includes the length of the sequence (i.e., the num ber of * sequence. This input includes the length of the sequence (i.e., the num ber of
* array) and the dimensions of each array index. * array) and the dimensions of each array index.
*/ */
typedef struct tagCreateArraySequenceIn { typedef struct tagCreateArraySequenceIn {
SWIGLAL_STRUCT(CreateArraySequenceIn); SWIGLAL_STRUCT(CreateArraySequenceIn);
UINT4 length; /**< The sequence length */ UINT4 length; /**< The sequence length */
UINT4Vector *dimLength; /**< The dimensions of each array index (the same for every array in the sequence) */ UINT4Vector *dimLength; /**< The dimensions of each array index (the same for every array in the sequence) */
} CreateArraySequenceIn; } CreateArraySequenceIn;
REAL4VectorSequence * XLALCreateVectorSequence ( UINT4 length, UINT4 veclen /*@}*/
); /* ---------- end:SeqFactories_h ---------- */
void XLALDestroyVectorSequence ( REAL4VectorSequence * vecseq );
void LALCreateVectorSequence(LALStatus *, REAL4VectorSequence **, /** \defgroup ArraySequenceFactories_c Module ArraySequenceFactories.c
CreateVectorSequenceIn *); \ingroup SeqFactories_h
void LALDestroyVectorSequence(LALStatus *, REAL4VectorSequence**);
\brief Create/destroy \<datatype\>ArraySequence objects.
\heading{Description}
The \c CreateArraySequence family of functions create a \<datatype\>ArraySe
quence of the appropriate dimensions.
The \c DestroyArraySequence family of functions return the storage allocate
d by the \c CreateArraySequence functions to the system.
*/
/*@{*/
/** \name REAL4 prototypes (default name) */
/*@{*/
void LALCreateArraySequence(LALStatus *, REAL4ArraySequence **, void LALCreateArraySequence(LALStatus *, REAL4ArraySequence **,
CreateArraySequenceIn *); CreateArraySequenceIn *);
void LALDestroyArraySequence(LALStatus *, REAL4ArraySequence **); void LALDestroyArraySequence(LALStatus *, REAL4ArraySequence **);
/*@}*/
/* CHAR prototypes */ /** \name INT2 prototypes */
/*@{*/
void LALI2CreateArraySequence ( LALStatus *status,
INT2ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALI2DestroyArraySequence ( LALStatus *status,
INT2ArraySequence **arraySeqence);
/*@}*/
/** \name INT4 prototypes */
/*@{*/
void LALI4CreateArraySequence ( LALStatus *status,
INT4ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALI4DestroyArraySequence ( LALStatus *status,
INT4ArraySequence **arraySeqence);
/*@}*/
/** \name INT8 prototypes */
/*@{*/
void LALI8CreateArraySequence ( LALStatus *status,
INT8ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALI8DestroyArraySequence ( LALStatus *status,
INT8ArraySequence **arraySeqence);
/*@}*/
/** \name UINT2 prototypes */
/*@{*/
void LALU2CreateArraySequence ( LALStatus *status,
UINT2ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALU2DestroyArraySequence ( LALStatus *status,
UINT2ArraySequence **arraySeqence);
/*@}*/
/** \name UINT4 prototypes */
/*@{*/
void LALU4CreateArraySequence ( LALStatus *status,
UINT4ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALU4DestroyArraySequence ( LALStatus *status,
UINT4ArraySequence **arraySeqence);
/*@}*/
/** \name UINT8 prototypes */
/*@{*/
void LALU8CreateArraySequence ( LALStatus *status,
UINT8ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALU8DestroyArraySequence ( LALStatus *status,
UINT8ArraySequence **arraySeqence);
/*@}*/
/** \name REAL4 prototypes */
/*@{*/
void LALSCreateArraySequence ( LALStatus *status,
REAL4ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALSDestroyArraySequence ( LALStatus *status,
REAL4ArraySequence **arraySeqence);
/*@}*/
/** \name REAL8 prototypes */
/*@{*/
void LALDCreateArraySequence ( LALStatus *status,
REAL8ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALDDestroyArraySequence ( LALStatus *status,
REAL8ArraySequence **arraySeqence);
/*@}*/
/** \name COMPLEX8 prototypes */
/*@{*/
void LALCCreateArraySequence ( LALStatus *status,
COMPLEX8ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALCDestroyArraySequence ( LALStatus *status,
COMPLEX8ArraySequence **arraySeqence);
/*@}*/
/** \name COMPLEX16 prototypes */
/*@{*/
void LALZCreateArraySequence ( LALStatus *status,
COMPLEX16ArraySequence **arraySequence,
CreateArraySequenceIn *aSeqParams);
void LALZDestroyArraySequence ( LALStatus *status,
COMPLEX16ArraySequence **arraySeqence);
/*@}*/
/*@}*/
/* ---------- end: ArraySequenceFactories_c ---------- */
/** \defgroup VectorSequenceFactories_c Module VectorSequenceFactories.c
\ingroup SeqFactories_h
\brief Create/destroy \<datatype\>VectorSequence objects.
\heading{Description}
The \c CreateVectorSequence family of functions create a \<datatype\>Vector
Sequence of the appropriate dimensions.
The \c DestroyVectorSequence family of functions return the storage allocat
ed by the \c CreateVectorSequence functions to the system.
*/
/*@{*/
/** \name REAL4 prototypes (default name) */
/*@{*/
REAL4VectorSequence * XLALCreateVectorSequence ( UINT4 length, UINT4 veclen
);
void XLALDestroyVectorSequence ( REAL4VectorSequence * vecseq );
void LALCreateVectorSequence(LALStatus *, REAL4VectorSequence **,
CreateVectorSequenceIn *);
void LALDestroyVectorSequence(LALStatus *, REAL4VectorSequence**);
/*@}*/
/** \name CHAR prototypes */
/*@{*/
CHARVectorSequence * XLALCreateCHARVectorSequence ( UINT4 length, UINT4 vec len ); CHARVectorSequence * XLALCreateCHARVectorSequence ( UINT4 length, UINT4 vec len );
void XLALDestroyCHARVectorSequence ( CHARVectorSequence * vecseq ); void XLALDestroyCHARVectorSequence ( CHARVectorSequence * vecseq );
void LALCHARCreateVectorSequence ( LALStatus *status, void LALCHARCreateVectorSequence ( LALStatus *status,
CHARVectorSequence **vectorSequence, CHARVectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALCHARDestroyVectorSequence ( LALStatus *status, void LALCHARDestroyVectorSequence ( LALStatus *status,
CHARVectorSequence **vectorSequence); CHARVectorSequence **vectorSequence);
/*@}*/
/* INT2 prototypes */ /** \name INT2 prototypes */
/*@{*/
INT2VectorSequence * XLALCreateINT2VectorSequence ( UINT4 length, UINT4 vec len ); INT2VectorSequence * XLALCreateINT2VectorSequence ( UINT4 length, UINT4 vec len );
void XLALDestroyINT2VectorSequence ( INT2VectorSequence * vecseq ); void XLALDestroyINT2VectorSequence ( INT2VectorSequence * vecseq );
void LALI2CreateVectorSequence ( LALStatus *status, void LALI2CreateVectorSequence ( LALStatus *status,
INT2VectorSequence **vectorSequence, INT2VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALI2DestroyVectorSequence ( LALStatus *status, void LALI2DestroyVectorSequence ( LALStatus *status,
INT2VectorSequence **vectorSequence); INT2VectorSequence **vectorSequence);
/*@}*/
void LALI2CreateArraySequence ( LALStatus *status, /** \name INT4 prototypes */
INT2ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALI2DestroyArraySequence ( LALStatus *status,
INT2ArraySequence **arraySeqence);
/* INT4 prototypes */
INT4VectorSequence * XLALCreateINT4VectorSequence ( UINT4 length, UINT4 vec len ); INT4VectorSequence * XLALCreateINT4VectorSequence ( UINT4 length, UINT4 vec len );
void XLALDestroyINT4VectorSequence ( INT4VectorSequence * vecseq ); void XLALDestroyINT4VectorSequence ( INT4VectorSequence * vecseq );
void LALI4CreateVectorSequence ( LALStatus *status, void LALI4CreateVectorSequence ( LALStatus *status,
INT4VectorSequence **vectorSequence, INT4VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALI4DestroyVectorSequence ( LALStatus *status, void LALI4DestroyVectorSequence ( LALStatus *status,
INT4VectorSequence **vectorSequence); INT4VectorSequence **vectorSequence);
/*@}*/
void LALI4CreateArraySequence ( LALStatus *status, /** \name INT8 prototypes */
INT4ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALI4DestroyArraySequence ( LALStatus *status,
INT4ArraySequence **arraySeqence);
/* INT8 prototypes */
INT8VectorSequence * XLALCreateINT8VectorSequence ( UINT4 length, UINT4 vec len ); INT8VectorSequence * XLALCreateINT8VectorSequence ( UINT4 length, UINT4 vec len );
void XLALDestroyINT8VectorSequence ( INT8VectorSequence * vecseq ); void XLALDestroyINT8VectorSequence ( INT8VectorSequence * vecseq );
void LALI8CreateVectorSequence ( LALStatus *status, void LALI8CreateVectorSequence ( LALStatus *status,
INT8VectorSequence **vectorSequence, INT8VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALI8DestroyVectorSequence ( LALStatus *status, void LALI8DestroyVectorSequence ( LALStatus *status,
INT8VectorSequence **vectorSequence); INT8VectorSequence **vectorSequence);
/*@}*/
void LALI8CreateArraySequence ( LALStatus *status, /** \name UINT2 prototypes */
INT8ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALI8DestroyArraySequence ( LALStatus *status,
INT8ArraySequence **arraySeqence);
/* UINT2 prototypes */
UINT2VectorSequence * XLALCreateUINT2VectorSequence ( UINT4 length, UINT4 v eclen ); UINT2VectorSequence * XLALCreateUINT2VectorSequence ( UINT4 length, UINT4 v eclen );
void XLALDestroyUINT2VectorSequence ( UINT2VectorSequence * vecseq ); void XLALDestroyUINT2VectorSequence ( UINT2VectorSequence * vecseq );
void LALU2CreateVectorSequence ( LALStatus *status, void LALU2CreateVectorSequence ( LALStatus *status,
UINT2VectorSequence **vectorSequence, UINT2VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALU2DestroyVectorSequence ( LALStatus *status, void LALU2DestroyVectorSequence ( LALStatus *status,
UINT2VectorSequence **vectorSequence); UINT2VectorSequence **vectorSequence);
/*@}*/
void LALU2CreateArraySequence ( LALStatus *status, /** \name UINT4 prototypes */
UINT2ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALU2DestroyArraySequence ( LALStatus *status,
UINT2ArraySequence **arraySeqence);
/* UINT4 prototypes */
UINT4VectorSequence * XLALCreateUINT4VectorSequence ( UINT4 length, UINT4 v eclen ); UINT4VectorSequence * XLALCreateUINT4VectorSequence ( UINT4 length, UINT4 v eclen );
void XLALDestroyUINT4VectorSequence ( UINT4VectorSequence * vecseq ); void XLALDestroyUINT4VectorSequence ( UINT4VectorSequence * vecseq );
void LALU4CreateVectorSequence ( LALStatus *status, void LALU4CreateVectorSequence ( LALStatus *status,
UINT4VectorSequence **vectorSequence, UINT4VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALU4DestroyVectorSequence ( LALStatus *status, void LALU4DestroyVectorSequence ( LALStatus *status,
UINT4VectorSequence **vectorSequence); UINT4VectorSequence **vectorSequence);
/*@}*/
void LALU4CreateArraySequence ( LALStatus *status, /** \name UINT8 prototypes */
UINT4ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALU4DestroyArraySequence ( LALStatus *status,
UINT4ArraySequence **arraySeqence);
/* UINT8 prototypes */
UINT8VectorSequence * XLALCreateUINT8VectorSequence ( UINT4 length, UINT4 v eclen ); UINT8VectorSequence * XLALCreateUINT8VectorSequence ( UINT4 length, UINT4 v eclen );
void XLALDestroyUINT8VectorSequence ( UINT8VectorSequence * vecseq ); void XLALDestroyUINT8VectorSequence ( UINT8VectorSequence * vecseq );
void LALU8CreateVectorSequence ( LALStatus *status, void LALU8CreateVectorSequence ( LALStatus *status,
UINT8VectorSequence **vectorSequence, UINT8VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALU8DestroyVectorSequence ( LALStatus *status, void LALU8DestroyVectorSequence ( LALStatus *status,
UINT8VectorSequence **vectorSequence); UINT8VectorSequence **vectorSequence);
/*@}*/
void LALU8CreateArraySequence ( LALStatus *status, /** \name REAL4 prototypes */
UINT8ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALU8DestroyArraySequence ( LALStatus *status,
UINT8ArraySequence **arraySeqence);
/* REAL4 prototypes */
REAL4VectorSequence * XLALCreateREAL4VectorSequence ( UINT4 length, UINT4 v eclen ); REAL4VectorSequence * XLALCreateREAL4VectorSequence ( UINT4 length, UINT4 v eclen );
void XLALDestroyREAL4VectorSequence ( REAL4VectorSequence * vecseq ); void XLALDestroyREAL4VectorSequence ( REAL4VectorSequence * vecseq );
void LALSCreateVectorSequence ( LALStatus *status, void LALSCreateVectorSequence ( LALStatus *status,
REAL4VectorSequence **vectorSequence, REAL4VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALSDestroyVectorSequence ( LALStatus *status, void LALSDestroyVectorSequence ( LALStatus *status,
REAL4VectorSequence **vectorSequence); REAL4VectorSequence **vectorSequence);
/*@}*/
void LALSCreateArraySequence ( LALStatus *status, /** \name REAL8 prototypes */
REAL4ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALSDestroyArraySequence ( LALStatus *status,
REAL4ArraySequence **arraySeqence);
/* REAL8 prototypes */
REAL8VectorSequence * XLALCreateREAL8VectorSequence ( UINT4 length, UINT4 v eclen ); REAL8VectorSequence * XLALCreateREAL8VectorSequence ( UINT4 length, UINT4 v eclen );
void XLALDestroyREAL8VectorSequence ( REAL8VectorSequence * vecseq ); void XLALDestroyREAL8VectorSequence ( REAL8VectorSequence * vecseq );
void LALDCreateVectorSequence ( LALStatus *status, void LALDCreateVectorSequence ( LALStatus *status,
REAL8VectorSequence **vectorSequence, REAL8VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALDDestroyVectorSequence ( LALStatus *status, void LALDDestroyVectorSequence ( LALStatus *status,
REAL8VectorSequence **vectorSequence); REAL8VectorSequence **vectorSequence);
/*@}*/
void LALDCreateArraySequence ( LALStatus *status, /** \name COMPLEX8 prototypes */
REAL8ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALDDestroyArraySequence ( LALStatus *status,
REAL8ArraySequence **arraySeqence);
/* COMPLEX8 prototypes */
COMPLEX8VectorSequence * XLALCreateCOMPLEX8VectorSequence ( UINT4 length, U INT4 veclen ); COMPLEX8VectorSequence * XLALCreateCOMPLEX8VectorSequence ( UINT4 length, U INT4 veclen );
void XLALDestroyCOMPLEX8VectorSequence ( COMPLEX8VectorSequence * vecseq ); void XLALDestroyCOMPLEX8VectorSequence ( COMPLEX8VectorSequence * vecseq );
void LALCCreateVectorSequence ( LALStatus *status, void LALCCreateVectorSequence ( LALStatus *status,
COMPLEX8VectorSequence **vectorSequence, COMPLEX8VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALCDestroyVectorSequence ( LALStatus *status, void LALCDestroyVectorSequence ( LALStatus *status,
COMPLEX8VectorSequence **vectorSequence); COMPLEX8VectorSequence **vectorSequence);
/*@}*/
void LALCCreateArraySequence ( LALStatus *status, /** \name COMPLEX16 prototypes */
COMPLEX8ArraySequence **arraySequence, /*@{*/
CreateArraySequenceIn *aSeqParams);
void LALCDestroyArraySequence ( LALStatus *status,
COMPLEX8ArraySequence **arraySeqence);
/* COMPLEX16 prototypes */
COMPLEX16VectorSequence * XLALCreateCOMPLEX16VectorSequence ( UINT4 length, UINT4 veclen ); COMPLEX16VectorSequence * XLALCreateCOMPLEX16VectorSequence ( UINT4 length, UINT4 veclen );
void XLALDestroyCOMPLEX16VectorSequence ( COMPLEX16VectorSequence * vecseq ); void XLALDestroyCOMPLEX16VectorSequence ( COMPLEX16VectorSequence * vecseq );
void LALZCreateVectorSequence ( LALStatus *status, void LALZCreateVectorSequence ( LALStatus *status,
COMPLEX16VectorSequence **vectorSequence, COMPLEX16VectorSequence **vectorSequence,
CreateVectorSequenceIn *vSeqParams); CreateVectorSequenceIn *vSeqParams);
void LALZDestroyVectorSequence ( LALStatus *status, void LALZDestroyVectorSequence ( LALStatus *status,
COMPLEX16VectorSequence **vectorSequence); COMPLEX16VectorSequence **vectorSequence);
/*@}*/
void LALZCreateArraySequence ( LALStatus *status, /*@}*/
COMPLEX16ArraySequence **arraySequence, /* ---------- end: VectorSequenceFactories_c ---------- */
CreateArraySequenceIn *aSeqParams);
void LALZDestroyArraySequence ( LALStatus *status,
COMPLEX16ArraySequence **arraySeqence);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _SEQFACTORIES_H */ #endif /* _SEQFACTORIES_H */
 End of changes. 37 change blocks. 
131 lines changed or deleted 215 lines changed or added


 Sequence.h   Sequence.h 
skipping to change at line 32 skipping to change at line 32
#include <stddef.h> #include <stddef.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/* COMPLEX8 prototypes */ /**
\addtogroup SequenceManipulation
void XLALDestroyCOMPLEX8Sequence ( \author Kipp Cannon <kipp@gravity.phys.uwm.edu>
COMPLEX8Sequence *sequence
);
COMPLEX8Sequence *XLALCreateCOMPLEX8Sequence (
size_t length
);
COMPLEX8Sequence *XLALCutCOMPLEX8Sequence (
COMPLEX8Sequence *sequence,
size_t first,
size_t length
);
COMPLEX8Sequence *XLALCopyCOMPLEX8Sequence (
COMPLEX8Sequence *sequence
);
void XLALShiftCOMPLEX8Sequence (
COMPLEX8Sequence *sequence,
int count
);
COMPLEX8Sequence *XLALResizeCOMPLEX8Sequence (
COMPLEX8Sequence *sequence,
int first,
size_t length
);
COMPLEX8Sequence *XLALShrinkCOMPLEX8Sequence (
COMPLEX8Sequence *sequence,
size_t first,
size_t length
);
COMPLEX8 XLALCOMPLEX8Sum (
const COMPLEX8 *data,
size_t first,
size_t count
);
REAL4 XLALCOMPLEX8SumSquares (
const COMPLEX8 *data,
size_t first,
size_t count
);
COMPLEX8 XLALCOMPLEX8SequenceSum (
const COMPLEX8Sequence *sequence,
size_t first,
size_t count
);
REAL4 XLALCOMPLEX8SequenceSumSquares (
const COMPLEX8Sequence *sequence,
size_t first,
size_t count
);
COMPLEX8Sequence *XLALConjugateCOMPLEX8Sequence (
COMPLEX8Sequence *series
);
/* COMPLEX16 prototypes */
void XLALDestroyCOMPLEX16Sequence (
COMPLEX16Sequence *sequence
);
COMPLEX16Sequence *XLALCreateCOMPLEX16Sequence (
size_t length
);
COMPLEX16Sequence *XLALCutCOMPLEX16Sequence (
COMPLEX16Sequence *sequence,
size_t first,
size_t length
);
COMPLEX16Sequence *XLALCopyCOMPLEX16Sequence (
COMPLEX16Sequence *sequence
);
void XLALShiftCOMPLEX16Sequence (
COMPLEX16Sequence *sequence,
int count
);
COMPLEX16Sequence *XLALResizeCOMPLEX16Sequence (
COMPLEX16Sequence *sequence,
int first,
size_t length
);
COMPLEX16Sequence *XLALShrinkCOMPLEX16Sequence (
COMPLEX16Sequence *sequence,
size_t first,
size_t length
);
COMPLEX16 XLALCOMPLEX16Sum (
const COMPLEX16 *data,
size_t first,
size_t count
);
REAL8 XLALCOMPLEX16SumSquares (
const COMPLEX16 *data,
size_t first,
size_t count
);
COMPLEX16 XLALCOMPLEX16SequenceSum (
const COMPLEX16Sequence *sequence,
size_t first,
size_t count
);
REAL8 XLALCOMPLEX16SequenceSumSquares (
const COMPLEX16Sequence *sequence,
size_t first,
size_t count
);
COMPLEX16Sequence *XLALConjugateCOMPLEX16Sequence (
COMPLEX16Sequence *series
);
/* REAL4 prototypes */
void XLALDestroyREAL4Sequence (
REAL4Sequence *sequence
);
REAL4Sequence *XLALCreateREAL4Sequence (
size_t length
);
REAL4Sequence *XLALCutREAL4Sequence (
REAL4Sequence *sequence,
size_t first,
size_t length
);
REAL4Sequence *XLALCopyREAL4Sequence (
REAL4Sequence *sequence
);
void XLALShiftREAL4Sequence (
REAL4Sequence *sequence,
int count
);
REAL4Sequence *XLALResizeREAL4Sequence (
REAL4Sequence *sequence,
int first,
size_t length
);
REAL4Sequence *XLALShrinkREAL4Sequence (
REAL4Sequence *sequence,
size_t first,
size_t length
);
REAL4 XLALREAL4Sum (
const REAL4 *data,
size_t first,
size_t count
);
REAL4 XLALREAL4SumSquares (
const REAL4 *data,
size_t first,
size_t count
);
REAL4 XLALREAL4SequenceSum (
const REAL4Sequence *sequence,
size_t first,
size_t count
);
REAL4 XLALREAL4SequenceSumSquares (
const REAL4Sequence *sequence,
size_t first,
size_t count
);
/* REAL8 prototypes */
void XLALDestroyREAL8Sequence (
REAL8Sequence *sequence
);
REAL8Sequence *XLALCreateREAL8Sequence (
size_t length
);
REAL8Sequence *XLALCutREAL8Sequence (
REAL8Sequence *sequence,
size_t first,
size_t length
);
REAL8Sequence *XLALCopyREAL8Sequence (
REAL8Sequence *sequence
);
void XLALShiftREAL8Sequence (
REAL8Sequence *sequence,
int count
);
REAL8Sequence *XLALResizeREAL8Sequence (
REAL8Sequence *sequence,
int first,
size_t length
);
REAL8Sequence *XLALShrinkREAL8Sequence (
REAL8Sequence *sequence,
size_t first,
size_t length
);
REAL8 XLALREAL8Sum (
const REAL8 *data,
size_t first,
size_t count
);
REAL8 XLALREAL8SumSquares (
const REAL8 *data,
size_t first,
size_t count
);
REAL8 XLALREAL8SequenceSum (
const REAL8Sequence *sequence,
size_t first,
size_t count
);
REAL8 XLALREAL8SequenceSumSquares (
const REAL8Sequence *sequence,
size_t first,
size_t count
);
/* INT2 prototypes */
void XLALDestroyINT2Sequence (
INT2Sequence *sequence
);
INT2Sequence *XLALCreateINT2Sequence (
size_t length
);
INT2Sequence *XLALCutINT2Sequence (
INT2Sequence *sequence,
size_t first,
size_t length
);
INT2Sequence *XLALCopyINT2Sequence (
INT2Sequence *sequence
);
void XLALShiftINT2Sequence (
INT2Sequence *sequence,
int count
);
INT2Sequence *XLALResizeINT2Sequence (
INT2Sequence *sequence,
int first,
size_t length
);
INT2Sequence *XLALShrinkINT2Sequence (
INT2Sequence *sequence,
size_t first,
size_t length
);
INT2 XLALINT2Sum (
const INT2 *data,
size_t first,
size_t count
);
UINT2 XLALINT2SumSquares (
const INT2 *data,
size_t first,
size_t count
);
INT2 XLALINT2SequenceSum (
const INT2Sequence *sequence,
size_t first,
size_t count
);
UINT2 XLALINT2SequenceSumSquares (
const INT2Sequence *sequence,
size_t first,
size_t count
);
/* INT4 prototypes */
void XLALDestroyINT4Sequence (
INT4Sequence *sequence
);
INT4Sequence *XLALCreateINT4Sequence (
size_t length
);
INT4Sequence *XLALCutINT4Sequence (
INT4Sequence *sequence,
size_t first,
size_t length
);
INT4Sequence *XLALCopyINT4Sequence (
INT4Sequence *sequence
);
void XLALShiftINT4Sequence (
INT4Sequence *sequence,
int count
);
INT4Sequence *XLALResizeINT4Sequence ( \brief This is a suite of functions for creating, destroying, and manipulat
INT4Sequence *sequence, ing LAL
int first, sequences. For example XLALCreateREAL4Sequence() is available for
size_t length creating sequences of \c REAL4 data.
); */
/*@{*/
INT4Sequence *XLALShrinkINT4Sequence ( /** \name Creation Functions
INT4Sequence *sequence, \heading{Synopsis}
size_t first,
size_t length
);
INT4 XLALINT4Sum ( \code
const INT4 *data, #include <lal/Sequence.h>
size_t first,
size_t count
);
UINT4 XLALINT4SumSquares ( XLALCreate<sequencetype>()
const INT4 *data, LALCreate<sequencetype>()
size_t first, \endcode
size_t count
);
INT4 XLALINT4SequenceSum ( \heading{Description}
const INT4Sequence *sequence,
size_t first,
size_t count
);
UINT4 XLALINT4SequenceSumSquares ( These functions create LAL sequences. The parameter \c length
const INT4Sequence *sequence, specifies the length of the desired sequence. The return value is a
size_t first, pointer to the newly created sequence or \c NULL on failure.
size_t count */
); /*@{*/
COMPLEX8Sequence *XLALCreateCOMPLEX8Sequence ( size_t length );
COMPLEX16Sequence *XLALCreateCOMPLEX16Sequence ( size_t length );
REAL4Sequence *XLALCreateREAL4Sequence ( size_t length );
REAL8Sequence *XLALCreateREAL8Sequence ( size_t length );
INT2Sequence *XLALCreateINT2Sequence ( size_t length );
INT4Sequence *XLALCreateINT4Sequence ( size_t length );
INT8Sequence *XLALCreateINT8Sequence ( size_t length );
UINT2Sequence *XLALCreateUINT2Sequence ( size_t length );
UINT4Sequence *XLALCreateUINT4Sequence ( size_t length );
UINT8Sequence *XLALCreateUINT8Sequence ( size_t length );
/*@}*/
/* INT8 prototypes */ /** \name Destruction Functions
void XLALDestroyINT8Sequence ( \heading{Synopsis}
INT8Sequence *sequence
);
INT8Sequence *XLALCreateINT8Sequence ( \code
size_t length #include <lal/Sequence.h>
);
INT8Sequence *XLALCutINT8Sequence ( XLALDestroy<sequencetype>()
INT8Sequence *sequence, \endcode
size_t first,
size_t length
);
INT8Sequence *XLALCopyINT8Sequence ( \heading{Description}
INT8Sequence *sequence
);
void XLALShiftINT8Sequence ( These functions free all memory associated with a LAL sequence. It is safe
INT8Sequence *sequence, to pass \c NULL to these functions.
int count
);
INT8Sequence *XLALResizeINT8Sequence ( */
INT8Sequence *sequence, /*@{*/
int first, void XLALDestroyCOMPLEX8Sequence ( COMPLEX8Sequence *sequence );
size_t length void XLALDestroyCOMPLEX16Sequence ( COMPLEX16Sequence *sequence );
); void XLALDestroyREAL4Sequence ( REAL4Sequence *sequence );
void XLALDestroyREAL8Sequence ( REAL8Sequence *sequence );
void XLALDestroyINT2Sequence ( INT2Sequence *sequence );
void XLALDestroyINT4Sequence ( INT4Sequence *sequence );
void XLALDestroyINT8Sequence ( INT8Sequence *sequence );
void XLALDestroyUINT2Sequence ( UINT2Sequence *sequence );
void XLALDestroyUINT4Sequence ( UINT4Sequence *sequence );
void XLALDestroyUINT8Sequence ( UINT8Sequence *sequence );
/*@}*/
INT8Sequence *XLALShrinkINT8Sequence ( /** \name Cutting Functions
INT8Sequence *sequence,
size_t first,
size_t length
);
INT8 XLALINT8Sum ( \heading{Synopsis}
const INT8 *data,
size_t first,
size_t count
);
UINT8 XLALINT8SumSquares ( \code
const INT8 *data, #include <lal/Sequence.h>
size_t first,
size_t count
);
INT8 XLALINT8SequenceSum ( XLALCut<sequencetype>()
const INT8Sequence *sequence, XLALCopy<sequencetype>()
size_t first, \endcode
size_t count
);
UINT8 XLALINT8SequenceSumSquares ( \heading{Description}
const INT8Sequence *sequence,
size_t first,
size_t count
);
/* UINT2 prototypes */ These functions create a new sequence by extracting a section of an
existing sequence.
void XLALDestroyUINT2Sequence ( */
UINT2Sequence *sequence /*@{*/
); COMPLEX8Sequence *XLALCutCOMPLEX8Sequence ( COMPLEX8Sequence *sequence, siz
e_t first, size_t length );
COMPLEX16Sequence *XLALCutCOMPLEX16Sequence ( COMPLEX16Sequence *sequence,
size_t first, size_t length );
REAL4Sequence *XLALCutREAL4Sequence ( REAL4Sequence *sequence, size_t first
, size_t length );
REAL8Sequence *XLALCutREAL8Sequence ( REAL8Sequence *sequence, size_t first
, size_t length );
INT2Sequence *XLALCutINT2Sequence ( INT2Sequence *sequence, size_t first, s
ize_t length );
INT4Sequence *XLALCutINT4Sequence ( INT4Sequence *sequence, size_t first, s
ize_t length );
INT8Sequence *XLALCutINT8Sequence ( INT8Sequence *sequence, size_t first, s
ize_t length );
UINT2Sequence *XLALCutUINT2Sequence ( UINT2Sequence *sequence, size_t first
, size_t length );
UINT4Sequence *XLALCutUINT4Sequence ( UINT4Sequence *sequence, size_t first
, size_t length );
UINT8Sequence *XLALCutUINT8Sequence ( UINT8Sequence *sequence, size_t first
, size_t length );
UINT2Sequence *XLALCreateUINT2Sequence ( COMPLEX8Sequence *XLALCopyCOMPLEX8Sequence ( COMPLEX8Sequence *sequence );
size_t length COMPLEX16Sequence *XLALCopyCOMPLEX16Sequence ( COMPLEX16Sequence *sequence
); );
REAL4Sequence *XLALCopyREAL4Sequence ( REAL4Sequence *sequence );
REAL8Sequence *XLALCopyREAL8Sequence ( REAL8Sequence *sequence );
INT2Sequence *XLALCopyINT2Sequence ( INT2Sequence *sequence );
INT4Sequence *XLALCopyINT4Sequence ( INT4Sequence *sequence );
INT8Sequence *XLALCopyINT8Sequence ( INT8Sequence *sequence );
UINT2Sequence *XLALCopyUINT2Sequence ( UINT2Sequence *sequence );
UINT4Sequence *XLALCopyUINT4Sequence ( UINT4Sequence *sequence );
UINT8Sequence *XLALCopyUINT8Sequence ( UINT8Sequence *sequence );
/*@}*/
UINT2Sequence *XLALCutUINT2Sequence ( /** \name Shifting Functions
UINT2Sequence *sequence,
size_t first,
size_t length
);
UINT2Sequence *XLALCopyUINT2Sequence ( \heading{Synopsis}
UINT2Sequence *sequence
);
void XLALShiftUINT2Sequence ( \code
UINT2Sequence *sequence, #include <lal/Sequence.h>
int count
);
UINT2Sequence *XLALResizeUINT2Sequence ( XLALShift<sequencetype>()
UINT2Sequence *sequence, \endcode
int first,
size_t length
);
UINT2Sequence *XLALShrinkUINT2Sequence ( \heading{Description}
UINT2Sequence *sequence,
size_t first,
size_t length
);
UINT2 XLALUINT2Sum ( These functions shift the samples in a sequence, with zeros being placed in
const UINT2 *data, the space that is freed.
size_t first, */
size_t count /*@{*/
); void XLALShiftCOMPLEX8Sequence ( COMPLEX8Sequence *sequence, int count );
void XLALShiftCOMPLEX16Sequence ( COMPLEX16Sequence *sequence, int count );
void XLALShiftREAL4Sequence ( REAL4Sequence *sequence, int count );
void XLALShiftREAL8Sequence ( REAL8Sequence *sequence, int count );
void XLALShiftINT2Sequence ( INT2Sequence *sequence, int count );
void XLALShiftINT4Sequence ( INT4Sequence *sequence, int count );
void XLALShiftINT8Sequence ( INT8Sequence *sequence, int count );
void XLALShiftUINT2Sequence ( UINT2Sequence *sequence, int count );
void XLALShiftUINT4Sequence ( UINT4Sequence *sequence, int count );
void XLALShiftUINT8Sequence ( UINT8Sequence *sequence, int count );
/*@}*/
UINT2 XLALUINT2SumSquares ( /** \name Resizing Functions
const UINT2 *data,
size_t first,
size_t count
);
UINT2 XLALUINT2SequenceSum ( \heading{Synopsis}
const UINT2Sequence *sequence,
size_t first,
size_t count
);
UINT2 XLALUINT2SequenceSumSquares ( \code
const UINT2Sequence *sequence, #include <lal/Sequence.h>
size_t first,
size_t count
);
/* UINT4 prototypes */ XLALResize<sequencetype>()
XLALShrink<sequencetype>()
\endcode
void XLALDestroyUINT4Sequence ( \heading{Description}
UINT4Sequence *sequence
);
UINT4Sequence *XLALCreateUINT4Sequence ( The resize functions alter the size of an existing sequence. The sequence
size_t length is adjusted to have the specified length, and that part of the original
); sequence starting at sample first is used to fill the new sequence. If
first is negative, then the start of the new sequence is padded by that
many samples. If part of the new sequence does not correspond to some part
of the original sequence, then those samples are set to 0.
UINT4Sequence *XLALCutUINT4Sequence ( The shrink functions, originally, could only handle the special case in
UINT4Sequence *sequence, which the new sequence is wholly contained in the original sequence. Now
size_t first, the shrink functions are wrappers for the resize functions and are only
size_t length retained for backwards compatibility.
);
UINT4Sequence *XLALCopyUINT4Sequence ( */
UINT4Sequence *sequence /*@{*/
); COMPLEX8Sequence *XLALResizeCOMPLEX8Sequence ( COMPLEX8Sequence *sequence,
int first, size_t length );
COMPLEX16Sequence *XLALResizeCOMPLEX16Sequence ( COMPLEX16Sequence *sequenc
e, int first, size_t length );
REAL4Sequence *XLALResizeREAL4Sequence ( REAL4Sequence *sequence, int first
, size_t length );
REAL8Sequence *XLALResizeREAL8Sequence ( REAL8Sequence *sequence, int first
, size_t length );
INT2Sequence *XLALResizeINT2Sequence ( INT2Sequence *sequence, int first, s
ize_t length );
INT4Sequence *XLALResizeINT4Sequence ( INT4Sequence *sequence, int first, s
ize_t length );
INT8Sequence *XLALResizeINT8Sequence ( INT8Sequence *sequence, int first, s
ize_t length );
UINT2Sequence *XLALResizeUINT2Sequence ( UINT2Sequence *sequence, int first
, size_t length );
UINT4Sequence *XLALResizeUINT4Sequence ( UINT4Sequence *sequence, int first
, size_t length );
UINT8Sequence *XLALResizeUINT8Sequence ( UINT8Sequence *sequence, int first
, size_t length );
void XLALShiftUINT4Sequence ( COMPLEX8Sequence *XLALShrinkCOMPLEX8Sequence ( COMPLEX8Sequence *sequence,
UINT4Sequence *sequence, size_t first, size_t length );
int count COMPLEX16Sequence *XLALShrinkCOMPLEX16Sequence ( COMPLEX16Sequence *sequenc
); e, size_t first, size_t length );
REAL4Sequence *XLALShrinkREAL4Sequence ( REAL4Sequence *sequence, size_t fi
rst, size_t length );
REAL8Sequence *XLALShrinkREAL8Sequence ( REAL8Sequence *sequence, size_t fi
rst, size_t length );
INT2Sequence *XLALShrinkINT2Sequence ( INT2Sequence *sequence, size_t first
, size_t length );
INT4Sequence *XLALShrinkINT4Sequence ( INT4Sequence *sequence, size_t first
, size_t length );
INT8Sequence *XLALShrinkINT8Sequence ( INT8Sequence *sequence, size_t first
, size_t length );
UINT2Sequence *XLALShrinkUINT2Sequence ( UINT2Sequence *sequence, size_t fi
rst, size_t length );
UINT4Sequence *XLALShrinkUINT4Sequence ( UINT4Sequence *sequence, size_t fi
rst, size_t length );
UINT8Sequence *XLALShrinkUINT8Sequence ( UINT8Sequence *sequence, size_t fi
rst, size_t length );
/*@}*/
UINT4Sequence *XLALResizeUINT4Sequence ( /** \name Summing Functions
UINT4Sequence *sequence,
int first,
size_t length
);
UINT4Sequence *XLALShrinkUINT4Sequence ( \heading{Synopsis}
UINT4Sequence *sequence,
size_t first,
size_t length
);
UINT4 XLALUINT4Sum ( \code
const UINT4 *data, #include <lal/Sequence.h>
size_t first,
size_t count
);
UINT4 XLALUINT4SumSquares ( XLAL<datatype>Sum()
const UINT4 *data, XLAL<datatype>SumSquares()
size_t first, XLAL<sequencetype>Sum>()
size_t count XLAL<sequencetype>SumSquares()
); \endcode
UINT4 XLALUINT4SequenceSum ( \heading{Description}
const UINT4Sequence *sequence,
size_t first,
size_t count
);
UINT4 XLALUINT4SequenceSumSquares ( The \c XLAL\<datatype\>Sum() and
const UINT4Sequence *sequence, \c XLAL\<datatype\>SumSquares() functions sum the
size_t first, elements and squares of the elements, respectively, in an array.
size_t count
);
/* UINT8 prototypes */ The \c XLAL\<sequencetype\>Sum() and
\c XLAL\<sequencetype\>SumSquares() functions sum the
elements and the squares of the elements, respectively in a sequence.
Bounds checking is performed.
void XLALDestroyUINT8Sequence ( In all cases, the return value is the sum, and these functions cannot fail.
UINT8Sequence *sequence In the case of the sequence-related functions, if the sum extends beyond
); the bounds of the sequence, then the missing values are assumed to be 0.
UINT8Sequence *XLALCreateUINT8Sequence ( \heading{Bugs}
size_t length
);
UINT8Sequence *XLALCutUINT8Sequence ( Because the LAL library must conform to the C89 specification, aggregate
UINT8Sequence *sequence, data types cannot be returned from functions so the COMPLEX8 and COMPLEX16
size_t first, versions of the sum functions (not sum-of-squares functions) are commented
size_t length out at this time.
); */
/*@{*/
COMPLEX8 XLALCOMPLEX8Sum ( const COMPLEX8 *data, size_t first, size_t count
);
REAL4 XLALCOMPLEX8SumSquares ( const COMPLEX8 *data, size_t first, size_t c
ount );
COMPLEX8 XLALCOMPLEX8SequenceSum ( const COMPLEX8Sequence *sequence, size_t
first, size_t count );
REAL4 XLALCOMPLEX8SequenceSumSquares ( const COMPLEX8Sequence *sequence, si
ze_t first, size_t count );
COMPLEX16 XLALCOMPLEX16Sum ( const COMPLEX16 *data, size_t first, size_t co
unt );
REAL8 XLALCOMPLEX16SumSquares ( const COMPLEX16 *data, size_t first, size_t
count );
COMPLEX16 XLALCOMPLEX16SequenceSum ( const COMPLEX16Sequence *sequence, siz
e_t first, size_t count );
REAL8 XLALCOMPLEX16SequenceSumSquares ( const COMPLEX16Sequence *sequence,
size_t first, size_t count );
REAL4 XLALREAL4Sum ( const REAL4 *data, size_t first, size_t count );
REAL4 XLALREAL4SumSquares ( const REAL4 *data, size_t first, size_t count )
;
REAL4 XLALREAL4SequenceSum ( const REAL4Sequence *sequence, size_t first, s
ize_t count );
REAL4 XLALREAL4SequenceSumSquares ( const REAL4Sequence *sequence, size_t f
irst, size_t count );
REAL8 XLALREAL8Sum ( const REAL8 *data, size_t first, size_t count );
REAL8 XLALREAL8SumSquares ( const REAL8 *data, size_t first, size_t count )
;
REAL8 XLALREAL8SequenceSum ( const REAL8Sequence *sequence, size_t first, s
ize_t count );
REAL8 XLALREAL8SequenceSumSquares ( const REAL8Sequence *sequence, size_t f
irst, size_t count );
INT2 XLALINT2Sum ( const INT2 *data, size_t first, size_t count );
UINT2 XLALINT2SumSquares ( const INT2 *data, size_t first, size_t count );
INT2 XLALINT2SequenceSum ( const INT2Sequence *sequence, size_t first, size
_t count );
UINT2 XLALINT2SequenceSumSquares ( const INT2Sequence *sequence, size_t fir
st, size_t count );
INT4 XLALINT4Sum ( const INT4 *data, size_t first, size_t count );
UINT4 XLALINT4SumSquares ( const INT4 *data, size_t first, size_t count );
INT4 XLALINT4SequenceSum ( const INT4Sequence *sequence, size_t first, size
_t count );
UINT4 XLALINT4SequenceSumSquares ( const INT4Sequence *sequence, size_t fir
st, size_t count );
INT8 XLALINT8Sum ( const INT8 *data, size_t first, size_t count );
UINT8 XLALINT8SumSquares ( const INT8 *data, size_t first, size_t count );
INT8 XLALINT8SequenceSum ( const INT8Sequence *sequence, size_t first, size
_t count );
UINT8 XLALINT8SequenceSumSquares ( const INT8Sequence *sequence, size_t fir
st, size_t count );
UINT2 XLALUINT2Sum ( const UINT2 *data, size_t first, size_t count );
UINT2 XLALUINT2SumSquares ( const UINT2 *data, size_t first, size_t count )
;
UINT2 XLALUINT2SequenceSum ( const UINT2Sequence *sequence, size_t first, s
ize_t count );
UINT2 XLALUINT2SequenceSumSquares ( const UINT2Sequence *sequence, size_t f
irst, size_t count );
UINT4 XLALUINT4Sum ( const UINT4 *data, size_t first, size_t count );
UINT4 XLALUINT4SumSquares ( const UINT4 *data, size_t first, size_t count )
;
UINT4 XLALUINT4SequenceSum ( const UINT4Sequence *sequence, size_t first, s
ize_t count );
UINT4 XLALUINT4SequenceSumSquares ( const UINT4Sequence *sequence, size_t f
irst, size_t count );
UINT8 XLALUINT8Sum ( const UINT8 *data, size_t first, size_t count );
UINT8 XLALUINT8SumSquares ( const UINT8 *data, size_t first, size_t count )
;
UINT8 XLALUINT8SequenceSum ( const UINT8Sequence *sequence, size_t first, s
ize_t count );
UINT8 XLALUINT8SequenceSumSquares ( const UINT8Sequence *sequence, size_t f
irst, size_t count );
/*@}*/
UINT8Sequence *XLALCopyUINT8Sequence ( /** \name Conjugate Functions
UINT8Sequence *sequence
);
void XLALShiftUINT8Sequence ( \heading{Synopsis}
UINT8Sequence *sequence,
int count
);
UINT8Sequence *XLALResizeUINT8Sequence ( \code
UINT8Sequence *sequence, #include <lal/Sequence.h>
int first,
size_t length
);
UINT8Sequence *XLALShrinkUINT8Sequence ( XLAL<datatype>Conjugate()
UINT8Sequence *sequence, \endcode
size_t first,
size_t length
);
UINT8 XLALUINT8Sum ( \heading{Description}
const UINT8 *data,
size_t first,
size_t count
);
UINT8 XLALUINT8SumSquares ( These functions replace a sequence with its complex conjugate.
const UINT8 *data,
size_t first,
size_t count
);
UINT8 XLALUINT8SequenceSum ( */
const UINT8Sequence *sequence, /*@{*/
size_t first, COMPLEX8Sequence *XLALConjugateCOMPLEX8Sequence ( COMPLEX8Sequence *series
size_t count );
); COMPLEX16Sequence *XLALConjugateCOMPLEX16Sequence ( COMPLEX16Sequence *seri
es );
/*@}*/
UINT8 XLALUINT8SequenceSumSquares ( /*@}*/
const UINT8Sequence *sequence,
size_t first,
size_t count
);
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _SEQUENCE_H */ #endif /* _SEQUENCE_H */
 End of changes. 55 change blocks. 
563 lines changed or deleted 295 lines changed or added


 SimulateCoherentGW.h   SimulateCoherentGW.h 
skipping to change at line 40 skipping to change at line 40
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/LALBarycenter.h> #include <lal/LALBarycenter.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /**
\author Creighton, T. D.
\addtogroup SimulateCoherentGW_h \addtogroup SimulateCoherentGW_h
\author Creighton, T. D.
\brief Provides routines to simulate generic gravitational waveforms \brief Provides routines to simulate generic gravitational waveforms
originating from a particular source. originating from a particular source.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/SimulateCoherentGW.h> #include <lal/SimulateCoherentGW.h>
\endcode \endcode
This header covers generic routines and structures to represent and This header covers generic routines and structures to represent and
skipping to change at line 133 skipping to change at line 133
\f$x\f$-axis of the polarization basis relative to an Earth-fixed \f$x\f$-axis of the polarization basis relative to an Earth-fixed
reference frame (see the coordinate conventions below). If \f$\Phi\f$ is reference frame (see the coordinate conventions below). If \f$\Phi\f$ is
constant, one can redefine \f$\psi\f$ such that \f$\Phi=0\f$; however, when constant, one can redefine \f$\psi\f$ such that \f$\Phi=0\f$; however, when
\f$\Phi\f$ changes with time, we would nonetheless like our polarization \f$\Phi\f$ changes with time, we would nonetheless like our polarization
basis to remain fixed. We therefore retain the constant \f$\psi\f$ and basis to remain fixed. We therefore retain the constant \f$\psi\f$ and
the function \f$\Phi(t)\f$ as distinct quantities. the function \f$\Phi(t)\f$ as distinct quantities.
The advantage of this quasiperiodic representation of a gravitational The advantage of this quasiperiodic representation of a gravitational
wave is that a physical sampling of the parameters \f$A_1\f$, \f$A_2\f$, wave is that a physical sampling of the parameters \f$A_1\f$, \f$A_2\f$,
\f$\phi\f$, and \f$\Phi\f$ need only be done on timescales \f$\Delta \f$\phi\f$, and \f$\Phi\f$ need only be done on timescales \f$\Delta
t\lessim\tau\f$, whereas the actual wave functions \f$h_{+,\times}\f$ need t\lesssim\tau\f$, whereas the actual wave functions \f$h_{+,\times}\f$ need
to be sampled on timescales \f$\Delta t\lessim1/f\f$. to be sampled on timescales \f$\Delta t\lesssim1/f\f$.
The following coordinate conventions are assumed: The following coordinate conventions are assumed:
<ol> <ol>
<li> Fig. 7 of [\ref Will_C_1996] defines standard coordinate <li> Fig. 7 of [\ref Will_C_1996] defines standard coordinate
conventions for nonprecessing binaries, and by extension, for any conventions for nonprecessing binaries, and by extension, for any
fixed-axis rotating source: If \f$\mathbf{\hat{z}}\f$ points in the directi on fixed-axis rotating source: If \f$\mathbf{\hat{z}}\f$ points in the directi on
of wave propagation (away from the source), and \f$\mathbf{\hat{l}}\f$ poin ts of wave propagation (away from the source), and \f$\mathbf{\hat{l}}\f$ poin ts
in the (constant) direction of the source's angular momentum vector, in the (constant) direction of the source's angular momentum vector,
then the \f$x\f$-\f$y\f$ coordinates used to define the + and \f$\times\f$ then the \f$x\f$-\f$y\f$ coordinates used to define the + and \f$\times\f$
polarizations are given by \f$\mathbf{\hat{x}}=|\csc polarizations are given by \f$\mathbf{\hat{x}}=|\csc
skipping to change at line 253 skipping to change at line 253
However, coherence is often used to refer to a more restricted class However, coherence is often used to refer to a more restricted class
of waveforms that are "effectively monochromatic" over some of waveforms that are "effectively monochromatic" over some
coherence timescale \f$t_\mathrm{coh}\f$; i.e.\ in any timespan coherence timescale \f$t_\mathrm{coh}\f$; i.e.\ in any timespan
\f$t_\mathrm{coh}\f$ there is a fixed-frequency sinusoid that is never \f$t_\mathrm{coh}\f$ there is a fixed-frequency sinusoid that is never
more than \f$90^\circ\f$ out of phase with the waveform. This is more more than \f$90^\circ\f$ out of phase with the waveform. This is more
retrictive even than our concept of quasiperiodic waves; for retrictive even than our concept of quasiperiodic waves; for
smoothly-varying waveforms one has \f$t_\mathrm{coh}\sim\dot{f}^{-1/2}\f$, smoothly-varying waveforms one has \f$t_\mathrm{coh}\sim\dot{f}^{-1/2}\f$,
which is much shorter than the evolution timescale \f$\tau\sim which is much shorter than the evolution timescale \f$\tau\sim
f/\dot{f}\f$ (provided \f$\tau\gg1/f\f$, as we have assumed). f/\dot{f}\f$ (provided \f$\tau\gg1/f\f$, as we have assumed).
*/ /**@{ */ */
/** \name Error Codes */ /*@{*/ /*@{*/
/** \name Error Codes */
/*@{*/
#define SIMULATECOHERENTGWH_ENUL 1 /**< Unexpected null pointer in argu ments */ #define SIMULATECOHERENTGWH_ENUL 1 /**< Unexpected null pointer in argu ments */
#define SIMULATECOHERENTGWH_EBAD 2 /**< A sampling interval is (effecti vely) zero */ #define SIMULATECOHERENTGWH_EBAD 2 /**< A sampling interval is (effecti vely) zero */
#define SIMULATECOHERENTGWH_ESIG 3 /**< Input signal must specify ampli tude and phase functions */ #define SIMULATECOHERENTGWH_ESIG 3 /**< Input signal must specify ampli tude and phase functions */
#define SIMULATECOHERENTGWH_EDIM 4 /**< Amplitude must be a 2-dimension al vector */ #define SIMULATECOHERENTGWH_EDIM 4 /**< Amplitude must be a 2-dimension al vector */
#define SIMULATECOHERENTGWH_EMEM 5 /**< Memory allocation error */ #define SIMULATECOHERENTGWH_EMEM 5 /**< Memory allocation error */
#define SIMULATECOHERENTGWH_EUNIT 6 /**< Bad input units */ #define SIMULATECOHERENTGWH_EUNIT 6 /**< Bad input units */
/** @} */ /*@} */
/** @} */
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define SIMULATECOHERENTGWH_MSGENUL "Unexpected null pointer in arguments" #define SIMULATECOHERENTGWH_MSGENUL "Unexpected null pointer in arguments"
#define SIMULATECOHERENTGWH_MSGEBAD "A sampling interval is (effectively) zero" #define SIMULATECOHERENTGWH_MSGEBAD "A sampling interval is (effectively) zero"
#define SIMULATECOHERENTGWH_MSGESIG "Input signal must specify amplitude a nd phase functions" #define SIMULATECOHERENTGWH_MSGESIG "Input signal must specify amplitude a nd phase functions"
#define SIMULATECOHERENTGWH_MSGEDIM "Amplitude must be a 2-dimensional vec tor" #define SIMULATECOHERENTGWH_MSGEDIM "Amplitude must be a 2-dimensional vec tor"
#define SIMULATECOHERENTGWH_MSGEMEM "Memory allocation error" #define SIMULATECOHERENTGWH_MSGEMEM "Memory allocation error"
#define SIMULATECOHERENTGWH_MSGEUNIT "Bad input units" #define SIMULATECOHERENTGWH_MSGEUNIT "Bad input units"
/** \endcond */ /** \endcond */
/** \ingroup SimulateCoherentGW_h /** This structure stores a representation of a plane
* This structure stores a representation of a plane
* gravitational wave propagating from a particular point on the sky. * gravitational wave propagating from a particular point on the sky.
* Several alternate representations are permitted to allow a more * Several alternate representations are permitted to allow a more
* natural characterization of quasiperiodic waveforms. * natural characterization of quasiperiodic waveforms.
* *
* \note It is permissible to set only some of the * \note It is permissible to set only some of the
* \c REAL4TimeSeries or \c REAL4TimeVectorSeries fields above, * \c REAL4TimeSeries or \c REAL4TimeVectorSeries fields above,
* but the waveform is treated as being zero except during those times * but the waveform is treated as being zero except during those times
* when either \c h, or both \c a and \c phi, are defined. * when either \c h, or both \c a and \c phi, are defined.
* Where \c shift is not specified, it is assumed that \f$\Phi\f$ is * Where \c shift is not specified, it is assumed that \f$\Phi\f$ is
* zero; where \c f is not specified but \c phi is, \f$f(t)\f$ can be * zero; where \c f is not specified but \c phi is, \f$f(t)\f$ can be
skipping to change at line 301 skipping to change at line 302
SWIGLAL_STRUCT(CoherentGW); SWIGLAL_STRUCT(CoherentGW);
SkyPosition position; /**< The location of the source in the sky; thi s should be in equatorial celestial coordinates, but routines may be able t o do the conversion */ SkyPosition position; /**< The location of the source in the sky; thi s should be in equatorial celestial coordinates, but routines may be able t o do the conversion */
REAL4 psi; /**< The polarization angle \f$\psi\f$, in radi ans, as defined in Appendix B of [\ref Anderson_W2000] */ REAL4 psi; /**< The polarization angle \f$\psi\f$, in radi ans, as defined in Appendix B of [\ref Anderson_W2000] */
REAL4TimeVectorSeries *h; /**< A time-sampled two-dimensional vector stor ing the waveforms \f$h_+(t)\f$ and \f$h_\times(t)\f$, in dimensionless stra in */ REAL4TimeVectorSeries *h; /**< A time-sampled two-dimensional vector stor ing the waveforms \f$h_+(t)\f$ and \f$h_\times(t)\f$, in dimensionless stra in */
REAL4TimeVectorSeries *a; /**< A time-sampled two-dimensional vector stor ing the amplitudes \f$A_1(t)\f$ and \f$A_2(t)\f$, in dimensionless strain * / REAL4TimeVectorSeries *a; /**< A time-sampled two-dimensional vector stor ing the amplitudes \f$A_1(t)\f$ and \f$A_2(t)\f$, in dimensionless strain * /
REAL4TimeSeries *f; /**< A time-sampled sequence storing the instan taneous frequency \f$f(t)\f$, in Hz. */ REAL4TimeSeries *f; /**< A time-sampled sequence storing the instan taneous frequency \f$f(t)\f$, in Hz. */
REAL8TimeSeries *phi; /**< A time-sampled sequence storing the phase function \f$\phi(t)\f$, in radians */ REAL8TimeSeries *phi; /**< A time-sampled sequence storing the phase function \f$\phi(t)\f$, in radians */
REAL4TimeSeries *shift; /**< A time-sampled sequence storing the polari zation shift \f$\Phi(t)\f$, in radians */ REAL4TimeSeries *shift; /**< A time-sampled sequence storing the polari zation shift \f$\Phi(t)\f$, in radians */
} CoherentGW; } CoherentGW;
/** \ingroup SimulateCoherentGW_h /** This structure contains information required to determine the response
* This structure contains information required to determine the response
* of a detector to a gravitational waveform. * of a detector to a gravitational waveform.
*/ */
typedef struct tagDetectorResponse { typedef struct tagDetectorResponse {
SWIGLAL_STRUCT(DetectorResponse); SWIGLAL_STRUCT(DetectorResponse);
COMPLEX8FrequencySeries *transfer; /**< The frequency-dependent transfe r function of the interferometer, in ADC counts per unit strain amplitude a t any given frequency; COMPLEX8FrequencySeries *transfer; /**< The frequency-dependent transfe r function of the interferometer, in ADC counts per unit strain amplitude a t any given frequency;
* if absent, the response will be given in raw strain rather than ADC output */ * if absent, the response will be given in raw strain rather than ADC output */
LALDetector *site; /**< A structure storing sit e and polarization information, used to compute the polarization response a nd the propagation delay; LALDetector *site; /**< A structure storing sit e and polarization information, used to compute the polarization response a nd the propagation delay;
* if absent, the response will be computed to the plus mode waveform with no time delay */ * if absent, the response will be computed to the plus mode waveform with no time delay */
EphemerisData *ephemerides; /**< A structure storing the positions, velocities, and accelerations of the Earth and Sun centres of m ass, used to compute EphemerisData *ephemerides; /**< A structure storing the positions, velocities, and accelerations of the Earth and Sun centres of m ass, used to compute
* the propagation delay to the sol ar system barycentre; * the propagation delay to the sol ar system barycentre;
skipping to change at line 329 skipping to change at line 329
} DetectorResponse; } DetectorResponse;
/* Function prototypes. */ /* Function prototypes. */
void void
LALSimulateCoherentGW( LALStatus *status, LALSimulateCoherentGW( LALStatus *status,
REAL4TimeSeries *output, REAL4TimeSeries *output,
CoherentGW *input, CoherentGW *input,
DetectorResponse *detector ); DetectorResponse *detector );
/*@}*/
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _SIMULATECOHERENTGW_H */ #endif /* _SIMULATECOHERENTGW_H */
 End of changes. 8 change blocks. 
11 lines changed or deleted 13 lines changed or added


 SkyCoordinates.h   SkyCoordinates.h 
skipping to change at line 35 skipping to change at line 35
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** \addtogroup SkyCoordinates_h /** \addtogroup SkyCoordinates_h
* @{*/
* @{
* \defgroup CelestialCoordinates_c Module CelestialCoordinates.c /** \name Error codes */
* \defgroup TerrestrialCoordinates_c Module TerrestrialCoordinates.c /*@{*/
* \defgroup SkyCoordinates_c Module SkyCoordinates.c
*
*/
/** \name Error codes *//**@{*/
#define SKYCOORDINATESH_ENUL 1 /**< Unexpected null pointer in argu ments */ #define SKYCOORDINATESH_ENUL 1 /**< Unexpected null pointer in argu ments */
#define SKYCOORDINATESH_ESYS 2 /**< Wrong coordinate system in inpu t */ #define SKYCOORDINATESH_ESYS 2 /**< Wrong coordinate system in inpu t */
#define SKYCOORDINATESH_EZERO 3 /**< Angular coordinates undefined a t origin */ #define SKYCOORDINATESH_EZERO 3 /**< Angular coordinates undefined a t origin */
#define SKYCOORDINATESH_ESING 4 /**< Point is inside singular ellips oid */ #define SKYCOORDINATESH_ESING 4 /**< Point is inside singular ellips oid */
/*@}*/ /*@}*/
/** \cond DONT_DOXYGEN */ /** \cond DONT_DOXYGEN */
#define SKYCOORDINATESH_MSGENUL "Unexpected null pointer in arguments" #define SKYCOORDINATESH_MSGENUL "Unexpected null pointer in arguments"
#define SKYCOORDINATESH_MSGESYS "Wrong coordinate system in input" #define SKYCOORDINATESH_MSGESYS "Wrong coordinate system in input"
#define SKYCOORDINATESH_MSGEZERO "Angular coordinates undefined at origin" #define SKYCOORDINATESH_MSGEZERO "Angular coordinates undefined at origin"
#define SKYCOORDINATESH_MSGESING "Point is inside singular ellipsoid" #define SKYCOORDINATESH_MSGESING "Point is inside singular ellipsoid"
/** \endcond */ /** \endcond */
/*---------- exported types ---------- */ /*---------- exported types ---------- */
/** This enumerated type is used to identify data as being in one of the /** This enumerated type is used to identify data as being in one of the
* coordinate systems discussed in \ref SkyCoordinates. */ * coordinate systems discussed in \ref SkyCoordinates_h. */
typedef enum { typedef enum {
COORDINATESYSTEM_HORIZON, /**< A horizon coordinate system. */ COORDINATESYSTEM_HORIZON, /**< A horizon coordinate system. */
COORDINATESYSTEM_GEOGRAPHIC, /**< The Earth-fixed geographic coordinate s ystem. */ COORDINATESYSTEM_GEOGRAPHIC, /**< The Earth-fixed geographic coordinate s ystem. */
COORDINATESYSTEM_EQUATORIAL, /**< The sky-fixed equatorial coordinate sys tem. */ COORDINATESYSTEM_EQUATORIAL, /**< The sky-fixed equatorial coordinate sys tem. */
COORDINATESYSTEM_ECLIPTIC, /**< The ecliptic coordinate system. */ COORDINATESYSTEM_ECLIPTIC, /**< The ecliptic coordinate system. */
COORDINATESYSTEM_GALACTIC /**< The galactic coordinate system. */ COORDINATESYSTEM_GALACTIC /**< The galactic coordinate system. */
} CoordinateSystem; } CoordinateSystem;
/** This structure stores the two spherical coordinates of a sky position; /** This structure stores the two spherical coordinates of a sky position;
* ie a generic latitude and longitude; the structure is not defined * ie a generic latitude and longitude; the structure is not defined
skipping to change at line 120 skipping to change at line 116
* may be <tt>NULL</tt> if one is neither co nverting to nor from * may be <tt>NULL</tt> if one is neither co nverting to nor from
* a horizon system. */ * a horizon system. */
LIGOTimeGPS *gpsTime; /**< The GPS time for conversions be tween Earth-fixed and LIGOTimeGPS *gpsTime; /**< The GPS time for conversions be tween Earth-fixed and
* sky-fixed coordinates; may be <tt>NULL</t t> if no such conversion * sky-fixed coordinates; may be <tt>NULL</t t> if no such conversion
* is required (or if one is transforming to or from horizon * is required (or if one is transforming to or from horizon
* coordinates and <tt>*zenith</tt> is given in the sky-fixed * coordinates and <tt>*zenith</tt> is given in the sky-fixed
* equatorial system). */ * equatorial system). */
} ConvertSkyParams; } ConvertSkyParams;
/** @} */ /*@}*/
/* ---------- Function prototypes ---------- */ /* ---------- Function prototypes ---------- */
void void
LALGalacticToEquatorial( LALStatus *, LALGalacticToEquatorial( LALStatus *,
SkyPosition *output, SkyPosition *output,
SkyPosition *input ); SkyPosition *input );
void void
LALEquatorialToGalactic( LALStatus *, LALEquatorialToGalactic( LALStatus *,
 End of changes. 3 change blocks. 
10 lines changed or deleted 6 lines changed or added


 Skymap.h   Skymap.h 
skipping to change at line 28 skipping to change at line 28
*/ */
#ifndef SKYMAP_H #ifndef SKYMAP_H
#define SKYMAP_H #define SKYMAP_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
/* Special cases for Python bindings of functions defined in this header.
* FIXME: add Octave section, or modify function declarations to work more
* smoothly with stock swiglal typemaps. */
#if defined(SWIG) && defined(SWIGPYTHON)
// special typemaps for XLALSkymapPlanConstruct
%typemap(in, noblock=1) (int n, int *detectors) (int i, PyObject *seq) {
seq = PySequence_Fast($input, "expected detectors to be a sequence");
if (!seq) SWIG_fail;
$1 = PySequence_Fast_GET_SIZE(seq);
$2 = ($2_type) calloc($1, sizeof($*2_type));
if (!$2)
{
Py_DECREF(seq);
SWIG_exception(SWIG_MemoryError,
"failed to allocate temporary memory");
}
for (i = 0; i < $1; i ++)
{
long longValue = PyInt_AsLong(PySequence_Fast_GET_ITEM(seq, i));
if (longValue == -1 && PyErr_Occurred())
{
Py_DECREF(seq);
SWIG_fail;
}
$2[i] = longValue;
}
Py_DECREF(seq);
}
%typemap(freearg, noblock=1) (int n, int *detectors) {
free($2);
}
// special typemaps for XLALSkymapKernelConstruct
// and XLALSkymapUncertainKernelConstruct
%typemap(in, noblock=1) double *wSw (int i, int n, PyObject *seq) {
seq = PySequence_Fast($input, "expected direction to be a sequence");
if (!seq) SWIG_fail;
n = PySequence_Fast_GET_SIZE(seq);
$1 = ($1_type) calloc(n, sizeof($*1_type));
if (!$1)
{
Py_DECREF(seq);
SWIG_exception(SWIG_MemoryError,
"failed to allocate temporary memory");
}
for (i = 0; i < n; i ++)
{
double doubleValue = PyFloat_AsDouble(PySequence_Fast_GET_ITEM(seq,
i));
if (doubleValue == -1 && PyErr_Occurred())
{
Py_DECREF(seq);
SWIG_fail;
}
$1[i] = doubleValue;
}
Py_DECREF(seq);
}
%typemap(freearg, noblock=1) double *wSw {
free($1);
}
%apply double *wSw { double *error };
// special typemaps for XLALSkymapApply
%typemap(in, noblock=1) double **xSw (PyObject *seq, int n, int i) {
seq = PySequence_Fast($input, "expected xSw to be a sequence");
if (!seq) SWIG_fail;
n = PySequence_Fast_GET_SIZE(seq);
$1 = ($1_type) calloc(n, sizeof($*1_type));
if (!$1)
{
Py_DECREF(seq);
SWIG_exception(SWIG_MemoryError,
"failed to allocate temporary memory");
}
for (i = 0; i < n; i ++)
{
PyObject *arr;
int len;
void *data;
arr = PyArray_CheckFromAny(PySequence_Fast_GET_ITEM(seq, i),
PyArray_DescrFromType(NPY_DOUBLE), 1, 1,
NPY_IN_ARRAY | NPY_NOTSWAPPED, NULL);
if (!arr)
{
Py_DECREF(seq);
SWIG_fail;
}
len = PyArray_SIZE(arr);
data = malloc(len * sizeof(double));
if (!data)
{
Py_DECREF(arr);
Py_DECREF(seq);
SWIG_exception(SWIG_MemoryError,
"failed to allocate temporary memory");
}
memcpy(data, PyArray_DATA(arr), len * sizeof(double));
Py_DECREF(arr);
$1[i] = ($*1_type) data;
}
Py_DECREF(seq);
}
%typemap(argout, noblock=1) double **xSw {
}
%typemap(freearg, noblock=1) double **xSw (int i) {
for (i = 0; i < n$argnum; i ++)
free($1[i]);
free($1);
}
%typemap(in, noblock=1, numinputs=0) double *logPosterior (double ret) {
$1 = &ret;
}
%typemap(argout, noblock=1) double *logPosterior {
$result = PyFloat_FromDouble(*$1);
}
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <lal/LALDetectors.h> #include <lal/LALDetectors.h>
// Manipulate log-represented values without overflowing // Manipulate log-represented values without overflowing
double XLALSkymapLogSumExp(double a, double b); double XLALSkymapLogSumExp(double a, double b);
double XLALSkymapLogTotalExp(double* begin, double* end); double XLALSkymapLogTotalExp(double* begin, double* end);
skipping to change at line 90 skipping to change at line 219
typedef struct tagXLALSkymapDirectionPropertiesType typedef struct tagXLALSkymapDirectionPropertiesType
{ {
SWIGLAL_STRUCT(XLALSkymapDirectionPropertiesType); SWIGLAL_STRUCT(XLALSkymapDirectionPropertiesType);
double f[XLALSKYMAP_N][2]; double f[XLALSKYMAP_N][2];
double delay[XLALSKYMAP_N]; double delay[XLALSKYMAP_N];
} XLALSkymapDirectionPropertiesType; } XLALSkymapDirectionPropertiesType;
void XLALSkymapDirectionPropertiesConstruct( void XLALSkymapDirectionPropertiesConstruct(
XLALSkymapPlanType* plan, XLALSkymapPlanType* plan,
double* direction, double direction[2],
XLALSkymapDirectionPropertiesType* properties XLALSkymapDirectionPropertiesType* properties
); );
// Struct to store reuseable pre-computed kernel for a specific direction, // Struct to store reuseable pre-computed kernel for a specific direction,
// power spectra, and sample rate // power spectra, and sample rate
typedef struct tagXLALSkymapKernelType typedef struct tagXLALSkymapKernelType
{ {
SWIGLAL_STRUCT(XLALSkymapKernelType); SWIGLAL_STRUCT(XLALSkymapKernelType);
double k[XLALSKYMAP_N][XLALSKYMAP_N]; double k[XLALSKYMAP_N][XLALSKYMAP_N];
 End of changes. 2 change blocks. 
1 lines changed or deleted 131 lines changed or added


 SphericalHarmonics.h   SphericalHarmonics.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**
* \defgroup SphericalHarmonics Spin-weighted Spherical Harmonics
* \ingroup support
* \author S.Fairhurst, B. Krishnan, L.Santamaria, C. Robinson
*
* \brief Library of spherical harmonic functions
*
*
*/
/* includes */ /* includes */
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#ifndef _SPHERICALHARMONICS_H #ifndef _SPHERICALHARMONICS_H
#define _SPHERICALHARMONICS_H #define _SPHERICALHARMONICS_H
#ifdef __cplusplus /* C++ protection. */ #ifdef __cplusplus /* C++ protection. */
extern "C" { extern "C" {
#endif #endif
/** /**
* Computes the (s)Y(l,m) spin-weighted spherical harmonic. * \addtogroup SphericalHarmonics_h
* \author S.Fairhurst, B. Krishnan, L.Santamaria, C. Robinson
* *
* From somewhere .... * \brief Library of Spin-weighted Spherical Harmonic functions
* *
* See also:
* Implements Equations (II.9)-(II.13) of
* D. A. Brown, S. Fairhurst, B. Krishnan, R. A. Mercer, R. K. Kopparapu,
* L. Santamaria, and J. T. Whelan,
* "Data formats for numerical relativity waves",
* arXiv:0709.0093v1 (2007).
* *
* Currently only supports s=-2, l=2,3,4,5,6,7,8 modes.
*/ */
COMPLEX16 XLALSpinWeightedSphericalHarmonic( /*@{*/
REAL8 theta, /**< polar angle (rad) */ COMPLEX16 XLALSpinWeightedSphericalHarmonic( REAL8 theta, REAL8 phi, int s,
REAL8 phi, /**< azimuthal angle (rad) int l, int m );
*/ int XLALScalarSphericalHarmonic( COMPLEX16 *y, UINT4 l, INT4 m, REAL8 thet
int s, /**< spin weight */ a, REAL8 phi );
int l, /**< mode number l */ INT4 XLALSphHarm ( COMPLEX16 *out, UINT4 L, INT4 M, REAL4 theta, REAL4
int m /**< mode number m */ phi );
); /*@}*/
/**
* Computes the scalar spherical harmonic \f$ Y_{lm}(\theta, \phi) \f$.
*/
int
XLALScalarSphericalHarmonic(
COMPLEX16 *y, /**< output */
UINT4 l, /**< value of l */
INT4 m, /**< value of m */
REAL8 theta, /**< angle theta */
REAL8 phi /**< angle phi */
);
/**
* Computes the spin 2 weighted spherical harmonic. This function is now
* deprecated and will be removed soon. All calls should be replaced with
* calls to XLALSpinWeightedSphHarm.
*/
INT4 XLALSphHarm ( COMPLEX16 *out, /**< output */
UINT4 L, /**< value of L */
INT4 M, /**< value of M */
REAL4 theta, /**< angle with respect to the z axis */
REAL4 phi /**< angle with respect to the x axis */
);
#ifdef __cplusplus #ifdef __cplusplus
} /* Close C++ protection */ } /* Close C++ protection */
#endif #endif
#endif /* _SPHERICALHARMONICS_H */ #endif /* _SPHERICALHARMONICS_H */
 End of changes. 6 change blocks. 
52 lines changed or deleted 11 lines changed or added


 StringVector.h   StringVector.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**
* \author Reinhard Prix
* \date 2008
* \defgroup StringVector StringVector
* \ingroup factories
* \brief Creation/destruction/manipulation API for ::LALStringVector objec
ts,
* which are just LAL 'vectors' of CHAR * pointers.
*
* \heading{Synopsis}
* \code
* #include <lal/StringVector.h>
* \endcode
*
*/
#ifndef _STRINGVECTOR_H /* Double-include protection. */ #ifndef _STRINGVECTOR_H /* Double-include protection. */
#define _STRINGVECTOR_H #define _STRINGVECTOR_H
/* C++ protection. */ /* C++ protection. */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/*---------- INCLUDES ----------*/ /*---------- INCLUDES ----------*/
#include <stdarg.h> #include <stdarg.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
/**
* \author Reinhard Prix
* \date 2008
* \addtogroup StringVector_h
*
* \brief Creation/destruction/manipulation API for ::LALStringVector objec
ts,
* which are just LAL-type vectors of CHAR * pointers.
*
* \heading{Synopsis}
* \code
* #include <lal/StringVector.h>
* \endcode
*
*/
/*@{*/
/*---------- DEFINES ----------*/ /*---------- DEFINES ----------*/
/*----- Error-codes -----*/ /*----- Error-codes -----*/
/*---------- exported types ----------*/ /*---------- exported types ----------*/
/*---------- Global variables ----------*/ /*---------- Global variables ----------*/
/*---------- exported prototypes [API] ----------*/ /*---------- exported prototypes [API] ----------*/
#ifdef SWIG /* SWIG interface directives */ #ifdef SWIG /* SWIG interface directives */
/* disable keywords arguments for XLALCreateStringVector */ /* disable keywords arguments for XLALCreateStringVector */
%feature("kwargs", 0) XLALCreateStringVector; %feature("kwargs", 0) XLALCreateStringVector;
skipping to change at line 84 skipping to change at line 85
#endif /* SWIG */ #endif /* SWIG */
LALStringVector *XLALCreateStringVector ( const CHAR *str1, ... ); LALStringVector *XLALCreateStringVector ( const CHAR *str1, ... );
LALStringVector *XLALAppendString2Vector (LALStringVector *vect, const CHAR *string ); LALStringVector *XLALAppendString2Vector (LALStringVector *vect, const CHAR *string );
void XLALDestroyStringVector ( LALStringVector *vect ); void XLALDestroyStringVector ( LALStringVector *vect );
int XLALSortStringVector (LALStringVector *strings); int XLALSortStringVector (LALStringVector *strings);
LALStringVector *XLALParseCSV2StringVector ( const CHAR *CSVlist ); LALStringVector *XLALParseCSV2StringVector ( const CHAR *CSVlist );
INT4 XLALFindStringInVector ( const char *needle, const LALStringVector *ha ystack ); INT4 XLALFindStringInVector ( const char *needle, const LALStringVector *ha ystack );
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
/* C++ protection. */ /* C++ protection. */
#endif /* Double-include protection. */ #endif /* Double-include protection. */
 End of changes. 3 change blocks. 
16 lines changed or deleted 19 lines changed or added


 TimeDelay.h   TimeDelay.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/**
* \defgroup TimeDelay_h TimeDelay
* \ingroup date
* \brief Provides routines to compute time delay between two detectors
*
* \heading{Synopsis}
* \code
* #include <lal/TimeDelay.h>
* \endcode
*/
#ifndef _TIMEDELAY_H #ifndef _TIMEDELAY_H
#define _TIMEDELAY_H #define _TIMEDELAY_H
#include <lal/Date.h> #include <lal/Date.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
/**
* \addtogroup TimeDelay_h
* \author David Chin, Kipp Cannon
*
* \brief Provides routines to compute time delay between two detectors
*
* \heading{Synopsis}
* \code
* #include <lal/TimeDelay.h>
* \endcode
\heading{Description}
The function XLALTimeDelayFromEarthCenter() Computes difference in arrival
time of the same signal at detector and at center of Earth-fixed frame.
The function XLALLightTravelTime() computes the light travel time between t
wo detectors and returns the answer in \c INT8 nanoseconds.
The function XLALPopulateAccuracyParams() creates an instance of ::Inspiral
AccuracyList populated with
the light-travel times between the detectors, using just the previous funct
ion.
The function XLALPopulateAccuracyParamsExt(), however, creates an instance
of ::InspiralAccuracyList
populated with the \c real travel time of a putative signal for the given t
ime and the given sky
location (in right ascension and declination, both given in degrees).
\heading{Algorithm}
TBA. See Anderson, <em>et al.</em> [\ref ABCF2000] in the mean time.
Note that GPS time is passed with both the detectors. The GPS time of the
second detector is \e ignored, and the GPS time for the first detector
is taken to be the time when the signal arrives at the center of the
Earth. In practice, this time will be the time of detection of a signal at
the first detector, but, as in Anderson, <em>et al.</em>, we make this
approximation as it makes little difference. This time is used to compute
a GMST which gives us the orientation of the Earth.
*/
/*@{*/
/* /*
* Function prototypes * Function prototypes
*/ */
double double
XLALArrivalTimeDiff( XLALArrivalTimeDiff(
const double detector1_earthfixed_xyz_metres[3], const double detector1_earthfixed_xyz_metres[3],
const double detector2_earthfixed_xyz_metres[3], const double detector2_earthfixed_xyz_metres[3],
const double source_right_ascension_radians, const double source_right_ascension_radians,
const double source_declination_radians, const double source_declination_radians,
skipping to change at line 68 skipping to change at line 96
); );
REAL8 REAL8
XLALTimeDelayFromEarthCenter( XLALTimeDelayFromEarthCenter(
const double detector_earthfixed_xyz_metres[3], const double detector_earthfixed_xyz_metres[3],
double source_right_ascension_radians, double source_right_ascension_radians,
double source_declination_radians, double source_declination_radians,
const LIGOTimeGPS *gpstime const LIGOTimeGPS *gpstime
); );
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* !defined _TIMEDELAY_H */ #endif /* !defined _TIMEDELAY_H */
 End of changes. 3 change blocks. 
11 lines changed or deleted 46 lines changed or added


 TimeFreqFFT.h   TimeFreqFFT.h 
skipping to change at line 59 skipping to change at line 59
* Perform time-to-frequency and frequency-to-time fast Fourier * Perform time-to-frequency and frequency-to-time fast Fourier
* transforms. Also provides a function to compute mean and median power * transforms. Also provides a function to compute mean and median power
* spectra with user specified windowning. * spectra with user specified windowning.
* *
* The definition of the Fourier transform is \f$ e^{2 \pi i f t} \f$ * The definition of the Fourier transform is \f$ e^{2 \pi i f t} \f$
* and the inline equation version of that is * and the inline equation version of that is
* \f[ * \f[
* \tilde{h}_k = \sum * \tilde{h}_k = \sum
* \f] * \f]
* *
*/ *
* \heading{Description}
*
* The routines LALTimeFreqRealFFT() and LALTimeFreqComplexFFT()
* transform time series \f$h_j\f$, \f$0\le j<n\f$, into a frequency series
* \f$\tilde{h}_k\f$. For LALTimeFreqRealFFT(),
* \f[
* \tilde{h}_k = \Delta t \times H_k \;
* \mbox{for } 0\le k\le\lfloor n/2\rfloor
* \f]
* The packing covers the range from dc (inclusive) to Nyquist (inclusive i
f
* \f$n\f$ is even).
* For LALTimeFreqComplexFFT(),
* \f[
* \tilde{h}_k = \Delta t \left\{
* \begin{array}{ll}
* H_{k+\lfloor(n+1)/2\rfloor} &
* \mbox{for } 0\le k<\lfloor n/2\rfloor, \\
* H_{k-\lfloor n/2\rfloor} &
* \mbox{for } \lfloor n/2\rfloor\le k<n. \\
* \end{array}
* \right.
* \f]
* The packing covers the range from negative Nyquist (inclusive if \f$n\f$
is
* even) up to (but not including) positive Nyquist.
* Here \f$H_k\f$ is the DFT of \f$h_j\f$:
* \f[
* H_k = \sum_{j=0}^{n-1} h_j e^{-2\pi ijk/n}.
* \f]
* The units of \f$\tilde{h}_k\f$ are equal to the units of \f$h_j\f$ times
seconds.
*
* The routines LALFreqTimeRealFFT() and LALFreqTimeComplexFFT()
* perform the inverse transforms from \f$\tilde{h}_k\f$ back to \f$h_j\f$.
This is
* done by shuffling the data, performing the reverse DFT, and multiplying
by
* \f$\Delta f\f$.
*
* The routine LALREAL4AverageSpectrum() uses Welch's method to compute
* the average power spectrum of the time series stored in the input struct
ure
* \c tSeries and return it in the output structure \c fSeries. A
* Welch PSD estimate is defined by an FFT length, overlap length, choice o
f
* window function and averaging method. These are specified in the
* parameter structure; the FFT length is obtained from the length of the
* \c REAL4Window in the parameters.
*
* On entry the parameter structure \c params must contain a valid
* \c REAL4Window, an integer that determines the overlap as described
* below and a forward FFT plan for transforming data of the specified
* window length into the time domain. The method used to compute the
* average must also be set.
*
* If the length of the window is \f$N\f$, then the FFT length is defined t
o be
* \f$N/2-1\f$. The input data of length \f$M\f$ is divided into \f$i\f$ se
gments which
* overlap by \f$o\f$, where
* \f{equation}{
* i = \frac{M-o}{N-o}.
* \f}
*
* The PSD of each segment is obtained. The Welch PSD estimate is the avera
ge
* of these \f$i\f$ sub-estimates. The average is computed using the mean
or
* median method, as specified in the parameter structure.
*
* Note: the return PSD estimate is a one-sided power spectral density
* normalized as defined in the conventions document. When the averaging
* method is choosen to be mean and the window type Hann, the result is the
* same as returned by the LDAS datacondAPI <tt>psd()</tt> action for a rea
l
* sequence without detrending.
*
* \heading{Operating Instructions}
*
* \code
* const UINT4 n = 65536;
* const REAL4 dt = 1.0 / 16384.0;
* static LALStatus status; compute average power spectrum
* static REAL4TimeSeries x;
* static COMPLEX8FrequencySeries X;
* static COMPLEX8TimeSeries z;
* static COMPLEX8FrequencySeries Z;
* RealFFTPlan *fwdRealPlan = NULL;
* RealFFTPlan *revRealPlan = NULL;
* ComplexFFTPlan *fwdComplexPlan = NULL;
* ComplexFFTPlan *revComplexPlan = NULL;
*
* LALSCreateVector( &status, &x.data, n );
* LALCCreateVector( &status, &X.data, n / 2 + 1 );
* LALCCreateVector( &status, &z.data, n );
* LALCCreateVector( &status, &Z.data, n );
* LALCreateForwardRealFFTPlan( &status, &fwdRealPlan, n, 0 );
* LALCreateReverseRealFFTPlan( &status, &revRealPlan, n, 0 );
* LALCreateForwardComplexFFTPlan( &status, &fwdComplexPlan, n, 0 );
* LALCreateReverseComplexFFTPlan( &status, &revComplexPlan, n, 0 );
*
* x.f0 = 0;
* x.deltaT = dt;
* x.sampleUnits = lalMeterUnit;
* strncpy( x.name, "x", sizeof( x.name ) );
*
* z.f0 = 0;
* z.deltaT = dt;
* z.sampleUnits = lalVoltUnit;
* strncpy( z.name, "z", sizeof( z.name ) );
*
* <assign data>
*
* LALTimeFreqRealFFT( &status, &X, &x, fwdRealPlan );
* LALFreqTimeRealFFT( &status, &x, &X, revRealPlan );
* LALTimeFreqComplexFFT( &status, &Z, &z, fwdComplexPlan );
* LALFreqTimeComplexFFT( &status, &z, &Z, revComplexPlan );
*
* LALDestroyRealFFTPlan( &status, &fwdRealPlan );
* LALDestroyRealFFTPlan( &status, &revRealPlan );
* LALDestroyComplexFFTPlan( &status, &fwdComplexPlan );
* LALDestroyComplexFFTPlan( &status, &revComplexPlan );
* LALCDestroyVector( &status, &Z.data );
* LALCDestroyVector( &status, &z.data );
* LALCDestroyVector( &status, &X.data );
* LALSDestroyVector( &status, &x.data );
* \endcode
*
* \heading{Notes}
*
* <ol>
* <li> The routines do not presently work properly with heterodyned data,
* i.e., the original time series data should have \c f0 equal to zero.
* </li></ol>
*
*
*
*/
/*@{*/ /*@{*/
/**\name Error Codes */ /*@{*/ /**\name Error Codes */
/*@{*/
#define TIMEFREQFFTH_ENULL 1 /**< Null pointer */ #define TIMEFREQFFTH_ENULL 1 /**< Null pointer */
#define TIMEFREQFFTH_ESIZE 2 /**< Invalid size */ #define TIMEFREQFFTH_ESIZE 2 /**< Invalid size */
#define TIMEFREQFFTH_ERATE 4 /**< Invalid rate */ #define TIMEFREQFFTH_ERATE 4 /**< Invalid rate */
#define TIMEFREQFFTH_ESIGN 4 /**< Incorrect plan sign */ #define TIMEFREQFFTH_ESIGN 4 /**< Incorrect plan sign */
#define TIMEFREQFFTH_EALLOC 16 /**< Pointer has already been allocated, sho uld be null */ #define TIMEFREQFFTH_EALLOC 16 /**< Pointer has already been allocated, sho uld be null */
#define TIMEFREQFFTH_EPOSARG 32 /**< Argument must be positive */ #define TIMEFREQFFTH_EPOSARG 32 /**< Argument must be positive */
#define TIMEFREQFFTH_EMALLOC 64 /**< Malloc failure */ #define TIMEFREQFFTH_EMALLOC 64 /**< Malloc failure */
#define TIMEFREQFFTH_EINCOMP 128/**< Incompatible arguments */ #define TIMEFREQFFTH_EINCOMP 128/**< Incompatible arguments */
#define TIMEFREQFFTH_ENNUL 256 /**< Non-null pointer */ #define TIMEFREQFFTH_ENNUL 256 /**< Non-null pointer */
#define TIMEFREQFFTH_EZSEG 512 /**< Segment length is zero */ #define TIMEFREQFFTH_EZSEG 512 /**< Segment length is zero */
 End of changes. 2 change blocks. 
2 lines changed or deleted 142 lines changed or added


 TimeSeries.h   TimeSeries.h 
skipping to change at line 32 skipping to change at line 32
#include <stddef.h> #include <stddef.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/* COMPLEX8 prototypes */ /** \addtogroup TimeSeriesManipulation
\author Kipp Cannon <kipp@gravity.phys.uwm.edu>
void XLALDestroyCOMPLEX8TimeSeries (
COMPLEX8TimeSeries *series
);
COMPLEX8TimeSeries *XLALCreateCOMPLEX8TimeSeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
COMPLEX8TimeSeries *XLALCutCOMPLEX8TimeSeries (
const COMPLEX8TimeSeries *series,
size_t first,
size_t length
);
COMPLEX8TimeSeries *XLALResizeCOMPLEX8TimeSeries (
COMPLEX8TimeSeries *series,
int first,
size_t length
);
COMPLEX8TimeSeries *XLALShrinkCOMPLEX8TimeSeries (
COMPLEX8TimeSeries *series,
size_t first,
size_t length
);
COMPLEX8TimeSeries *XLALAddCOMPLEX8TimeSeries (
COMPLEX8TimeSeries *arg1,
const COMPLEX8TimeSeries *arg2
);
/* COMPLEX16 prototypes */
void XLALDestroyCOMPLEX16TimeSeries (
COMPLEX16TimeSeries *series
);
COMPLEX16TimeSeries *XLALCreateCOMPLEX16TimeSeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
COMPLEX16TimeSeries *XLALCutCOMPLEX16TimeSeries (
const COMPLEX16TimeSeries *series,
size_t first,
size_t length
);
COMPLEX16TimeSeries *XLALResizeCOMPLEX16TimeSeries (
COMPLEX16TimeSeries *series,
int first,
size_t length
);
COMPLEX16TimeSeries *XLALShrinkCOMPLEX16TimeSeries (
COMPLEX16TimeSeries *series,
size_t first,
size_t length
);
COMPLEX16TimeSeries *XLALAddCOMPLEX16TimeSeries (
COMPLEX16TimeSeries *arg1,
const COMPLEX16TimeSeries *arg2
);
/* REAL4 prototypes */
void XLALDestroyREAL4TimeSeries (
REAL4TimeSeries *series
);
REAL4TimeSeries *XLALCreateREAL4TimeSeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
REAL4TimeSeries *XLALCutREAL4TimeSeries (
const REAL4TimeSeries *series,
size_t first,
size_t length
);
REAL4TimeSeries *XLALResizeREAL4TimeSeries (
REAL4TimeSeries *series,
int first,
size_t length
);
REAL4TimeSeries *XLALShrinkREAL4TimeSeries (
REAL4TimeSeries *series,
size_t first,
size_t length
);
REAL4TimeSeries *XLALAddREAL4TimeSeries (
REAL4TimeSeries *arg1,
const REAL4TimeSeries *arg2
);
/* REAL8 prototypes */
void XLALDestroyREAL8TimeSeries (
REAL8TimeSeries *series
);
REAL8TimeSeries *XLALCreateREAL8TimeSeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
REAL8TimeSeries *XLALCutREAL8TimeSeries (
const REAL8TimeSeries *series,
size_t first,
size_t length
);
REAL8TimeSeries *XLALResizeREAL8TimeSeries (
REAL8TimeSeries *series,
int first,
size_t length
);
REAL8TimeSeries *XLALShrinkREAL8TimeSeries (
REAL8TimeSeries *series,
size_t first,
size_t length
);
REAL8TimeSeries *XLALAddREAL8TimeSeries (
REAL8TimeSeries *arg1,
const REAL8TimeSeries *arg2
);
/* INT2 prototypes */
void XLALDestroyINT2TimeSeries (
INT2TimeSeries *series
);
INT2TimeSeries *XLALCreateINT2TimeSeries (
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
INT2TimeSeries *XLALCutINT2TimeSeries (
const INT2TimeSeries *series,
size_t first,
size_t length
);
INT2TimeSeries *XLALResizeINT2TimeSeries (
INT2TimeSeries *series,
int first,
size_t length
);
INT2TimeSeries *XLALShrinkINT2TimeSeries (
INT2TimeSeries *series,
size_t first,
size_t length
);
INT2TimeSeries *XLALAddINT2TimeSeries (
INT2TimeSeries *arg1,
const INT2TimeSeries *arg2
);
/* INT4 prototypes */
void XLALDestroyINT4TimeSeries ( \brief This is a suite of functions for creating, destroying, and manipulat
INT4TimeSeries *series ing LAL
); time series. One pair of functions (the XLAL version and its LAL
counterpart) is available for each method and series type. For example
<tt>XLALCreateREAL4TimeSeries()</tt> is available for creating time series
of \c REAL4 data, and the LAL-stype wrapper
<tt>LALCreateREAL4TimeSeries()</tt> is provided which is equivalent to the
XLAL version in all respects except that it adheres to the LAL calling
conventions (eg.\ it takes a \c LALStatus pointer as its first
argument, its return type is \c void, etc.).
INT4TimeSeries *XLALCreateINT4TimeSeries ( */
const CHAR *name, /*@{*/
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
INT4TimeSeries *XLALCutINT4TimeSeries ( /** \name Creation Functions
const INT4TimeSeries *series,
size_t first,
size_t length
);
INT4TimeSeries *XLALResizeINT4TimeSeries ( \heading{Synopsis}
INT4TimeSeries *series,
int first,
size_t length
);
INT4TimeSeries *XLALShrinkINT4TimeSeries ( \code
INT4TimeSeries *series, #include <lal/TimeSeries.h>
size_t first,
size_t length
);
INT4TimeSeries *XLALAddINT4TimeSeries ( XLALCreate<timeseriestype>()
INT4TimeSeries *arg1, LALCreate<timeseriestype>()
const INT4TimeSeries *arg2 \endcode
);
/* INT8 prototypes */ \heading{Description}
void XLALDestroyINT8TimeSeries ( These functions create LAL frequency series. An XLAL function returns a
INT8TimeSeries *series pointer to the newly created series or \c NULL on failure. The LAL
); counterpart accepts the address of a pointer which it fills with the
address of the newly created series or \c NULL on failure.
Additionally, the LAL wrapper provides standard LAL-style error checking
via a \c LALStatus pointer.
*/
/*@{*/
COMPLEX8TimeSeries *XLALCreateCOMPLEX8TimeSeries ( const CHAR *name, const
LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, siz
e_t length );
COMPLEX16TimeSeries *XLALCreateCOMPLEX16TimeSeries ( const CHAR *name, cons
t LIGOTimeGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, s
ize_t length );
REAL4TimeSeries *XLALCreateREAL4TimeSeries ( const CHAR *name, const LIGOTi
meGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t le
ngth );
REAL8TimeSeries *XLALCreateREAL8TimeSeries ( const CHAR *name, const LIGOTi
meGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t le
ngth );
INT2TimeSeries *XLALCreateINT2TimeSeries ( const CHAR *name, const LIGOTime
GPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t leng
th );
INT4TimeSeries *XLALCreateINT4TimeSeries ( const CHAR *name, const LIGOTime
GPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t leng
th );
INT8TimeSeries *XLALCreateINT8TimeSeries ( const CHAR *name, const LIGOTime
GPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t leng
th );
UINT2TimeSeries *XLALCreateUINT2TimeSeries ( const CHAR *name, const LIGOTi
meGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t le
ngth );
UINT4TimeSeries *XLALCreateUINT4TimeSeries ( const CHAR *name, const LIGOTi
meGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t le
ngth );
UINT8TimeSeries *XLALCreateUINT8TimeSeries ( const CHAR *name, const LIGOTi
meGPS *epoch, REAL8 f0, REAL8 deltaT, const LALUnit *sampleUnits, size_t le
ngth );
/*@}*/
INT8TimeSeries *XLALCreateINT8TimeSeries ( /** \name Destruction Functions
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
INT8TimeSeries *XLALCutINT8TimeSeries ( \heading{Synopsis}
const INT8TimeSeries *series, \code
size_t first, #include <lal/TimeSeries.h>
size_t length
);
INT8TimeSeries *XLALResizeINT8TimeSeries ( XLALDestroy<timeseriestype>()
INT8TimeSeries *series, LALDestroy<timeseriestype>()
int first, \endcode
size_t length
);
INT8TimeSeries *XLALShrinkINT8TimeSeries ( \heading{Description}
INT8TimeSeries *series,
size_t first,
size_t length
);
INT8TimeSeries *XLALAddINT8TimeSeries ( These functions free all memory associated with a LAL time series. It is
INT8TimeSeries *arg1, safe to pass \c NULL to these functions.
const INT8TimeSeries *arg2
);
/* UINT2 prototypes */ */
/*@{*/
void XLALDestroyCOMPLEX8TimeSeries ( COMPLEX8TimeSeries *series );
void XLALDestroyCOMPLEX16TimeSeries ( COMPLEX16TimeSeries *series );
void XLALDestroyREAL4TimeSeries ( REAL4TimeSeries *series );
void XLALDestroyREAL8TimeSeries ( REAL8TimeSeries *series );
void XLALDestroyINT2TimeSeries ( INT2TimeSeries *series );
void XLALDestroyINT4TimeSeries ( INT4TimeSeries *series );
void XLALDestroyINT8TimeSeries ( INT8TimeSeries *series );
void XLALDestroyUINT2TimeSeries ( UINT2TimeSeries *series );
void XLALDestroyUINT4TimeSeries ( UINT4TimeSeries *series );
void XLALDestroyUINT8TimeSeries ( UINT8TimeSeries *series );
/*@}*/
void XLALDestroyUINT2TimeSeries ( /** \name Cutting Functions
UINT2TimeSeries *series
);
UINT2TimeSeries *XLALCreateUINT2TimeSeries ( \heading{Synopsis}
const CHAR *name,
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
UINT2TimeSeries *XLALCutUINT2TimeSeries ( \code
const UINT2TimeSeries *series, #include <lal/TimeSeries.h>
size_t first,
size_t length
);
UINT2TimeSeries *XLALResizeUINT2TimeSeries ( XLALCut<timeseriestype>()
UINT2TimeSeries *series, LALCut<timeseriestype>()
int first, \endcode
size_t length
);
UINT2TimeSeries *XLALShrinkUINT2TimeSeries ( \heading{Description}
UINT2TimeSeries *series,
size_t first,
size_t length
);
UINT2TimeSeries *XLALAddUINT2TimeSeries ( These functions create a new time series by extracting a section of an
UINT2TimeSeries *arg1, existing time series.
const UINT2TimeSeries *arg2 */
); /*@{*/
COMPLEX8TimeSeries *XLALCutCOMPLEX8TimeSeries ( const COMPLEX8TimeSeries *s
eries, size_t first, size_t length );
COMPLEX16TimeSeries *XLALCutCOMPLEX16TimeSeries ( const COMPLEX16TimeSeries
*series, size_t first, size_t length );
REAL4TimeSeries *XLALCutREAL4TimeSeries ( const REAL4TimeSeries *series, si
ze_t first, size_t length );
REAL8TimeSeries *XLALCutREAL8TimeSeries ( const REAL8TimeSeries *series, si
ze_t first, size_t length );
INT2TimeSeries *XLALCutINT2TimeSeries ( const INT2TimeSeries *series, size_
t first, size_t length );
INT4TimeSeries *XLALCutINT4TimeSeries ( const INT4TimeSeries *series, size_
t first, size_t length );
INT8TimeSeries *XLALCutINT8TimeSeries ( const INT8TimeSeries *series, size_
t first, size_t length );
UINT2TimeSeries *XLALCutUINT2TimeSeries ( const UINT2TimeSeries *series, si
ze_t first, size_t length );
UINT4TimeSeries *XLALCutUINT4TimeSeries ( const UINT4TimeSeries *series, si
ze_t first, size_t length );
UINT8TimeSeries *XLALCutUINT8TimeSeries ( const UINT8TimeSeries *series, si
ze_t first, size_t length );
/*@}*/
/* UINT4 prototypes */ /** \name Resizing Functions
void XLALDestroyUINT4TimeSeries ( \heading{Synopsis}
UINT4TimeSeries *series
);
UINT4TimeSeries *XLALCreateUINT4TimeSeries ( \code
const CHAR *name, #include <lal/TimeSeries.h>
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
UINT4TimeSeries *XLALCutUINT4TimeSeries ( XLALResize<timeseriestype>()
const UINT4TimeSeries *series, LALResize<timeseriestype>()
size_t first, XLALShrink<timeseriestype>()
size_t length LALShrink<timeseriestype>()
); \endcode
UINT4TimeSeries *XLALResizeUINT4TimeSeries ( \heading{Description}
UINT4TimeSeries *series,
int first,
size_t length
);
UINT4TimeSeries *XLALShrinkUINT4TimeSeries ( These functions resize an existing time series. The new time series will
UINT4TimeSeries *series, have the given length, and its contents will consist of that part of the
size_t first, original time series that started at sample first. If first is negative,
size_t length then the new time series is padded at the start by that many samples. The
); time series' epoch is adjusted appropriately.
*/
/*@{*/
COMPLEX8TimeSeries *XLALResizeCOMPLEX8TimeSeries ( COMPLEX8TimeSeries *seri
es, int first, size_t length );
COMPLEX16TimeSeries *XLALResizeCOMPLEX16TimeSeries ( COMPLEX16TimeSeries *s
eries, int first, size_t length );
REAL4TimeSeries *XLALResizeREAL4TimeSeries ( REAL4TimeSeries *series, int f
irst, size_t length );
REAL8TimeSeries *XLALResizeREAL8TimeSeries ( REAL8TimeSeries *series, int f
irst, size_t length );
INT2TimeSeries *XLALResizeINT2TimeSeries ( INT2TimeSeries *series, int firs
t, size_t length );
INT4TimeSeries *XLALResizeINT4TimeSeries ( INT4TimeSeries *series, int firs
t, size_t length );
INT8TimeSeries *XLALResizeINT8TimeSeries ( INT8TimeSeries *series, int firs
t, size_t length );
UINT2TimeSeries *XLALResizeUINT2TimeSeries ( UINT2TimeSeries *series, int f
irst, size_t length );
UINT4TimeSeries *XLALResizeUINT4TimeSeries ( UINT4TimeSeries *series, int f
irst, size_t length );
UINT8TimeSeries *XLALResizeUINT8TimeSeries ( UINT8TimeSeries *series, int f
irst, size_t length );
UINT4TimeSeries *XLALAddUINT4TimeSeries ( COMPLEX8TimeSeries *XLALShrinkCOMPLEX8TimeSeries ( COMPLEX8TimeSeries *seri
UINT4TimeSeries *arg1, es, size_t first, size_t length );
const UINT4TimeSeries *arg2 COMPLEX16TimeSeries *XLALShrinkCOMPLEX16TimeSeries ( COMPLEX16TimeSeries *s
); eries, size_t first, size_t length );
REAL4TimeSeries *XLALShrinkREAL4TimeSeries ( REAL4TimeSeries *series, size_
t first, size_t length );
REAL8TimeSeries *XLALShrinkREAL8TimeSeries ( REAL8TimeSeries *series, size_
t first, size_t length );
INT2TimeSeries *XLALShrinkINT2TimeSeries ( INT2TimeSeries *series, size_t f
irst, size_t length );
INT4TimeSeries *XLALShrinkINT4TimeSeries ( INT4TimeSeries *series, size_t f
irst, size_t length );
INT8TimeSeries *XLALShrinkINT8TimeSeries ( INT8TimeSeries *series, size_t f
irst, size_t length );
UINT2TimeSeries *XLALShrinkUINT2TimeSeries ( UINT2TimeSeries *series, size_
t first, size_t length );
UINT4TimeSeries *XLALShrinkUINT4TimeSeries ( UINT4TimeSeries *series, size_
t first, size_t length );
UINT8TimeSeries *XLALShrinkUINT8TimeSeries ( UINT8TimeSeries *series, size_
t first, size_t length );
/*@}*/
/* UINT8 prototypes */ /** \name Addition Functions
void XLALDestroyUINT8TimeSeries ( \heading{Synopsis}
UINT8TimeSeries *series \code
); #include <lal/TimeSeries.h>
UINT8TimeSeries *XLALCreateUINT8TimeSeries ( XLALAdd<timeseriestype>()
const CHAR *name, \endcode
const LIGOTimeGPS *epoch,
REAL8 f0,
REAL8 deltaT,
const LALUnit *sampleUnits,
size_t length
);
UINT8TimeSeries *XLALCutUINT8TimeSeries ( \heading{Description}
const UINT8TimeSeries *series,
size_t first,
size_t length
);
UINT8TimeSeries *XLALResizeUINT8TimeSeries ( These functions add the second argument to the first argument, returning a
UINT8TimeSeries *series, pointer to the first argument on success or NULL on failure. The two
int first, series must have the same heterodyne frequency and time resolution, and
size_t length have units that differ only by a dimensionless factor.
);
UINT8TimeSeries *XLALShrinkUINT8TimeSeries ( */
UINT8TimeSeries *series, /*@{*/
size_t first, COMPLEX8TimeSeries *XLALAddCOMPLEX8TimeSeries ( COMPLEX8TimeSeries *arg1, c
size_t length onst COMPLEX8TimeSeries *arg2 );
); COMPLEX16TimeSeries *XLALAddCOMPLEX16TimeSeries ( COMPLEX16TimeSeries *arg1
, const COMPLEX16TimeSeries *arg2 );
REAL4TimeSeries *XLALAddREAL4TimeSeries ( REAL4TimeSeries *arg1, const REAL
4TimeSeries *arg2 );
REAL8TimeSeries *XLALAddREAL8TimeSeries ( REAL8TimeSeries *arg1, const REAL
8TimeSeries *arg2 );
INT2TimeSeries *XLALAddINT2TimeSeries ( INT2TimeSeries *arg1, const INT2Tim
eSeries *arg2 );
INT4TimeSeries *XLALAddINT4TimeSeries ( INT4TimeSeries *arg1, const INT4Tim
eSeries *arg2 );
INT8TimeSeries *XLALAddINT8TimeSeries ( INT8TimeSeries *arg1, const INT8Tim
eSeries *arg2 );
UINT2TimeSeries *XLALAddUINT2TimeSeries ( UINT2TimeSeries *arg1, const UINT
2TimeSeries *arg2 );
UINT4TimeSeries *XLALAddUINT4TimeSeries ( UINT4TimeSeries *arg1, const UINT
4TimeSeries *arg2 );
UINT8TimeSeries *XLALAddUINT8TimeSeries ( UINT8TimeSeries *arg1, const UINT
8TimeSeries *arg2 );
/*@}*/
UINT8TimeSeries *XLALAddUINT8TimeSeries ( /*@}*/
UINT8TimeSeries *arg1,
const UINT8TimeSeries *arg2
);
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _TIMESERIES_H */ #endif /* _TIMESERIES_H */
 End of changes. 35 change blocks. 
345 lines changed or deleted 210 lines changed or added


 Units.h   Units.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
/** #ifndef _UNITS_H
\author J. T. Whelan <john.whelan@ligo.org> #define _UNITS_H
\addtogroup Units_h
\brief Provides prototypes for manipulation of units and declares /* remove SWIG interface directives */
\c extern constants for the basic and derived SI units. #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
\heading{Synopsis} #include <lal/LALStdlib.h>
\code
#include <lal/Units.h> #ifdef __cplusplus
\endcode extern "C" {
#endif
/** \addtogroup Units_h
\author J. T. Whelan <john.whelan@ligo.org>
\brief Provides prototypes for manipulation of units and declares
\c extern constants for the basic and derived SI units.
\heading{Synopsis}
\code
#include <lal/Units.h>
\endcode
This header provides prototypes for functions to manipulate This header provides prototypes for functions to manipulate
the \c LALUnit structure. It also defines \c extern the \c LALUnit structure. It also defines \c extern
constants for a set of predefined units, which are designed to make constants for a set of predefined units, which are designed to make
the structure easier to use. For instance, to determine whether a the structure easier to use. For instance, to determine whether a
quantity has units of strain per root hertz, one constructs the unit quantity has units of strain per root hertz, one constructs the unit
"strain per root hertz" from the predefined \c lalStrainUnit and &quot;strain per root hertz&quot; from the predefined \c lalStrainUnit and
\c lalHertzUnit constant structures using the \c lalHertzUnit constant structures using the
LALUnitRaise() and LALUnitMultiply() functions, then LALUnitRaise() and LALUnitMultiply() functions, then
compares that to the unit structure in question using the compares that to the unit structure in question using the
LALUnitCompare() function. LALUnitCompare() function.
The LALUnit datatype itself is included in the header The LALUnit datatype itself is included in the header
\ref LALDatatypes.h, and defines a unit in terms of an integer \ref LALDatatypes.h, and defines a unit in terms of an integer
power of ten multiplier along with rational powers of the basic SI power of ten multiplier along with rational powers of the basic SI
units (meters, kilograms, seconds, Amperes, and Kelvins) and two units (meters, kilograms, seconds, Amperes, and Kelvins) and two
custom units (strain and ADC counts). custom units (strain and ADC counts).
@{ \heading{XLAL interface to Units.h functions}
\defgroup UnitDefs_c Module UnitDefs.c
\defgroup UnitNormalize_c Module UnitNormalize.c
\defgroup UnitRaise_c Module UnitRaise.c
\defgroup UnitMultiply_c Module UnitMultiply.c
\defgroup UnitCompare_c Module UnitCompare.c
\defgroup UnitXLALFunctions XLAL Functions
@}
*/
/**
\addtogroup UnitXLALFunctions
\brief XLAL interface to Unit.h functions
\heading{Synopsis}
\code
#include <lal/Units.h>
\endcode
\heading{Description}
XLALUnitAsString() converts a ::LALUnit structure into a character XLALUnitAsString() converts a ::LALUnit structure into a character
string of maximum length \c length (including NUL termination) string of maximum length \c length (including NUL termination)
representation of the units. The inverse function, XLALParseUnitString() representation of the units. The inverse function, XLALParseUnitString()
parses a character string to produce a \c LALUnit structure; if parses a character string to produce a \c LALUnit structure; if
\c output is \c NULL, memory for the output is allocated. If the input \c output is \c NULL, memory for the output is allocated. If the input
\c string is \c NULL or is empty then the output units are \c string is \c NULL or is empty then the output units are
dimensionless: lalDimensionlessUnit. dimensionless: lalDimensionlessUnit.
XLALUnitNormalize() puts a ::LALUnit structure into normal form XLALUnitNormalize() puts a ::LALUnit structure into normal form
skipping to change at line 115 skipping to change at line 109
on failure, \c XLALParseUnitString returns \c NULL and sets on failure, \c XLALParseUnitString returns \c NULL and sets
\c ::xlalErrno to one of the following values: \c #XLAL_ENOMEM \c ::xlalErrno to one of the following values: \c #XLAL_ENOMEM
if the routine was unable to allocate memory for the output or if the routine was unable to allocate memory for the output or
\c #XLAL_EFAILED if the routine was unable to parse the unit string. \c #XLAL_EFAILED if the routine was unable to parse the unit string.
XLALUnitNormalize() returns 0 upon success or \c #XLAL_FAILURE XLALUnitNormalize() returns 0 upon success or \c #XLAL_FAILURE
if the input pointer is \c NULL, in which case \c xlalErrno if the input pointer is \c NULL, in which case \c xlalErrno
is set to \c #XLAL_EFAULT is set to \c #XLAL_EFAULT
XLALUnitCompare() returns 0 if the the normal form of the two unit XLALUnitCompare() returns 0 if the the normal form of the two unit
structures are the same or > 0 if they are different. It returns structures are the same or \> 0 if they are different. It returns
\c #XLAL_FAILURE and \c ::xlalErrno is set to \c #XLAL_EFAULT if \c #XLAL_FAILURE and \c ::xlalErrno is set to \c #XLAL_EFAULT if
one of the input pointers is \c NULL. one of the input pointers is \c NULL.
XLALUnitMultiply(), XLALUnitRaiseRAT4(), XLALUnitRaiseINT2(), XLALUnitSquar e() and XLALUnitMultiply(), XLALUnitRaiseRAT4(), XLALUnitRaiseINT2(), XLALUnitSquar e() and
XLALUnitSqrt() all return a pointer to the output unit structure XLALUnitSqrt() all return a pointer to the output unit structure
\c output upon success or \c NULL upon failure. If there is \c output upon success or \c NULL upon failure. If there is
a failure, \c ::xlalErrno is set to one of the following values: a failure, \c ::xlalErrno is set to one of the following values:
\c #XLAL_EFAULT if one of the input pointers is \c NULL, \c #XLAL_EFAULT if one of the input pointers is \c NULL,
\c #XLAL_ERANGE if one of the unit powers exceeds the allowed range, \c #XLAL_ERANGE if one of the unit powers exceeds the allowed range,
or \c #XLAL_EINVAL (for the raise functions only) if the unit power or \c #XLAL_EINVAL (for the raise functions only) if the unit power
would not be an integer. would not be an integer.
*/
#ifndef _UNITS_H @{
#define _UNITS_H \defgroup UnitDefs_c Module UnitDefs.c
\defgroup UnitNormalize_c Module UnitNormalize.c
/* remove SWIG interface directives */ \defgroup UnitRaise_c Module UnitRaise.c
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) \defgroup UnitMultiply_c Module UnitMultiply.c
#define SWIGLAL_STRUCT(...) \defgroup UnitCompare_c Module UnitCompare.c
#endif @}
*/
#include <lal/LALStdlib.h> /*@{*/
#ifdef __cplusplus
extern "C" {
#endif
/** \ingroup Units_h /** \name Error Codes */
* @{ /*@{*/
*/
/**\name Error Codes */ /*@{*/
#define UNITSH_ENULLPIN 1 /**< Null pointer to input */ #define UNITSH_ENULLPIN 1 /**< Null pointer to input */
#define UNITSH_ENULLPOUT 2 /**< Null pointer to output */ #define UNITSH_ENULLPOUT 2 /**< Null pointer to output */
#define UNITSH_ENULLPD 3 /**< Null pointer to data member of vector */ #define UNITSH_ENULLPD 3 /**< Null pointer to data member of vector */
#define UNITSH_ENULLPPARAM 4 /**< Null pointer to parameters */ #define UNITSH_ENULLPPARAM 4 /**< Null pointer to parameters */
#define UNITSH_ESTRINGSIZE 5 /**< Output string too short */ #define UNITSH_ESTRINGSIZE 5 /**< Output string too short */
#define UNITSH_EOVERFLOW 6 /**< Exponent outside of (U)INT2 bou nds */ #define UNITSH_EOVERFLOW 6 /**< Exponent outside of (U)INT2 bou nds */
#define UNITSH_ENONINT 7 /**< Non-integer power of ten */ #define UNITSH_ENONINT 7 /**< Non-integer power of ten */
#define UNITSH_EPARSE 8 /**< Error parsing unit string */ #define UNITSH_EPARSE 8 /**< Error parsing unit string */
/*@}*/ /*@}*/
skipping to change at line 179 skipping to change at line 166
* LALUnitRaise(). * LALUnitRaise().
*/ */
typedef struct typedef struct
tagRAT4 tagRAT4
{ {
SWIGLAL_STRUCT(RAT4); SWIGLAL_STRUCT(RAT4);
INT2 numerator; /**< The numerator */ INT2 numerator; /**< The numerator */
UINT2 denominatorMinusOne; /**< One less than the denominator */ UINT2 denominatorMinusOne; /**< One less than the denominator */
} RAT4; } RAT4;
/** @} */ /** Consists of a pair of unit structures; used as an input structure for
* the LALUnitCompare() and LALUnitMultiply() functions.
*/
typedef struct
tagLALUnitPair
{
SWIGLAL_STRUCT(LALUnitPair);
const LALUnit *unitOne; /**< The first unit */
const LALUnit *unitTwo; /**< The second unit */
}
LALUnitPair;
/*@}*/
/* end: Units_h */
/********************************************************* /*********************************************************
* * * *
* Functions to manipulate unit structures * * Functions to manipulate unit structures *
* * * *
*********************************************************/ *********************************************************/
/* XLAL routines */ /* XLAL routines */
/** \addtogroup UnitXLALFunctions
* @{
*/
char * XLALUnitAsString( char *string, UINT4 length, const LALUnit *input ) ; char * XLALUnitAsString( char *string, UINT4 length, const LALUnit *input ) ;
LALUnit * XLALParseUnitString( LALUnit *output, const char *string ); LALUnit * XLALParseUnitString( LALUnit *output, const char *string );
int XLALUnitNormalize( LALUnit *unit ); int XLALUnitNormalize( LALUnit *unit );
int XLALUnitCompare( const LALUnit *unit1, const LALUnit *unit2 ); int XLALUnitCompare( const LALUnit *unit1, const LALUnit *unit2 );
LALUnit * XLALUnitMultiply( LALUnit *output, const LALUnit *unit1, LALUnit * XLALUnitMultiply( LALUnit *output, const LALUnit *unit1,
const LALUnit *unit2 ); const LALUnit *unit2 );
LALUnit * XLALUnitDivide( LALUnit *output, const LALUnit *unit1, LALUnit * XLALUnitDivide( LALUnit *output, const LALUnit *unit1,
const LALUnit *unit2 ); const LALUnit *unit2 );
LALUnit * XLALUnitRaiseRAT4( LALUnit *output, const LALUnit *input, LALUnit * XLALUnitRaiseRAT4( LALUnit *output, const LALUnit *input,
const RAT4 *power ); const RAT4 *power );
LALUnit * XLALUnitRaiseINT2( LALUnit *output, const LALUnit *input, LALUnit * XLALUnitRaiseINT2( LALUnit *output, const LALUnit *input,
INT2 power ); INT2 power );
LALUnit * XLALUnitSquare( LALUnit *output, const LALUnit *input ); LALUnit * XLALUnitSquare( LALUnit *output, const LALUnit *input );
LALUnit * XLALUnitSqrt( LALUnit *output, const LALUnit *input ); LALUnit * XLALUnitSqrt( LALUnit *output, const LALUnit *input );
LALUnit * XLALUnitInvert( LALUnit *output, const LALUnit *input ); LALUnit * XLALUnitInvert( LALUnit *output, const LALUnit *input );
REAL8 XLALUnitPrefactor(const LALUnit *unit); REAL8 XLALUnitPrefactor(const LALUnit *unit);
int XLALUnitIsDimensionless(const LALUnit *unit); int XLALUnitIsDimensionless(const LALUnit *unit);
REAL8 XLALUnitRatio(const LALUnit *unit1, const LALUnit *unit2); REAL8 XLALUnitRatio(const LALUnit *unit1, const LALUnit *unit2);
/** @} */
/* LALUnitNormalize() will reduce the rational powers in the basic unit
* exponents, e.g. converting 2/2 to 1/1 and 3/6 to 1/2.
*/
void LALUnitNormalize (LALStatus *status, LALUnit *output,
const LALUnit *input);
/* Several functions take two Unit variables as input, so need the
* following structure.
*/
/* Consists of a pair of unit structures; used as an input structure for
* the LALUnitCompare() and LALUnitMultiply() functions.
*/
typedef struct
tagLALUnitPair
{
SWIGLAL_STRUCT(LALUnitPair);
const LALUnit *unitOne; /**< The first unit */
const LALUnit *unitTwo; /**< The second unit */
}
LALUnitPair;
/* LALUnitMultiply will multiply together two Unit variables and /* Obsolete LAL-interface functions */
* output their product; it will call LALUnitNormalize. void LALUnitNormalize (LALStatus *status, LALUnit *output, const LALUnit *i
*/ nput);
void LALUnitMultiply (LALStatus *status, LALUnit *output, void LALUnitMultiply (LALStatus *status, LALUnit *output, const LALUnitPair
const LALUnitPair *input); *input);
void LALUnitCompare (LALStatus *status, BOOLEAN *output, const LALUnitPair
/* LALUnitCompare will compare two Unit variables and return true if *input);
* they are the equivalent (the same power of ten offset as well as void LALUnitRaise (LALStatus *status, LALUnit *output, const LALUnit *input
* equivalent ratioanl powers of the base units). , const RAT4 *power);
*/ void LALUnitAsString (LALStatus *status, CHARVector *output, const LALUnit
void LALUnitCompare (LALStatus *status, BOOLEAN *output, *input);
const LALUnitPair *input); void LALParseUnitString ( LALStatus *status, LALUnit *output, const CHARVec
tor *input );
/* LALUnitRaise() will raise a unit structure to a rational power; the
* most common choices will presumably be -1, 2, and 1/2. An error
* occurs if input->powerOfTen is not evenly divisible by the
* denominator of the specified power
*/
void LALUnitRaise (LALStatus *status, LALUnit *output,
const LALUnit *input, const RAT4 *power);
/** Converts a LALUnit structure into a human-readable text form.
*/
void LALUnitAsString (LALStatus *status, CHARVector *output,
const LALUnit *input);
void
LALParseUnitString ( LALStatus *status,
LALUnit *output,
const CHARVector *input );
#ifndef SWIG /* exclude from SWIG interface */ #ifndef SWIG /* exclude from SWIG interface */
enum enumLALUnitNameSize { enum enumLALUnitNameSize {
LALUnitNameSize = sizeof("strain") LALUnitNameSize = sizeof("strain")
}; };
enum enumLALUnitTextSize { enum enumLALUnitTextSize {
LALUnitTextSize = sizeof("10^-32768 m^-32768/32767 kg^-32768/32767 " LALUnitTextSize = sizeof("10^-32768 m^-32768/32767 kg^-32768/32767 "
"s^-32768/32767 A^-32768/32767 " "s^-32768/32767 A^-32768/32767 "
"K^-32768/32767 strain^-32768/32767 " "K^-32768/32767 strain^-32768/32767 "
"count^-32768/32767") "count^-32768/32767")
 End of changes. 13 change blocks. 
107 lines changed or deleted 63 lines changed or added


 VectorIndexRange.h   VectorIndexRange.h 
/* -*- C -*- */ /* -*- C -*- */
/**
* \author David Chin <dwchin@umich.edu> +1-734-709-9119
* \addtogroup VectorIndexRange_h
*
* \section TODOref Header \ref VectorIndexRange.h
*
* \brief Routines to slice up vectors/sequences by specifying starting and
ending indices, inclusive.
*
* VectorIndexHole() is "complementary" to VectorIndexRange(), in the sense
that
* it returns the two segments of the vector that would remain after Vector
IndexRange() acts.
*
* \heading{Synopsis}
* \code
* #include <lal/VectorIndexRange.h>
* \endcode
*
* @{
*/
#include <math.h> #include <math.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/SeqFactories.h> #include <lal/SeqFactories.h>
#include <lal/AVFactories.h> #include <lal/AVFactories.h>
#ifndef __LALVECTORINDEXRANGE_H__ #ifndef __LALVECTORINDEXRANGE_H__
#define __LALVECTORINDEXRANGE_H__ #define __LALVECTORINDEXRANGE_H__
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT #define SWIGLAL_STRUCT
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* C++ */ #endif /* C++ */
/**\name Error Codes */ /*@{*/ /**
* \addtogroup VectorIndexRange_h
* \author David Chin <dwchin@umich.edu> +1-734-709-9119
*
* \brief Routines to slice up vectors/sequences by specifying starting and
ending indices, inclusive.
*
* VectorIndexHole() is "complementary" to VectorIndexRange(), in the sense
that
* it returns the two segments of the vector that would remain after Vector
IndexRange() acts.
*
* \heading{Synopsis}
* \code
* #include <lal/VectorIndexRange.h>
* \endcode
*/
/*@{*/
/**\name Error Codes */
/*@{*/
#define VECTORINDEXRANGEH_EARG 1 /**< Error parsing command-line argu ments */ #define VECTORINDEXRANGEH_EARG 1 /**< Error parsing command-line argu ments */
#define VECTORINDEXRANGEH_ECHK 2 /**< Error checking failed to catch bad data */ #define VECTORINDEXRANGEH_ECHK 2 /**< Error checking failed to catch bad data */
#define VECTORINDEXRANGEH_EFLS 3 /**< Incorrect answer for valid data */ #define VECTORINDEXRANGEH_EFLS 3 /**< Incorrect answer for valid data */
#define VECTORINDEXRANGEH_EUSE 4 /**< Bad user-entered data */ #define VECTORINDEXRANGEH_EUSE 4 /**< Bad user-entered data */
#define VECTORINDEXRANGEH_ENULL 5 /**< Null Pointer */ #define VECTORINDEXRANGEH_ENULL 5 /**< Null Pointer */
#define VECTORINDEXRANGEH_EALOC 6 /**< Memory Allocation Error */ #define VECTORINDEXRANGEH_EALOC 6 /**< Memory Allocation Error */
#define VECTORINDEXRANGEH_EFPMS 7 /**< Filter Parameter Structure Erro r */ #define VECTORINDEXRANGEH_EFPMS 7 /**< Filter Parameter Structure Erro r */
#define VECTORINDEXRANGEH_ENUMZ 8 /**< Incorrect number of command lin e arguments */ #define VECTORINDEXRANGEH_ENUMZ 8 /**< Incorrect number of command lin e arguments */
#define VECTORINDEXRANGEH_ELNTH 9 /**< Vector/Array of Improper Length */ #define VECTORINDEXRANGEH_ELNTH 9 /**< Vector/Array of Improper Length */
#define VECTORINDEXRANGEH_ENNUL 10 /**< Non-Null Pointer that should be NULL */ #define VECTORINDEXRANGEH_ENNUL 10 /**< Non-Null Pointer that should be NULL */
/** @}*/ /*@}*/
/** @}*/
/** \cond DONT_DOXYGEN */
#define VECTORINDEXRANGEH_MSGEARG "Error parsing command-line arguments" #define VECTORINDEXRANGEH_MSGEARG "Error parsing command-line arguments"
#define VECTORINDEXRANGEH_MSGECHK "Error checking failed to catch bad data" #define VECTORINDEXRANGEH_MSGECHK "Error checking failed to catch bad data"
#define VECTORINDEXRANGEH_MSGEFLS "Incorrect answer for valid data" #define VECTORINDEXRANGEH_MSGEFLS "Incorrect answer for valid data"
#define VECTORINDEXRANGEH_MSGEUSE "Bad user-entered data" #define VECTORINDEXRANGEH_MSGEUSE "Bad user-entered data"
#define VECTORINDEXRANGEH_MSGENULL "Null Pointer." #define VECTORINDEXRANGEH_MSGENULL "Null Pointer."
#define VECTORINDEXRANGEH_MSGEALOC "Memory Allocation Error" #define VECTORINDEXRANGEH_MSGEALOC "Memory Allocation Error"
#define VECTORINDEXRANGEH_MSGEFPMS "Filter Parameter Structure Error" #define VECTORINDEXRANGEH_MSGEFPMS "Filter Parameter Structure Error"
#define VECTORINDEXRANGEH_MSGENUMZ "Incorrect number of command line argume nts" #define VECTORINDEXRANGEH_MSGENUMZ "Incorrect number of command line argume nts"
#define VECTORINDEXRANGEH_MSGELNTH "Vector/Array of Improper Length" #define VECTORINDEXRANGEH_MSGELNTH "Vector/Array of Improper Length"
#define VECTORINDEXRANGEH_MSGENNUL "Non-Null Pointer that should be NULL" #define VECTORINDEXRANGEH_MSGENNUL "Non-Null Pointer that should be NULL"
/** \endcond */
/* typedefs */ /* ---------- typedefs ---------- */
/* CHAR */ /* CHAR */
typedef struct typedef struct
tagCHARVectorPair { tagCHARVectorPair {
SWIGLAL_STRUCT(CHARVectorPair); SWIGLAL_STRUCT(CHARVectorPair);
CHARVector **head; CHARVector **head;
CHARVector **tail; CHARVector **tail;
} CHARVectorPair; } CHARVectorPair;
/* INT2 */ /* INT2 */
skipping to change at line 154 skipping to change at line 152
} COMPLEX8VectorPair; } COMPLEX8VectorPair;
/* COMPLEX16 */ /* COMPLEX16 */
typedef struct typedef struct
tagCOMPLEX16VectorPair { tagCOMPLEX16VectorPair {
SWIGLAL_STRUCT(COMPLEX16VectorPair); SWIGLAL_STRUCT(COMPLEX16VectorPair);
COMPLEX16Vector **head; COMPLEX16Vector **head;
COMPLEX16Vector **tail; COMPLEX16Vector **tail;
} COMPLEX16VectorPair; } COMPLEX16VectorPair;
/* Function protos */ /* ---------- Function protos ---------- */
/* CHAR */ /* CHAR */
void LALCHARVectorIndexRange ( LALStatus *status, void LALCHARVectorIndexRange ( LALStatus *status,
CHARVector **result, CHARVector **result,
CHARVector *v, CHARVector *v,
const UINT4Vector *indexVector ); const UINT4Vector *indexVector );
void LALCHARVectorIndexHole ( LALStatus *status, void LALCHARVectorIndexHole ( LALStatus *status,
CHARVectorPair *result_pair, CHARVectorPair *result_pair,
CHARVector *v, CHARVector *v,
const UINT4Vector *indexVector ); const UINT4Vector *indexVector );
skipping to change at line 266 skipping to change at line 264
/* COMPLEX16 */ /* COMPLEX16 */
void LALZVectorIndexRange ( LALStatus *status, void LALZVectorIndexRange ( LALStatus *status,
COMPLEX16Vector **result, COMPLEX16Vector **result,
COMPLEX16Vector *v, COMPLEX16Vector *v,
const UINT4Vector *indexVector ); const UINT4Vector *indexVector );
void LALZVectorIndexHole ( LALStatus *status, void LALZVectorIndexHole ( LALStatus *status,
COMPLEX16VectorPair *result_pair, COMPLEX16VectorPair *result_pair,
COMPLEX16Vector *v, COMPLEX16Vector *v,
const UINT4Vector *indexVector ); const UINT4Vector *indexVector );
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ */ #endif /* C++ */
#endif /* __LALVECTORINDEXRANGE_H__ */ #endif /* __LALVECTORINDEXRANGE_H__ */
 End of changes. 8 change blocks. 
28 lines changed or deleted 28 lines changed or added


 VectorOps.h   VectorOps.h 
skipping to change at line 20 skipping to change at line 20
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details. * GNU General Public License for more details.
* *
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with with program; see the file COPYING. If not, write to the * along with with program; see the file COPYING. If not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, * Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA * MA 02111-1307 USA
*/ */
#ifndef _VECTOROPS_H
#define _VECTOROPS_H
#include <lal/LALDatatypes.h>
#if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
/** /**
* \addtogroup VectorOps_h * \addtogroup VectorOps_h
* \author J. D. E. Creighton, T. D. Creighton, A. M. Sintes * \author J. D. E. Creighton, T. D. Creighton, A. M. Sintes
* *
* \brief Basic vector manipulation operations. * \brief Basic vector manipulation operations.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/VectorOps.h> * #include <lal/VectorOps.h>
* \endcode * \endcode
* *
* @{ * @{
* \defgroup VectorMultiply_c Module VectorMultiply.c * \defgroup VectorMultiply_c Module VectorMultiply.c
* \defgroup VectorPolar_c Module VectorPolar.c * \defgroup VectorPolar_c Module VectorPolar.c
*
*/ */
#ifndef _VECTOROPS_H /** \name Error Codes */
#define _VECTOROPS_H /*@{*/
#include <lal/LALDatatypes.h>
#if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
/** \name Error Codes
* @{*/
#define VECTOROPSH_ENULL 1 /**< Null pointer */ #define VECTOROPSH_ENULL 1 /**< Null pointer */
#define VECTOROPSH_ESIZE 2 /**< Invalid input size */ #define VECTOROPSH_ESIZE 2 /**< Invalid input size */
#define VECTOROPSH_ESZMM 4 /**< Size mismatch */ #define VECTOROPSH_ESZMM 4 /**< Size mismatch */
#define VECTOROPSH_ESAME 8 /**< Input/Output data vectors are the same */ #define VECTOROPSH_ESAME 8 /**< Input/Output data vectors are the same */
/** @}*/ /*@}*/
/** @}*/ /*@}*/
#define VECTOROPSH_MSGENULL "Null pointer" #define VECTOROPSH_MSGENULL "Null pointer"
#define VECTOROPSH_MSGESIZE "Invalid input size" #define VECTOROPSH_MSGESIZE "Invalid input size"
#define VECTOROPSH_MSGESZMM "Size mismatch" #define VECTOROPSH_MSGESZMM "Size mismatch"
#define VECTOROPSH_MSGESAME "Input/Output data vectors are the same" #define VECTOROPSH_MSGESAME "Input/Output data vectors are the same"
/* ---------- Function prototypes ---------- */
/* /*
* *
* XLAL Routines. * XLAL Routines.
* *
*/ */
/* sigle precision */ /* sigle precision */
COMPLEX8Vector * XLALCCVectorDivide( COMPLEX8Vector *out, const COMPLEX8Vec tor *in1, const COMPLEX8Vector *in2 ); COMPLEX8Vector * XLALCCVectorDivide( COMPLEX8Vector *out, const COMPLEX8Vec tor *in1, const COMPLEX8Vector *in2 );
COMPLEX8Vector * XLALCCVectorMultiply( COMPLEX8Vector *out, const COMPLEX8V ector *in1, const COMPLEX8Vector *in2 ); COMPLEX8Vector * XLALCCVectorMultiply( COMPLEX8Vector *out, const COMPLEX8V ector *in1, const COMPLEX8Vector *in2 );
COMPLEX8Vector * XLALCCVectorMultiplyConjugate( COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2 ); COMPLEX8Vector * XLALCCVectorMultiplyConjugate( COMPLEX8Vector *out, const COMPLEX8Vector *in1, const COMPLEX8Vector *in2 );
 End of changes. 5 change blocks. 
16 lines changed or deleted 17 lines changed or added


 Window.h   Window.h 
skipping to change at line 35 skipping to change at line 35
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** \addtogroup window */ /**
* \defgroup Window_h Header Window.h
* \ingroup pkg_window
* \brief This header file provides routines and structures to create and s
tore window functions (also called a taper,
* lag window, or apodization function).
\heading{Synopsis}
\code
#include <lal/Window.h>
\endcode
\heading{Description}
These functions create or destroy a time-domain window function in a vector
of specified length. If you wish to construct a custom window, call
<tt>XLALCreateRectangularREAL8Window()</tt> (or the \c REAL4
version), then replace the samples inside it with your own, and update the
\c sumofsquares and \c sum elements. If the window function
proves useful, consider adding it here so that others can benefit.
It is convenient to describe the windows as functions on the normalized
domain \f$y \in [-1, 1]\f$. The window is zero outside this domain. The
window functions defined in this package are as follows.
\heading{Rectangle}
\f{equation}{
w(y)
= 1.
\f}</dd>
\heading{Hann}
\f{equation}{
w(y)
= \cos^2 \frac{\pi}{2} y.
\f}</dd>
\heading{Welch}
\f{equation}{
w(y)
= 1 - y^2.
\f}</dd>
\heading{Bartlett}
\f{equation}{
w(y)
= 1 - |y|.
\f}</dd>
\heading{Parzen}
\f{equation}{
w(y)
= \left\{ \begin{array}{ll}
1 - 6 y^2 (1 - |y|) & |y| \leq 1 / 2, \\
2 (1 - |y|)^3 & |y| > 1 / 2.
\end{array}\right.
\f}</dd>
\heading{Papoulis}
\f{equation}{
w(y)
= \frac{1}{\pi} \sin \pi |y| + (1 - |y|) \cos \pi |y|.
\f}</dd>
\heading{Hamming}
\f{equation}{
w(y)
= 0.08 + 0.92 \cos^{2} \frac{\pi}{2} y.
\f}
This is the same as the Hann window, but with an additional DC bias, or
&quot;foot,&quot; of 0.08.</dd>
\heading{Kaiser}
\f{equation}{
w(y)
= I_0 \left( \beta \sqrt{1-y^2} \right) / I_0(\beta),
\f}
where \f$I_0(x)\f$ is the \f$0\f$th order, modified Bessel function of the
first
kind. The shape parameter \f$\beta \in [0, \infty]\f$ sets the sharpness o
f
the central peak. \f$\beta = 0\f$ yields the rectangle window, \f$\beta
\rightarrow \infty\f$ yields a \f$\delta\f$ function with a single non-zero
sample in the middle. This window is difficult to compute for large
\f$\beta\f$, and an asymptotic approximation is used for \f$\beta \ge 705\f
$. A
linearly-interpolated transition occurs between \f$\beta = 695\f$ and \f$\b
eta =
705\f$. Finite-difference derivatives of the window with respect to \f$\be
ta\f$
are unlikely to work well in this regime.</dd>
\heading{Creighton}
\f{equation}{
w(y)
= \exp \left( -\beta \frac{y^2}{1 - y^2} \right).
\f}
This window function is based on a fairly standard \f$C_{\infty}\f$ test
function used in distribution theory, e.g.\ <em>Green's Functions and
Boundary Value Problems</em> [\ref stakgold79], by Stakgold. The shape par
ameter
\f$\beta \in [0, \infty]\f$ sets the sharpness of the central peak. \f$\be
ta =
0\f$ yields the rectangle window, \f$\beta \rightarrow \infty\f$ yields a
\f$\delta\f$ function with a single non-zero sample in the middle.</dd>
\heading{Tukey}
\f{equation}{
w(y)
= \left\{ \begin{array}{ll}
\sin^2 \left[ \frac{\pi}{2} (|y| - 1) / \beta \right] & |y| \geq 1 -
\beta,
\\
1 & |y| < 1 - \beta.
\end{array} \right.
\f}
The shape parameter \f$\beta \in [0, 1]\f$ sets what fraction of the window
is
spanned by the tapers. \f$\beta = 0\f$ yields the rectangle window, \f$\be
ta =
1\f$ yields the Hann window.</dd>
\heading{Gauss}
\f{equation}{
w(y)
= \exp \left( -\frac{1}{2} \beta^{2} y^{2} \right).
\f}
The shape parameter \f$\beta \in [0, \infty]\f$ sets the sharpness of the
central peak. \f$\beta = 0\f$ yields the rectangle window, \f$\beta \right
arrow \infty\f$ yields a \f$\delta\f$ function with a single non-zero sampl
e in the
middle.
These window functions are shown in Fig.\figref{f_window_t}, showing variou
s windows as functions of the normalized
independend variable \f$y\f$, choosing \f$\beta = 6\f$ for the Kaiser windo
w, \f$\beta = 2\f$ for the Creighton window,
\f$\beta = 0.5\f$ for the Tukey window, and \f$\beta = 3\f$ for the Gauss w
indow.
\floatfig{htbp,f_window_t}
\image html window_t.png "Fig. [f_window_t]: Various windows as functions
of the normalized independend variable y"
\image latex window_t.pdf "Various windows as functions of the normalized i
ndependend variable y"
For a vector of length \f$L\f$ (an integer), the mapping from integer array
index \f$i\f$ to normalized co-ordinate \f$y\f$ is
\f{equation}{
y(i)
= \left\{ \begin{array}{ll}
0 & L \le 1, \\
2 i / (L - 1) - 1 & L > 1,
\end{array} \right.
\f}
where \f$0 \le i < L\f$, and floating-point division is used. This agrees
with
J. G. Proakis and D. G. Manolakis, <em>Digital Signal Processing</em>
[\ref pm95], and \c MatLab. The first sample is \f$y = -1\f$, the last
sample is \f$y = +1\f$. For odd-lengthed vectors, the middle sample is \f$
y =
0\f$, while for even-lengthed vectors \f$y = 0\f$ occurs half-way between t
he two
middle samples. Substituting \f$y(i)\f$ into the definitions of the window
functions above yields \f$w(i)\f$, the value of the window function at the
integer sample \f$i\f$.
The Fourier transforms of the windows are shown as functions of \f$1 / y\f$
in
Fig.\figref{f_window_f}, showing frequency behaviour of various windows as
functions
of the inverse of the normalized independend variable \f$y\f$, choosing \f$
\beta = 6\f$
for the Kaiser window, \f$\beta = 2\f$ for the Creighton window, \f$\beta =
0.5\f$ for
the Tukey window, and \f$\beta = 3\f$ for the Gauss window.
\floatfig{htbp,f_window_f}
\image html window_f.png "Fig. [f_window_f]: Frequency behaviour of variou
s windows as functions of the inverse of the normalized independend variabl
e y"
\image latex window_f.pdf "Frequency behaviour of various windows as functi
ons of the inverse of the normalized independend variable y"
Since the Fourier transform of windowed data is the Fourier transform of
the data convolved with the Fourier transform of the window,
Fig.\figref{f_window_f} is the major guideline for selecting a window. One
can see that windows with a narrow central lobe tend to have higher
sidelobes, and windows which suppress their low-order sidelobes tend to
have more power in the high-order sidelobes. The choice of window thus
depends on whether one is trying to resolve nearby spectral features of
comparable magnitude (suggesting a rectangular or a Welch window), to
reduce spectral bias and low-order sidelobes (a Hamming or Kaiser window),
or to measure a broad spectrum with a large dynamical range (a Creighton or
a Papoulis window).
*/
/*@{*/ /*@{*/
/** Structure for storing REAL4 window function data, providing storage for a sequence of samples /** Structure for storing REAL4 window function data, providing storage for a sequence of samples
* as well as metadata about the window such as the sum-of-squarse of the s amples * as well as metadata about the window such as the sum-of-squarse of the s amples
*/ */
typedef struct tagREAL4Window { typedef struct tagREAL4Window {
SWIGLAL_STRUCT(REAL4Window); SWIGLAL_STRUCT(REAL4Window);
REAL4Sequence *data; /**< The window function samples */ REAL4Sequence *data; /**< The window function samples */
REAL8 sumofsquares; /**< The sum of the squares of the w indow function samples */ REAL8 sumofsquares; /**< The sum of the squares of the w indow function samples */
REAL8 sum; /**< The sum of the window function samples */ REAL8 sum; /**< The sum of the window function samples */
 End of changes. 1 change blocks. 
1 lines changed or deleted 198 lines changed or added


 ZPGFilter.h   ZPGFilter.h 
skipping to change at line 93 skipping to change at line 93
/*@{*/ /*@{*/
/** /**
@{ @{
\defgroup CreateZPGFilter_c Module CreateZPGFilter.c \defgroup CreateZPGFilter_c Module CreateZPGFilter.c
\defgroup DestroyZPGFilter_c Module DestroyZPGFilter.c \defgroup DestroyZPGFilter_c Module DestroyZPGFilter.c
\defgroup BilinearTransform_c Module BilinearTransform.c \defgroup BilinearTransform_c Module BilinearTransform.c
@} @}
*/ */
/** \name Error Codes */ /*@{*/ /** \name Error Codes */
/*@{*/
#define ZPGFILTERH_ENUL 1 /**< Unexpected null pointer in arguments */ #define ZPGFILTERH_ENUL 1 /**< Unexpected null pointer in arguments */
#define ZPGFILTERH_EOUT 2 /**< Output handle points to a non-null poin ter */ #define ZPGFILTERH_EOUT 2 /**< Output handle points to a non-null poin ter */
#define ZPGFILTERH_EMEM 3 /**< Memory allocation error */ #define ZPGFILTERH_EMEM 3 /**< Memory allocation error */
#define ZPGFILTERH_EBAD 4 /**< Bad filter parameters */ #define ZPGFILTERH_EBAD 4 /**< Bad filter parameters */
/*@}*/ /*@}*/
/*@}*/ /*@}*/
#define ZPGFILTERH_MSGENUL "Unexpected null pointer in arguments" #define ZPGFILTERH_MSGENUL "Unexpected null pointer in arguments"
#define ZPGFILTERH_MSGEOUT "Output handle points to a non-null pointer" #define ZPGFILTERH_MSGEOUT "Output handle points to a non-null pointer"
#define ZPGFILTERH_MSGEMEM "Memory allocation error" #define ZPGFILTERH_MSGEMEM "Memory allocation error"
#define ZPGFILTERH_MSGEBAD "Bad filter parameters" #define ZPGFILTERH_MSGEBAD "Bad filter parameters"
/* Function prototypes. */ /* ---------- Function prototypes. ---------- */
COMPLEX8ZPGFilter *XLALCreateCOMPLEX8ZPGFilter(INT4 numZeros, INT4 numPoles ); COMPLEX8ZPGFilter *XLALCreateCOMPLEX8ZPGFilter(INT4 numZeros, INT4 numPoles );
COMPLEX16ZPGFilter *XLALCreateCOMPLEX16ZPGFilter(INT4 numZeros, INT4 numPol es); COMPLEX16ZPGFilter *XLALCreateCOMPLEX16ZPGFilter(INT4 numZeros, INT4 numPol es);
void XLALDestroyCOMPLEX8ZPGFilter( COMPLEX8ZPGFilter *filter ); void XLALDestroyCOMPLEX8ZPGFilter( COMPLEX8ZPGFilter *filter );
void XLALDestroyCOMPLEX16ZPGFilter( COMPLEX16ZPGFilter *filter ); void XLALDestroyCOMPLEX16ZPGFilter( COMPLEX16ZPGFilter *filter );
int XLALWToZCOMPLEX8ZPGFilter( COMPLEX8ZPGFilter *filter ); int XLALWToZCOMPLEX8ZPGFilter( COMPLEX8ZPGFilter *filter );
int XLALWToZCOMPLEX16ZPGFilter( COMPLEX16ZPGFilter *filter ); int XLALWToZCOMPLEX16ZPGFilter( COMPLEX16ZPGFilter *filter );
void void
LALCreateCOMPLEX8ZPGFilter( LALStatus *status, LALCreateCOMPLEX8ZPGFilter( LALStatus *status,
COMPLEX8ZPGFilter **output, COMPLEX8ZPGFilter **output,
 End of changes. 2 change blocks. 
2 lines changed or deleted 3 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/