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 (