AVFactories.h		AVFactories.h
	/*-----------------------------------------------------------------------		/*-----------------------------------------------------------------------
	File Name: AVFactories.h		File Name: AVFactories.h
	<lalVerbatim file="AVFactoriesHV">
	Revision: $Id$
	</lalVerbatim>
	-------------------------------------------------------------------------*/		-------------------------------------------------------------------------*/
	/* <lalLaTeX>
	\section{Header \texttt{AVFactories.h}}
	\label{s:AVFactories.h}
	Provides prototype and status code information for use of CreateVector,
	CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray
	\subsection*{Synopsis}
	\begin{verbatim}
	#include <lal/AVFactories.h>
	\end{verbatim}
	</lalLaTeX> */
	#ifndef _AVFACTORIES_H		#ifndef _AVFACTORIES_H
	#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
	NRCSID (AVFACTORIESH, "$Id$");		NRCSID (AVFACTORIESH, "$Id$");
	/* <lalLaTeX>		/**
			\defgroup AVFactories_h AVFactories_h
	\subsection*{Error conditions}		\ingroup factories
	\input{AVFactoriesHErrTab}
	</lalLaTeX> */
	/*
	<lalErrTable file="AVFactoriesHErrTab">
	*/
	#define AVFACTORIESH_ELENGTH 1
	#define AVFACTORIESH_EVPTR 2
	#define AVFACTORIESH_EUPTR 4
	#define AVFACTORIESH_EDPTR 8
	#define AVFACTORIESH_EMALLOC 16
	#define AVFACTORIESH_MSGELENGTH "Illegal length."
	#define AVFACTORIESH_MSGEVPTR "Null vector/array handle."
	#define AVFACTORIESH_MSGEUPTR "Non-null vector/array pointer."
	#define AVFACTORIESH_MSGEDPTR "Null vector/array data."
	#define AVFACTORIESH_MSGEMALLOC "Malloc failure."
	/*
	</lalErrTable>
	*/
	/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{VectorFactoriesC}
	\newpage\input{ArrayFactoriesC}
	\newpage		\brief Provides prototype and status code information for use of CreateVect
	\subsection{XLAL Functions}		or,
			CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray
	\subsubsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/AVFactories.h>		#include <lal/AVFactories.h>
			\endcode
			\section secXLALfcts XLAL Functions
			\code
	REAL4Vector * XLALCreateVector(UINT4 length);		REAL4Vector * XLALCreateVector(UINT4 length);
	REAL4Vector * XLALResizeVector(REAL4Vector *vector, UINT4 length);		REAL4Vector * XLALResizeVector(REAL4Vector *vector, UINT4 length);
	void XLALDestroyVector(REAL4Vector *vector, UINT4 length);		void XLALDestroyVector(REAL4Vector *vector, UINT4 length);
	<vectype> * XLALCreate<vectype>(UINT4 length );		<vectype> * XLALCreate<vectype>(UINT4 length );
	<vectype> * XLALResize<vectype>(<vectype> *vector, UINT4 length );		<vectype> * XLALResize<vectype>(<vectype> *vector, UINT4 length );
	void XLALDestroy<vectype>(<vectype> *vector);		void XLALDestroy<vectype>(<vectype> *vector);
	REAL4Array * XLALCreateArrayL(UINT4 ndim, ...);		REAL4Array * XLALCreateArrayL(UINT4 ndim, ...);
	REAL4Array * XLALCreateArrayV(UINT4 ndim, UINT4 *dims);		REAL4Array * XLALCreateArrayV(UINT4 ndim, UINT4 *dims);
	skipping to change at line 97		skipping to change at line 57
	REAL4Array * XLALResizeArray(REAL4Array *array, UINT4Vector *dimLength);		REAL4Array * XLALResizeArray(REAL4Array *array, UINT4Vector *dimLength);
	void XLALDestroyArray(REAL4Array *array);		void XLALDestroyArray(REAL4Array *array);
	<arrtype> * XLALCreate<arrtype>L(UINT4 ndim, ...);		<arrtype> * XLALCreate<arrtype>L(UINT4 ndim, ...);
	<arrtype> * XLALCreate<arrtype>V(UINT4 ndim, UINT4 *dims);		<arrtype> * XLALCreate<arrtype>V(UINT4 ndim, UINT4 *dims);
	<arrtype> * XLALCreate<arrtype>(UINT4Vector *dimLength);		<arrtype> * XLALCreate<arrtype>(UINT4Vector *dimLength);
	<arrtype> * XLALResize<arrtype>L(<arrtype> *array, UINT4 ndim, ...);		<arrtype> * XLALResize<arrtype>L(<arrtype> *array, UINT4 ndim, ...);
	<arrtype> * XLALResize<arrtype>V(<arrtype> *array, UINT4 ndim, UINT4 *dims) ;		<arrtype> * XLALResize<arrtype>V(<arrtype> *array, UINT4 ndim, UINT4 *dims) ;
	<arrtype> * XLALResize<arrtype>(<arrtype> *array, UINT4Vector *dimLength);		<arrtype> * XLALResize<arrtype>(<arrtype> *array, UINT4Vector *dimLength);
	void XLALDestroy<arrtype>(<arrtype> *array);		void XLALDestroy<arrtype>(<arrtype> *array);
	\end{verbatim}		\endcode
	\idx{XLALCreateVector}
	\idx{XLALResizeVector}
	\idx{XLALDestroyVector}
	\idx{XLALCreateArrayL}
	\idx{XLALCreateArrayV}
	\idx{XLALCreateArray}
	\idx{XLALResizeArrayL}
	\idx{XLALResizeArrayV}
	\idx{XLALResizeArray}
	\idx{XLALDestroyArray}
	\idx{XLALCreate<type>Vector}
	\idx{XLALResize<type>Vector}
	\idx{XLALDestroy<type>Vector}
	\idx{XLALCreate<type>ArrayL}
	\idx{XLALCreate<type>ArrayV}
	\idx{XLALCreate<type>Array}
	\idx{XLALResize<type>ArrayL}
	\idx{XLALResize<type>ArrayV}
	\idx{XLALResize<type>Array}
	\idx{XLALDestroy<type>Array}
	Here \verb+<vectype>+ is one of		Here <tt>\<vectype\></tt> is one of
	\verb+COMPLEX16Vector+,		\c COMPLEX16Vector,
	\verb+COMPLEX8Vector+,		\c COMPLEX8Vector,
	\verb+REAL8Vector+,		\c REAL8Vector,
	\verb+REAL4Vector+,		\c REAL4Vector,
	\verb+INT8Vector+,		\c INT8Vector,
	\verb+INT4Vector+,		\c INT4Vector,
	\verb+INT2Vector+,		\c INT2Vector,
	\verb+UINT8Vector+,		\c UINT8Vector,
	\verb+UINT4Vector+,		\c UINT4Vector,
	\verb+UINT2Vector+, or		\c UINT2Vector, or
	\verb+CHARVector+,		\c CHARVector,
	and \verb+<arrtype>+ is one of		and <tt>\<arrtype\></tt> is one of
	\verb+COMPLEX16Array+,		\c COMPLEX16Array,
	\verb+COMPLEX8Array+,		\c COMPLEX8Array,
	\verb+REAL8Array+,		\c REAL8Array,
	\verb+REAL4Array+,		\c REAL4Array,
	\verb+INT8Array+,		\c INT8Array,
	\verb+INT4Array+,		\c INT4Array,
	\verb+INT2Array+,		\c INT2Array,
	\verb+UINT8Array+,		\c UINT8Array,
	\verb+UINT4Array+, or		\c UINT4Array, or
	\verb+UINT2Array+.		\c UINT2Array.
	\subsubsection*{Description}		\subsection ss_AVF_desc Description
	The \verb+XLALCreate<type>Vector+ functions create vectors of the specified		The <tt>XLALCreate\<type\>%Vector</tt> functions create vectors of the spec
	\verb+length+ number of objects of type \verb+<type>+. The function		ified
	\verb+XLALCreateVector+ is the same as \verb+XLALCreateREAL4Vector+.		\c length number of objects of type <tt>\<type\></tt>. The function
			\c XLALCreateVector() is the same as \c XLALCreateREAL4Vector().
	The \verb+XLALDestroy<type>Vector+ functions deallocate the memory allocati		The <tt>XLALDestroy\<type\>%Vector</tt> functions deallocate the memory all
	on		ocation
	pointed to by \verb+vector+ including its contents. The function		pointed to by \c vector including its contents. The function
	\verb+XLALDestroyVector+ is the same as \verb+XLALDestroyREAL4Vector+.		\c XLALDestroyVector() is the same as \c XLALDestroyREAL4Vector().
	The \verb+XLALResize<type>Vector+ functions resize the supplied vector		The <tt>XLALResize\<type\>%Vector</tt> functions resize the supplied vector
	\verb+vector+ to the new size \verb+length+. If \verb+vector+ is \verb+NUL		\c vector to the new size \c length. If \c vector is \c NULL
	L+		then this is equivalent to <tt>XLALCreate\<type\>%Vector</tt>. If \c lengt
	then this is equivalent to \verb+XLALCreate<type>Vector+. If \verb+length+		h
	is zero then this is equivalent to \verb+XLALDestroy<type>Vector+ and the		is zero then this is equivalent to <tt>XLALDestroy\<type\>%Vector</tt> and
	routine returns \verb+NULL+. Otherwise, the amount of data in the vector		the
	is realloced using \verb+LALRealloc+. The function		routine returns \c NULL. Otherwise, the amount of data in the vector
	\verb+XLALResizeVector+ is the same as \verb+XLALResizeREAL4Vector+.		is realloced using \c LALRealloc(). The function
			\c XLALResizeVector() is the same as \c XLALResizeREAL4Vector().
	The \verb+XLALCreate<type>Array+		The <tt>XLALCreate\<type\>Array</tt>
	\verb+XLALCreate<type>ArrayL+		<tt>XLALCreate\<type\>ArrayL</tt>
	\verb+XLALCreate<type>ArrayV+		<tt>XLALCreate\<type\>ArrayV</tt>
	all create an object of type \verb+<type>Array+. They differ in the way		all create an object of type <tt>\<type\>Array</tt>. They differ in the wa
			y
	that the dimensions of the array are specified. The function		that the dimensions of the array are specified. The function
	\verb+XLALCreate<type>Array+ allocates an array with dimensions specified		<tt>XLALCreate\<type\>Array</tt> allocates an array with dimensions specifi
	by the \verb+UINT4Vector+ \verb+dimLength+ which is a vector of dimension		ed
			by the \c UINT4Vector \c dimLength which is a vector of dimension
	lengths for the array. The function		lengths for the array. The function
	\verb+XLALCreate<type>ArrayV+ provides these dimensions with two arguments:		<tt>XLALCreate\<type\>ArrayV</tt> provides these dimensions with two argume
	\verb+ndim+ is the number of dimensions and \verb+dims+ is an array of		nts:
	\verb+UINT4+ values for the dimensions. The function		\c ndim is the number of dimensions and \c dims is an array of
	\verb+XLALCreate<type>ArrayL+ also specifies the dimensions as arguments.		\c UINT4 values for the dimensions. The function
	Here, the first argument, \verb+ndim+, is the number of dimensions, and		<tt>XLALCreate\<type\>ArrayL</tt> also specifies the dimensions as argument
	this is followed by \verb+ndim+ arguments that provide the dimensions.		s.
			Here, the first argument, \c ndim, is the number of dimensions, and
			this is followed by \c ndim arguments that provide the dimensions.
	Note that for this function, a maximum of 16 dimensions can be provided		Note that for this function, a maximum of 16 dimensions can be provided
	(that is, \verb+ndim+ cannot be more than 16 and there cannot be more than		(that is, \c ndim cannot be more than 16 and there cannot be more than
	16 arguments after the first).		16 arguments after the first).
	The \verb+XLALCreateArray+		The \c XLALCreateArray()
	\verb+XLALCreateArrayL+		\c XLALCreateArrayL()
	\verb+XLALCreateArrayV+		\c XLALCreateArrayV()
	functions are equivalent to the		functions are equivalent to the
	\verb+XLALCreateREAL4Array+		\c XLALCreateREAL4Array()
	\verb+XLALCreateREAL4ArrayL+		\c XLALCreateREAL4ArrayL()
	\verb+XLALCreateREAL4ArrayV+		\c XLALCreateREAL4ArrayV()
	functions respectively.		functions respectively.
	The \verb+XLALDestroy<type>Array+ functions deallocate the memory allocatio		The <tt>XLALDestroy\<type\>Array</tt> functions deallocate the memory alloc
	n		ation
	pointed to by \verb+array+ including its contents. The function		pointed to by \c array including its contents. The function
	\verb+XLALDestroyArray+ is the same as \verb+XLALDestroyREAL4Array+.		\c XLALDestroyArray() is the same as \c XLALDestroyREAL4Array().
	The \verb+XLALResize<type>Array+		The <tt>XLALResize\<type\>Array</tt>
	\verb+XLALResize<type>ArrayL+		<tt>XLALResize\<type\>ArrayL</tt>
	\verb+XLALResize<type>ArrayV+		<tt>XLALResize\<type\>ArrayV</tt>
	functions resize the provided array \verb+array+. The arguments after the		functions resize the provided array \c array. The arguments after the
	first are interpreted in the same way as for the		first are interpreted in the same way as for the
	\verb+XLALCreate<type>Array+		<tt>XLALCreate\<type\>Array</tt>
	\verb+XLALCreate<type>ArrayL+		<tt>XLALCreate\<type\>ArrayL</tt>
	\verb+XLALCreate<type>ArrayV+		<tt>XLALCreate\<type\>ArrayV</tt>
	functions. If \verb+array+ is \verb+NULL+, the resize functions are equiva		functions. If \c array is \c NULL, the resize functions are equivalent
	lent		to the corresponding create function. If \c ndim is zero for
	to the corresponding create function. If \verb+ndim+ is zero for		<tt>XLALResize\<type\>ArrayL</tt> or
	\verb+XLALResize<type>ArrayL+ or		<tt>XLALResize\<type\>ArrayV</tt>, or if \c dimLength is \c NULL for
	\verb+XLALResize<type>ArrayV+, or if \verb+dimLength+ is \verb+NULL+ for		<tt>XLALResize\<type\>Array</tt>, then these functions are equivalent to
	\verb+XLALResize<type>Array+, then these functions are equivalent to		<tt>XLALDestroy\<type\>Array</tt>.
	\verb+XLALDestroy<type>Array+.		The \c XLALResizeArray()
	The \verb+XLALResizeArray+		\c XLALResizeArrayL()
	\verb+XLALResizeArrayL+		\c XLALResizeArrayV()
	\verb+XLALResizeArrayV+
	functions are equivalent to the		functions are equivalent to the
	\verb+XLALResizeREAL4Array+		\c XLALResizeREAL4Array()
	\verb+XLALResizeREAL4ArrayL+		\c XLALResizeREAL4ArrayL()
	\verb+XLALResizeREAL4ArrayV+		\c XLALResizeREAL4ArrayV()
	functions respectively.		functions respectively.
	\subsubsection*{Return Values}		\subsection ss_AVF_return Return Values
	If successful, the create and resize functions return a pointer to the same		If successful, the create and resize functions return a pointer to the same
	data that was passed to the function. The resize functions will return		data that was passed to the function. The resize functions will return
	a \verb+NULL+ pointer if the size of the new object was zero. Upon failure		a \c NULL pointer if the size of the new object was zero. Upon failure
	these routines will return \verb+NULL+ and will set \verb+xlalErrno+ to		these routines will return \c NULL and will set \c xlalErrno to
	one of these values: \verb+XLAL_ENOMEM+ if a memory allocation failed,		one of these values: \c #XLAL_ENOMEM if a memory allocation failed,
	\verb+XLAL_EBADLEN+ if an invalid length was provided (for example, a		\c #XLAL_EBADLEN if an invalid length was provided (for example, a
	zero-size allocation with a create function), \verb+XLAL_EINVAL+ if an		zero-size allocation with a create function), \c XLAL_EINVAL if an
	invalid argument is provided (for example, if the pointer to an		invalid argument is provided (for example, if the pointer to an
	array of dimensions is \verb+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
	\verb+NULL+ pointer, it will set \verb+xlalErrno+ to \verb+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 \verb+NULL+ data pointer) it will set		vector with zero length or will a \c NULL data pointer) it will set
	\verb+xlalErrno+ to \verb+XLAL_EINVAL+.		\c xlalErrno to \c #XLAL_EINVAL.
	</lalLaTeX> */
	/*		*/
			/*@{ */
			/** \name Error Codes *//*@{*/
			#define AVFACTORIESH_ELENGTH 1
			#define AVFACTORIESH_EVPTR 2
			#define AVFACTORIESH_EUPTR 4
			#define AVFACTORIESH_EDPTR 8
			#define AVFACTORIESH_EMALLOC 16
			#define AVFACTORIESH_MSGELENGTH "Illegal length."
			#define AVFACTORIESH_MSGEVPTR "Null vector/array handle."
			#define AVFACTORIESH_MSGEUPTR "Non-null vector/array pointer."
			#define AVFACTORIESH_MSGEDPTR "Null vector/array data."
			#define AVFACTORIESH_MSGEMALLOC "Malloc failure."
			/*@}*/
			/*@}*/
	* CHAR		/* CHAR vector prototypes */
	*/
	CHARVector * XLALCreateCHARVector ( UINT4 length );		CHARVector * XLALCreateCHARVector ( UINT4 length );
	CHARVector * XLALResizeCHARVector ( CHARVector * vector, UINT4 length );		CHARVector * XLALResizeCHARVector ( CHARVector * vector, UINT4 length );
	void XLALDestroyCHARVector ( CHARVector * vector );		void XLALDestroyCHARVector ( CHARVector * vector );
	void LALCHARCreateVector ( LALStatus *, CHARVector **, UINT4 );		void LALCHARCreateVector ( LALStatus *, CHARVector **, UINT4 );
	void LALCHARResizeVector ( LALStatus *, CHARVector **, UINT4 );		void LALCHARResizeVector ( LALStatus *, CHARVector **, UINT4 );
	void LALCHARDestroyVector ( LALStatus *, CHARVector ** );		void LALCHARDestroyVector ( LALStatus *, CHARVector ** );
	/*		/* INT2 vector prototypes */
	* INT2
	*/
	INT2Vector * XLALCreateINT2Vector ( UINT4 length );		INT2Vector * XLALCreateINT2Vector ( UINT4 length );
	INT2Vector * XLALResizeINT2Vector ( INT2Vector * vector, UINT4 length );		INT2Vector * XLALResizeINT2Vector ( INT2Vector * vector, UINT4 length );
	void XLALDestroyINT2Vector ( INT2Vector * vector );		void XLALDestroyINT2Vector ( INT2Vector * vector );
	void LALI2CreateVector ( LALStatus *, INT2Vector **, UINT4 );		void LALI2CreateVector ( LALStatus *, INT2Vector **, UINT4 );
	void LALI2ResizeVector ( LALStatus *, INT2Vector **, UINT4 );		void LALI2ResizeVector ( LALStatus *, INT2Vector **, UINT4 );
	void LALI2DestroyVector ( LALStatus *, INT2Vector ** );		void LALI2DestroyVector ( LALStatus *, INT2Vector ** );
	/*		/* INT2 array prototypes */
	* INT2
	*/
	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 */
	* INT4
	*/
	INT4Vector * XLALCreateINT4Vector ( UINT4 length );		INT4Vector * XLALCreateINT4Vector ( UINT4 length );
	INT4Vector * XLALResizeINT4Vector ( INT4Vector * vector, UINT4 length );		INT4Vector * XLALResizeINT4Vector ( INT4Vector * vector, UINT4 length );
	void XLALDestroyINT4Vector ( INT4Vector * vector );		void XLALDestroyINT4Vector ( INT4Vector * vector );
	void LALI4CreateVector ( LALStatus *, INT4Vector **, UINT4 );		void LALI4CreateVector ( LALStatus *, INT4Vector **, UINT4 );
	void LALI4ResizeVector ( LALStatus *, INT4Vector **, UINT4 );		void LALI4ResizeVector ( LALStatus *, INT4Vector **, UINT4 );
	void LALI4DestroyVector ( LALStatus *, INT4Vector ** );		void LALI4DestroyVector ( LALStatus *, INT4Vector ** );
	/*		/* INT4 array prototypes */
	* INT4
	*/
	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 */
	* INT8
	*/
	INT8Vector * XLALCreateINT8Vector ( UINT4 length );		INT8Vector * XLALCreateINT8Vector ( UINT4 length );
	INT8Vector * XLALResizeINT8Vector ( INT8Vector * vector, UINT4 length );		INT8Vector * XLALResizeINT8Vector ( INT8Vector * vector, UINT4 length );
	void XLALDestroyINT8Vector ( INT8Vector * vector );		void XLALDestroyINT8Vector ( INT8Vector * vector );
	void LALI8CreateVector ( LALStatus *, INT8Vector **, UINT4 );		void LALI8CreateVector ( LALStatus *, INT8Vector **, UINT4 );
	void LALI8ResizeVector ( LALStatus *, INT8Vector **, UINT4 );		void LALI8ResizeVector ( LALStatus *, INT8Vector **, UINT4 );
	void LALI8DestroyVector ( LALStatus *, INT8Vector ** );		void LALI8DestroyVector ( LALStatus *, INT8Vector ** );
	/*		/* INT8 array prototypes */
	* INT8
	*/
	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 */
	* UINT2
	*/
	UINT2Vector * XLALCreateUINT2Vector ( UINT4 length );		UINT2Vector * XLALCreateUINT2Vector ( UINT4 length );
	UINT2Vector * XLALResizeUINT2Vector ( UINT2Vector * vector, UINT4 length );		UINT2Vector * XLALResizeUINT2Vector ( UINT2Vector * vector, UINT4 length );
	void XLALDestroyUINT2Vector ( UINT2Vector * vector );		void XLALDestroyUINT2Vector ( UINT2Vector * vector );
	void LALU2CreateVector ( LALStatus *, UINT2Vector **, UINT4 );		void LALU2CreateVector ( LALStatus *, UINT2Vector **, UINT4 );
	void LALU2ResizeVector ( LALStatus *, UINT2Vector **, UINT4 );		void LALU2ResizeVector ( LALStatus *, UINT2Vector **, UINT4 );
	void LALU2DestroyVector ( LALStatus *, UINT2Vector ** );		void LALU2DestroyVector ( LALStatus *, UINT2Vector ** );
	/*		/* UINT2 array prototypes */
	* UINT2
	*/
	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 */
	* UINT4
	*/
	UINT4Vector * XLALCreateUINT4Vector ( UINT4 length );		UINT4Vector * XLALCreateUINT4Vector ( UINT4 length );
	UINT4Vector * XLALResizeUINT4Vector ( UINT4Vector * vector, UINT4 length );		UINT4Vector * XLALResizeUINT4Vector ( UINT4Vector * vector, UINT4 length );
	void XLALDestroyUINT4Vector ( UINT4Vector * vector );		void XLALDestroyUINT4Vector ( UINT4Vector * vector );
	void LALU4CreateVector ( LALStatus *, UINT4Vector **, UINT4 );		void LALU4CreateVector ( LALStatus *, UINT4Vector **, UINT4 );
	void LALU4ResizeVector ( LALStatus *, UINT4Vector **, UINT4 );		void LALU4ResizeVector ( LALStatus *, UINT4Vector **, UINT4 );
	void LALU4DestroyVector ( LALStatus *, UINT4Vector ** );		void LALU4DestroyVector ( LALStatus *, UINT4Vector ** );
	/*		/* UINT4 array prototypes */
	* UINT4
	*/
	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 */
	* UINT8
	*/
	UINT8Vector * XLALCreateUINT8Vector ( UINT4 length );		UINT8Vector * XLALCreateUINT8Vector ( UINT4 length );
	UINT8Vector * XLALResizeUINT8Vector ( UINT8Vector * vector, UINT4 length );		UINT8Vector * XLALResizeUINT8Vector ( UINT8Vector * vector, UINT4 length );
	void XLALDestroyUINT8Vector ( UINT8Vector * vector );		void XLALDestroyUINT8Vector ( UINT8Vector * vector );
	void LALU8CreateVector ( LALStatus *, UINT8Vector **, UINT4 );		void LALU8CreateVector ( LALStatus *, UINT8Vector **, UINT4 );
	void LALU8ResizeVector ( LALStatus *, UINT8Vector **, UINT4 );		void LALU8ResizeVector ( LALStatus *, UINT8Vector **, UINT4 );
	void LALU8DestroyVector ( LALStatus *, UINT8Vector ** );		void LALU8DestroyVector ( LALStatus *, UINT8Vector ** );
	/*		/* UINT8 array prototypes */
	* UINT8
	*/
	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 */
	* REAL4
	*/
	REAL4Vector * XLALCreateREAL4Vector ( UINT4 length );		REAL4Vector * XLALCreateREAL4Vector ( UINT4 length );
	REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length );		REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length );
	void XLALDestroyREAL4Vector ( REAL4Vector * vector );		void XLALDestroyREAL4Vector ( REAL4Vector * vector );
	void LALSCreateVector ( LALStatus *, REAL4Vector **, UINT4 );		void LALSCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
	void LALSResizeVector ( LALStatus *, REAL4Vector **, UINT4 );		void LALSResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
	void LALSDestroyVector ( LALStatus *, REAL4Vector ** );		void LALSDestroyVector ( LALStatus *, REAL4Vector ** );
	/*		/* REAL4 array prototypes */
	* REAL4
	*/
	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 */
	* REAL8
	*/
	REAL8Vector * XLALCreateREAL8Vector ( UINT4 length );		REAL8Vector * XLALCreateREAL8Vector ( UINT4 length );
	REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length );		REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length );
	void XLALDestroyREAL8Vector ( REAL8Vector * vector );		void XLALDestroyREAL8Vector ( REAL8Vector * vector );
	void LALDCreateVector ( LALStatus *, REAL8Vector **, UINT4 );		void LALDCreateVector ( LALStatus *, REAL8Vector **, UINT4 );
	void LALDResizeVector ( LALStatus *, REAL8Vector **, UINT4 );		void LALDResizeVector ( LALStatus *, REAL8Vector **, UINT4 );
	void LALDDestroyVector ( LALStatus *, REAL8Vector ** );		void LALDDestroyVector ( LALStatus *, REAL8Vector ** );
	/*		/* REAL8 array prototypes */
	* REAL8
	*/
	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 */
	* COMPLEX8
	*/
	COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length );		COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length );
	COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4 length );		COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4 length );
	void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector * vector );		void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector * vector );
	void LALCCreateVector ( LALStatus *, COMPLEX8Vector **, UINT4 );		void LALCCreateVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
	void LALCResizeVector ( LALStatus *, COMPLEX8Vector **, UINT4 );		void LALCResizeVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
	void LALCDestroyVector ( LALStatus *, COMPLEX8Vector ** );		void LALCDestroyVector ( LALStatus *, COMPLEX8Vector ** );
	/*		/* COMPLEX8 array prototypes */
	* COMPLEX8
	*/
	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 */
	* COMPLEX16
	*/
	COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length );		COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length );
	COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UIN T4 length );		COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UIN T4 length );
	void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector * vector );		void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector * vector );
	void LALZCreateVector ( LALStatus *, COMPLEX16Vector **, UINT4 );		void LALZCreateVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
	void LALZResizeVector ( LALStatus *, COMPLEX16Vector **, UINT4 );		void LALZResizeVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
	void LALZDestroyVector ( LALStatus *, COMPLEX16Vector ** );		void LALZDestroyVector ( LALStatus *, COMPLEX16Vector ** );
	/*		/* COMPLEX16 array prototypes */
	* COMPLEX16
	*/
	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 */
	* REAL4
	*/
	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 */
	* REAL4
	*/
	REAL4Array * XLALCreateArrayL ( UINT4, ... );		REAL4Array * XLALCreateArrayL ( UINT4, ... );
	REAL4Array * XLALCreateArrayV ( UINT4, UINT4 * );		REAL4Array * XLALCreateArrayV ( UINT4, UINT4 * );
	REAL4Array * XLALCreateArray ( UINT4Vector * );		REAL4Array * XLALCreateArray ( UINT4Vector * );
	REAL4Array * XLALResizeArrayL ( REAL4Array *, UINT4, ... );		REAL4Array * XLALResizeArrayL ( REAL4Array *, UINT4, ... );
	REAL4Array * XLALResizeArrayV ( REAL4Array *, UINT4, UINT4 * );		REAL4Array * XLALResizeArrayV ( REAL4Array *, UINT4, UINT4 * );
	REAL4Array * XLALResizeArray ( REAL4Array *, UINT4Vector * );		REAL4Array * XLALResizeArray ( REAL4Array *, UINT4Vector * );
	void XLALDestroyArray ( REAL4Array * );		void XLALDestroyArray ( REAL4Array * );
	void LALCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );		void LALCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );
	void LALResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );		void LALResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
	void LALDestroyArray ( LALStatus *, REAL4Array ** );		void LALDestroyArray ( LALStatus *, REAL4Array ** );
	/* Test program. */
	/* <lalLaTeX>
	\newpage\input{VectorFactoriesTestC}
	\newpage\input{ArrayFactoriesTestC}
	</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _AVFACTORIES_H */		#endif /* _AVFACTORIES_H */
End of changes. 53 change blocks.
	264 lines changed or deleted		148 lines changed or added

	Audio.h		Audio.h
	skipping to change at line 42		skipping to change at line 42
	*		*
	*/		*/
	#ifndef AUDIO_H		#ifndef AUDIO_H
	#define AUDIO_H		#define AUDIO_H
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	NRCSID( AUDIOH, "$Id$" );		NRCSID( AUDIOH, "$Id$" );
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	/** Records a time series as a .wav audio file */		/** Records a time series as a .wav audio file */
	int XLALAudioWAVRecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series );		int XLALAudioWAVRecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series );
	/** Records a time series as a .wav audio file */		/** Records a time series as a .wav audio file */
	int XLALAudioWAVRecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series );		int XLALAudioWAVRecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series );
	/** Records a time series as a .au audio file */		/** Records a time series as a .au audio file */
	int XLALAudioAURecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series );		int XLALAudioAURecordREAL4TimeSeries( FILE *fp, REAL4TimeSeries *series );
	/** Records a time series as a .au audio file */		/** Records a time series as a .au audio file */
	int XLALAudioAURecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series );		int XLALAudioAURecordREAL8TimeSeries( FILE *fp, REAL8TimeSeries *series );
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* AUDIO_H */		#endif /* AUDIO_H */
End of changes. 3 change blocks.
	4 lines changed or deleted		6 lines changed or added

	BandPassTimeSeries.h		BandPassTimeSeries.h
	skipping to change at line 46		skipping to change at line 46
	\noindent This header covers routines that apply a time-domain low- or		\noindent This header covers routines that apply a time-domain low- or
	high-pass filter to a data series of type \verb@<datatype>TimeSeries@.		high-pass filter to a data series of type \verb@<datatype>TimeSeries@.
	Further documentation is given in the individual routines' modules.		Further documentation is given in the individual routines' modules.
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
	#ifndef _BANDPASSTIMESERIES_H		#ifndef _BANDPASSTIMESERIES_H
	#define _BANDPASSTIMESERIES_H		#define _BANDPASSTIMESERIES_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/IIRFilter.h>		#include <lal/IIRFilter.h>
	#include <lal/ZPGFilter.h>		#include <lal/ZPGFilter.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID(BANDPASSTIMESERIESH,"$Id$");		NRCSID(BANDPASSTIMESERIESH,"$Id$");
	/********************************************************** <lalLaTeX>		/********************************************************** <lalLaTeX>
	\subsection*{Error conditions}		\subsection*{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		****************************************** </lalLaTeX><lalErrTable> */
	#define BANDPASSTIMESERIESH_ENUL 1		#define BANDPASSTIMESERIESH_ENUL 1
	#define BANDPASSTIMESERIESH_EBAD 2		#define BANDPASSTIMESERIESH_EBAD 2
	skipping to change at line 94		skipping to change at line 100
	\item[\texttt{REAL8 f1}, \texttt{f2}] The reference frequencies of the		\item[\texttt{REAL8 f1}, \texttt{f2}] The reference frequencies of the
	transition band.		transition band.
	\item[\texttt{REAL8 a1}, \texttt{a2}] The minimal desired attenuation		\item[\texttt{REAL8 a1}, \texttt{a2}] The minimal desired attenuation
	factors at the reference frequencies.		factors at the reference frequencies.
	\end{description}		\end{description}
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
	typedef struct tagPassBandParamStruc{		typedef struct tagPassBandParamStruc{
			SWIGLAL_STRUCT(PassBandParamStruc);
	CHAR *name;		CHAR *name;
	INT4 nMax;		INT4 nMax;
	REAL8 f1;		REAL8 f1;
	REAL8 f2;		REAL8 f2;
	REAL8 a1;		REAL8 a1;
	REAL8 a2;		REAL8 a2;
	} PassBandParamStruc;		} PassBandParamStruc;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vfill{\footnotesize\input{BandPassTimeSeriesHV}}		\vfill{\footnotesize\input{BandPassTimeSeriesHV}}
	skipping to change at line 147		skipping to change at line 154
	/* Chebyshev filters should also be added, but I'm too busy to write		/* Chebyshev filters should also be added, but I'm too busy to write
	the routines now. */		the routines now. */
	/* Test program. */		/* Test program. */
	/* <lalLaTeX>		/* <lalLaTeX>
	\newpage\input{BandPassTestC}		\newpage\input{BandPassTestC}
	</lalLaTeX> */		</lalLaTeX> */
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _BANDPASSTIMESERIES_H */		#endif /* _BANDPASSTIMESERIES_H */
End of changes. 5 change blocks.
	4 lines changed or deleted		12 lines changed or added

	BitField.h		BitField.h
	skipping to change at line 23		skipping to change at line 23
	*		*
	* 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		* \author Karl Wette
	* \file		* \file
	* \brief Macros for manipulating bit field		* \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>
	NRCSID(BITFIELDH, "$Id$");		NRCSID(BITFIELDH, "$Id$");
	/**		/**
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	Calibration.h		Calibration.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
	*/		*/
	/**** <lalVerbatim file="CalibrationHV">
	* Author: P. R. Brady, J. D. E. Creighton
	* $Id$
	**** </lalVerbatim> */
	/**** <lalLaTeX>
	*
	* \section{Header \texttt{Calibration.h}}
	*
	* \subsection*{Synopsis}
	* \begin{verbatim}
	* #include <lal/Calibration.h>
	* \end{verbatim}
	*
	**** </lalLaTeX> */
	#ifndef _CALIBRATION_H		#ifndef _CALIBRATION_H
	#define _CALIBRATION_H		#define _CALIBRATION_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/BandPassTimeSeries.h>		#include <lal/BandPassTimeSeries.h>
	NRCSID (CALIBRATIONH,"$Id$");		NRCSID (CALIBRATIONH,"$Id$");
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma } /** to match the previous brace **/		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	/**** <lalLaTeX>		/**
			* \author P. R. Brady, J. D. E. Creighton
			* \addtogroup Calibration_h
	*		*
	* \subsection*{Error conditions}		* \heading{Synopsis}
			* \code
			* #include <lal/Calibration.h>
			* \endcode
	*		*
	**** </lalLaTeX> */		*/
	/**** <lalErrTable> */		/** @{ */
	#define CALIBRATIONH_ENULL 001
	#define CALIBRATIONH_ESIZE 002
	#define CALIBRATIONH_ESZMM 004
	#define CALIBRATIONH_EZERO 010
	#define CALIBRATIONH_ETIME 020
	#define CALIBRATIONH_EUNIT 040
			/**\name Error Codes */ /*@{*/
			#define CALIBRATIONH_ENULL 001 /**< Null pointer */
			#define CALIBRATIONH_ESIZE 002 /**< Invalid size */
			#define CALIBRATIONH_ESZMM 004 /**< Size mismatch */
			#define CALIBRATIONH_EZERO 010 /**< Zero factor */
			#define CALIBRATIONH_ETIME 020 /**< Time out of range */
			#define CALIBRATIONH_EUNIT 040 /**< Incompatible units */
			/*@}*/
			/** \cond DONT_DOXYGEN */
	#define CALIBRATIONH_MSGENULL "Null pointer"		#define CALIBRATIONH_MSGENULL "Null pointer"
	#define CALIBRATIONH_MSGESIZE "Invalid size"		#define CALIBRATIONH_MSGESIZE "Invalid size"
	#define CALIBRATIONH_MSGESZMM "Size mismatch"		#define CALIBRATIONH_MSGESZMM "Size mismatch"
	#define CALIBRATIONH_MSGEZERO "Zero factor"		#define CALIBRATIONH_MSGEZERO "Zero factor"
	#define CALIBRATIONH_MSGETIME "Time out of range"		#define CALIBRATIONH_MSGETIME "Time out of range"
	#define CALIBRATIONH_MSGEUNIT "Incompatible units"		#define CALIBRATIONH_MSGEUNIT "Incompatible units"
	/**** </lalErrTable> */		/** \endcond */
	/**** <lalLaTeX>		/** UNDOCUMENTED */
	*
	* \subsection*{Structures}
	* \idx[Type]{CalibrationType}
	* \idx[Type]{CalibrationRecord}
	* \idx[Type]{CalibrationFunctions}
	* \idx[Type]{CalibrationUpdateParams}
	*
	* \subsubsection*{Type \texttt{CalibrationType}}
	*
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	typedef enum		typedef enum
	{		{
	CalibrationAmplitude = 001,		CalibrationAmplitude = 001,
	CalibrationOffset = 002,		CalibrationOffset = 002,
	CalibrationDelay = 004,		CalibrationDelay = 004,
	CalibrationTransfer = 010,		CalibrationTransfer = 010,
	CalibrationZPG = 020		CalibrationZPG = 020
	}		}
	CalibrationType;		CalibrationType;
	/**** </lalVerbatim> */
	/**** <lalLaTeX>		/** UNDOCUMENTED */
	*
	* Document \verb+CalibrationType+
	*
	* \subsubsection*{Type \texttt{CalFactors}}
	*
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	typedef struct		typedef struct
	tagCalFactors		tagCalFactors
	{		{
			SWIGLAL_STRUCT(CalFactors);
	COMPLEX16 alpha;		COMPLEX16 alpha;
	COMPLEX16 alphabeta;		COMPLEX16 alphabeta;
	COMPLEX16 beta;		COMPLEX16 beta;
	COMPLEX16 exc;		COMPLEX16 exc;
	COMPLEX16 asq;		COMPLEX16 asq;
	COMPLEX16 darm;		COMPLEX16 darm;
	}		}
	CalFactors;		CalFactors;
	/**** </lalVerbatim> */
	/**** <lalLaTeX>		/** UNDOCUMENTED */
	*
	* Document \verb+CalibrationType+
	*
	* \subsubsection*{Type \texttt{UpdateFactorsParams}}
	*
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	typedef struct		typedef struct
	tagUpdateFactorsParams		tagUpdateFactorsParams
	{		{
			SWIGLAL_STRUCT(UpdateFactorsParams);
	REAL8 lineFrequency;		REAL8 lineFrequency;
	COMPLEX16 openloop;		COMPLEX16 openloop;
	COMPLEX16 digital;		COMPLEX16 digital;
	COMPLEX16 whitener;		COMPLEX16 whitener;
	REAL4TimeSeries *darmCtrl;		REAL4TimeSeries *darmCtrl;
	REAL4TimeSeries *asQ;		REAL4TimeSeries *asQ;
	REAL4TimeSeries *exc;		REAL4TimeSeries *exc;
	}		}
	UpdateFactorsParams;		UpdateFactorsParams;
	/**** </lalVerbatim> */
	/**** <lalLaTeX>		/** UNDOCUMENTED */
	*
	* Document \verb+CalibrationType+
	*
	* \subsubsection*{Type \texttt{CalibrationRecord}}
	*
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	typedef struct		typedef struct
	tagCalibrationRecord		tagCalibrationRecord
	{		{
			SWIGLAL_STRUCT(CalibrationRecord);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 duration;		REAL8 duration;
	CHAR reference[LALNameLength];		CHAR reference[LALNameLength];
	LALUnit units;		LALUnit units;
	UINT4 type;		UINT4 type;
	REAL8 conversion;		REAL8 conversion;
	REAL8 offset;		REAL8 offset;
	REAL8 delay;		REAL8 delay;
	COMPLEX8FrequencySeries *transfer;		COMPLEX8FrequencySeries *transfer;
	REAL8Vector *zeros;		REAL8Vector *zeros;
	REAL8Vector *poles;		REAL8Vector *poles;
	REAL8 gain;		REAL8 gain;
	}		}
	CalibrationRecord;		CalibrationRecord;
	/**** </lalVerbatim> */
	/**** <lalLaTeX>		/** The type CalibrationFunctions contains two calibration functions,
	*		* the sensing function \f$C(f)\f$ and the response function \f$R(f)\f$. W
	* Document \verb+CalibrationRecord+		hile the
	*		* response function is the function that is most often wanted, the sensing
	* \subsubsection*{Type \texttt{CalibrationFunctions}}		* function is needed in updating calibration from one epoch to another.
	*		*/
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	typedef struct		typedef struct
	tagCalibrationFunctions		tagCalibrationFunctions
	{		{
			SWIGLAL_STRUCT(CalibrationFunctions);
	COMPLEX8FrequencySeries *responseFunction;		COMPLEX8FrequencySeries *responseFunction;
	COMPLEX8FrequencySeries *sensingFunction;		COMPLEX8FrequencySeries *sensingFunction;
	}		}
	CalibrationFunctions;		CalibrationFunctions;
	/**** </lalVerbatim> */
	/**** <lalLaTeX>		/** The type \c CalibrationUpdateParams contains two time series
	* The type \texttt{CalibrationFunctions} contains two calibration function		* representing an overall gain factor for the open-loop gain function \f$H
	s,		(f)\f$
	* the sensing function $C(f)$ and the response function $R(f)$. While the		* and the sensing function \f$C(f)\f$. These transfer functions are known
	* response function is the function that is most often wanted, the sensing		to
	* function is needed in updating calibration from one epoch to another.		* change (by an overall factor) with time, and these two factors can be
	*		* tracked using the injected calibration lines. The factors are stored
	* \subsubsection*{Type \texttt{CalibrationUpdateParams}}		* in this structure as (very-slowly varying) time series, and are to be
	*		* used in updating the calibration functions described previously.
	**** </lalLaTeX> */		* (The response function can be computed from the open-loop gain and the
	/**** <lalVerbatim> */		* sensing function. It is simply \f$R(f)=[1+H(f)]/C(f)\f$.) In addition,
			this
			* structure contains the present epoch and the duration of the data to be
			* calibrated to identify the particular set of
			* factors (from those recorded in the time series) to use.
			*/
	typedef struct		typedef struct
	tagCalibrationUpdateParams		tagCalibrationUpdateParams
	{		{
			SWIGLAL_STRUCT(CalibrationUpdateParams);
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	LIGOTimeGPS duration;		LIGOTimeGPS duration;
	CHAR *ifo;		CHAR *ifo;
	COMPLEX8 alpha;		COMPLEX8 alpha;
	COMPLEX8 alphabeta;		COMPLEX8 alphabeta;
	COMPLEX8TimeSeries *openLoopFactor;		COMPLEX8TimeSeries *openLoopFactor;
	COMPLEX8TimeSeries *sensingFactor;		COMPLEX8TimeSeries *sensingFactor;
	}		}
	CalibrationUpdateParams;		CalibrationUpdateParams;
	/**** </lalVerbatim> */
	/**** <lalLaTeX>
	* The type \texttt{CalibrationUpdateParams} contains two time series
	* representing an overall gain factor for the open-loop gain function $H(f
	)$
	* and the sensing function $C(f)$. These transfer functions are known to
	* change (by an overall factor) with time, and these two factors can be
	* tracked using the injected calibration lines. The factors are stored
	* in this structure as (very-slowly varying) time series, and are to be
	* used in updating the calibration functions described previously.
	* (The response function can be computed from the open-loop gain and the
	* sensing function. It is simply $R(f)=[1+H(f)]/C(f)$.) In addition, thi
	s
	* structure contains the present epoch and the duration of the data to be
	* calibrated to identify the particular set of
	* factors (from those recorded in the time series) to use.
	*
	* \vfill{\footnotesize\input{CalibrationHV}}
	* \newpage\input{ComputeTransferC}
	*
	**** </lalLaTeX> */
			/** UNDOCUMENTED */
	typedef		typedef
	struct StrainOutTag {		struct tagStrainOut {
	REAL8TimeSeries h; /* timeseries containing h(t) */		SWIGLAL_STRUCT(StrainOut);
	REAL8TimeSeries hC; /* timeseries containing the control signal *		REAL8TimeSeries h; /**< timeseries containing h(t) */
	/		REAL8TimeSeries hC; /**< timeseries containing the control signa
	REAL8TimeSeries hR; /* timeseries containing the residual signal		l */
	*/		REAL8TimeSeries hR; /**< timeseries containing the residual sign
	COMPLEX16TimeSeries alpha; /* alpha time series */		al */
	COMPLEX16TimeSeries beta; /* beta time series */		COMPLEX16TimeSeries alpha; /**< alpha time series */
	COMPLEX16TimeSeries alphabeta; /* alpha time series */		COMPLEX16TimeSeries beta; /**< beta time series */
	INT2TimeSeries science_mode; /* flag = 1 for science mode, 0 otherwise		COMPLEX16TimeSeries alphabeta;/**< alpha time series */
	*/		INT2TimeSeries science_mode; /**< flag = 1 for science mode, 0 otherwise
			*/
	} StrainOut;		} StrainOut;
			/** UNDOCUMENTED */
	typedef		typedef
	struct StrainInTag {		struct tagStrainIn {
	REAL4TimeSeries AS_Q ; /* timeseries containing ASQ */		SWIGLAL_STRUCT(StrainIn);
	REAL4TimeSeries DARM_ERR;/* timeseries containing DARM_ERR */		REAL4TimeSeries AS_Q ; /**< timeseries containing ASQ */
	REAL4TimeSeries DARM ; /* timeseries containing DARM_CTRL */		REAL4TimeSeries DARM_ERR;/**< timeseries containing DARM_ERR */
	REAL4TimeSeries EXC ; /* timeseries containing the excitation */		REAL4TimeSeries DARM ; /**< timeseries containing DARM_CTRL */
	REAL4TimeSeries StateVector; /* timeseries containing the State Vector (		REAL4TimeSeries EXC ; /**< timeseries containing the excitation */
	IFO-SV_STATE_VECTOR) */		REAL4TimeSeries StateVector; /**< timeseries containing the State Vector
	REAL4TimeSeries LAX; /* timeseries containing the Light-in-X-arm (LSC		(IFO-SV_STATE_VECTOR) */
	-LA_PTRX_NORM) */		REAL4TimeSeries LAX; /**< timeseries containing the Light-in-X-arm (L
	REAL4TimeSeries LAY; /* timeseries containing the Light-in-Y-arm (LSC		SC-LA_PTRX_NORM) */
	-LA_PTRY_NORM) */		REAL4TimeSeries LAY; /**< timeseries containing the Light-in-Y-arm (L
	COMPLEX16 Do; /* digital filter at cal line frequency */		SC-LA_PTRY_NORM) */
	COMPLEX16 Go; /* OLG at cal line frequency */		COMPLEX16 Do; /**< digital filter at cal line frequency */
	COMPLEX16 Wo; /* Whitening filter at cal line frequency */		COMPLEX16 Go; /**< OLG at cal line frequency */
	REAL8 f; /* calibration line frequency */		COMPLEX16 Wo; /**< Whitening filter at cal line frequency */
	REAL4 To; /* factors integration time */		REAL8 f; /**< calibration line frequency */
	char filter_vc_info[1024]; /* version control information in the filters		REAL4 To; /**< factors integration time */
	file */		char filter_vc_info[1024]; /**< version control information in the filter
	char filter_chksum[64]; /* checksum of the contents of the filters file		s file */
	*/		char filter_chksum[64]; /**< checksum of the contents of the filters fil
	REAL8IIRFilter *Cinv; /* Filters for inverse of sensing function */		e */
	INT4 CinvUSF; /* Upsampling factor for sensing function */		REAL8IIRFilter *Cinv; /**< Filters for inverse of sensing function */
	INT4 CinvDelay; /* Overall inverse sensing function delay */		INT4 CinvUSF; /**< Upsampling factor for sensing function */
	REAL8IIRFilter *A; /* Filters for analog actuation function */		INT4 CinvDelay; /**< Overall inverse sensing function delay */
	REAL8IIRFilter *D; /* Filters for analog actuation function */		REAL8IIRFilter *A; /**< Filters for analog actuation function */
	REAL8IIRFilter *AW; /* Filters for analog actuation function */		REAL8IIRFilter *D; /**< Filters for analog actuation function */
	REAL8 gamma_fudgefactor;		REAL8IIRFilter *AW; /**< Filters for analog actuation function */
	INT4 delta;		REAL8 gamma_fudgefactor; /**< UNDOCUMENTED */
	INT4 usefactors;		INT4 delta; /**< UNDOCUMENTED */
	INT4 wings; /* size of wings in seconds */		INT4 usefactors; /**< UNDOCUMENTED */
	INT4 fftconv;		INT4 wings; /**< size of wings in seconds */
	INT4 outalphas;		INT4 fftconv; /**< UNDOCUMENTED */
	INT4 darmctrl;		INT4 outalphas;/**< UNDOCUMENTED */
			INT4 darmctrl;/**< UNDOCUMENTED */
	/* Stuff needed to run old IIR code */		/* Stuff needed to run old IIR code */
	REAL8IIRFilter *AA; /* Filters for analog actuation function */		REAL8IIRFilter *AA; /**< Filters for analog actuation function */
	INT4 AADelay; /* Overall analog actuation function delay */		INT4 AADelay; /**< Overall analog actuation function delay */
	REAL8IIRFilter *AX; /* Digital filters for x arm actuation function		REAL8IIRFilter *AX; /**< Digital filters for x arm actuation functio
	*/		n */
	REAL8IIRFilter *AY; /* Digital filters for y arm actuation function		REAL8IIRFilter *AY; /**< Digital filters for y arm actuation functio
	*/		n */
	INT4 NCinv; /* Numbers of filters of each type */		INT4 NCinv; /**< Numbers of filters of each type */
	INT4 ND;		INT4 ND;/**< UNDOCUMENTED */
	INT4 NAA;		INT4 NAA;/**< UNDOCUMENTED */
	INT4 NAX;		INT4 NAX;/**< UNDOCUMENTED */
	INT4 NAY;		INT4 NAY;/**< UNDOCUMENTED */
	} StrainIn;		} StrainIn;
			/** UNDOCUMENTED */
	typedef		typedef
	struct MyIIRFilter {		struct tagMyIIRFilter {
			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 ----- */
	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,
	CalibrationUpdateParams *params		CalibrationUpdateParams *params
	);		);
	skipping to change at line 347		skipping to change at line 305
	void LALMakeFIRLP(LALStatus *status,		void LALMakeFIRLP(LALStatus *status,
	REAL8IIRFilter *G,		REAL8IIRFilter *G,
	int USF);		int USF);
	void LALMakeFIRLPALPHAS(LALStatus *status,		void LALMakeFIRLPALPHAS(LALStatus *status,
	REAL8IIRFilter *G);		REAL8IIRFilter *G);
	void LALMakeFIRHP(LALStatus *status,		void LALMakeFIRHP(LALStatus *status,
	REAL8IIRFilter *G);		REAL8IIRFilter *G);
	int XALFIRFilter(REAL8TimeSeries *tseries,		int XLALFIRFilter(REAL8TimeSeries *tseries,
	REAL8IIRFilter *FIR);		REAL8IIRFilter *FIR);
	void LALFFTFIRFilter(LALStatus *status,		void LALFFTFIRFilter(LALStatus *status,
	REAL8TimeSeries *tseries,		REAL8TimeSeries *tseries,
	REAL8IIRFilter *FIR);		REAL8IIRFilter *FIR);
	void LALFIRFilter(LALStatus *status,
	REAL8TimeSeries *tseries,
	REAL8IIRFilter *FIR);
	void LALFreeFilter(LALStatus *status, REAL8IIRFilter *F2, int ORDER);		void LALFreeFilter(LALStatus *status, REAL8IIRFilter *F2, int ORDER);
	void LALCopyFilter(LALStatus *status, REAL8IIRFilter **F2, REAL8IIRFilter * F1, int ORDER);		void LALCopyFilter(LALStatus *status, REAL8IIRFilter **F2, REAL8IIRFilter * F1, int ORDER);
	int XLALDivideTimeSeries(REAL8TimeSeries *hR, REAL8TimeSeries *ALPHAS);		int XLALDivideTimeSeries(REAL8TimeSeries *hR, REAL8TimeSeries *ALPHAS);
	int XLALUpsample(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_factor) ;		int XLALUpsample(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_factor) ;
	int XLALUpsampleLinear(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_f actor);		int XLALUpsampleLinear(REAL8TimeSeries *uphR, REAL8TimeSeries *hR, int up_f actor);
	#ifdef __cplusplus		#if 0
	#pragma { /** to match the next brace **/		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _CALIBRATION_H */		#endif /* _CALIBRATION_H */
End of changes. 36 change blocks.
	174 lines changed or deleted		130 lines changed or added

	CoarseGrainFrequencySeries.h		CoarseGrainFrequencySeries.h
	skipping to change at line 51		skipping to change at line 51
	\subsection*{Structures}		\subsection*{Structures}
	*********************************************************** </lalLaTeX> */		*********************************************************** </lalLaTeX> */
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifndef _COARSEGRAINFREQUENCYSERIES_H		#ifndef _COARSEGRAINFREQUENCYSERIES_H
	#define _COARSEGRAINFREQUENCYSERIES_H		#define _COARSEGRAINFREQUENCYSERIES_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( COARSEGRAINFREQUENCYSERIESH,		NRCSID( COARSEGRAINFREQUENCYSERIESH,
	"$Id$" );		"$Id$" );
	/****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */		/****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */
	#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1		#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1
	skipping to change at line 116		skipping to change at line 121
	\item[\texttt{REAL8 deltaF}]		\item[\texttt{REAL8 deltaF}]
	The frequency spacing of the frequency series.		The frequency spacing of the frequency series.
	\end{description}		\end{description}
	*********************************************************** </lalLaTeX> */		*********************************************************** </lalLaTeX> */
	typedef struct		typedef struct
	tagFrequencySamplingParams		tagFrequencySamplingParams
	{		{
			SWIGLAL_STRUCT(FrequencySamplingParams);
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	UINT4 length;		UINT4 length;
	}		}
	FrequencySamplingParams;		FrequencySamplingParams;
	void		void
	LALSCoarseGrainFrequencySeries(LALStatus *status,		LALSCoarseGrainFrequencySeries(LALStatus *status,
	REAL4FrequencySeries *output,		REAL4FrequencySeries *output,
	const REAL4FrequencySeries *input,		const REAL4FrequencySeries *input,
End of changes. 2 change blocks.
	0 lines changed or deleted		6 lines changed or added

	CoherentEstimation.h		CoherentEstimation.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
	*/		*/
	/*************************** <lalVerbatim file="CoherentEstimation">
	Author: Sylvestre, J.
	$Id$
	**************************************************** </lalVerbatim> */
	#ifndef _COHERENTESTIMATION_H		#ifndef _COHERENTESTIMATION_H
	#define _COHERENTESTIMATION_H		#define _COHERENTESTIMATION_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/DetectorSite.h>		#include <lal/DetectorSite.h>
	#include <lal/SkyCoordinates.h>		#include <lal/SkyCoordinates.h>
	#include <lal/IIRFilter.h>		#include <lal/IIRFilter.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID( COHERENTESTIMATION, "$Id$" );		NRCSID( COHERENTESTIMATION, "$Id$" );
	#define COHERENTESTIMATIONH_EMEM 1		#define COHERENTESTIMATIONH_EMEM 1
	#define COHERENTESTIMATIONH_ENULL 2		#define COHERENTESTIMATIONH_ENULL 2
	#define COHERENTESTIMATIONH_E0DEC 3		#define COHERENTESTIMATIONH_E0DEC 3
	#define COHERENTESTIMATIONH_EDST 4		#define COHERENTESTIMATIONH_EDST 4
	#define COHERENTESTIMATIONH_EICE 5		#define COHERENTESTIMATIONH_EICE 5
	#define COHERENTESTIMATIONH_ENUM 6		#define COHERENTESTIMATIONH_ENUM 6
	skipping to change at line 57		skipping to change at line 58
	#define COHERENTESTIMATIONH_MSGEMEM "Memory allocation error"		#define COHERENTESTIMATIONH_MSGEMEM "Memory allocation error"
	#define COHERENTESTIMATIONH_MSGENULL "NULL pointer"		#define COHERENTESTIMATIONH_MSGENULL "NULL pointer"
	#define COHERENTESTIMATIONH_MSGE0DEC "invalid DetectorsData structure"		#define COHERENTESTIMATIONH_MSGE0DEC "invalid DetectorsData structure"
	#define COHERENTESTIMATIONH_MSGEDST "input time series don't all have same start time"		#define COHERENTESTIMATIONH_MSGEDST "input time series don't all have same start time"
	#define COHERENTESTIMATIONH_MSGEICE "invalid CoherentEstimation structure"		#define COHERENTESTIMATIONH_MSGEICE "invalid CoherentEstimation structure"
	#define COHERENTESTIMATIONH_MSGENUM "Numerical erorr"		#define COHERENTESTIMATIONH_MSGENUM "Numerical erorr"
	#define COHERENTESTIMATIONH_MSGEUIMP "Implemented only for 3 detectors"		#define COHERENTESTIMATIONH_MSGEUIMP "Implemented only for 3 detectors"
	typedef struct tagDetectorsData {		typedef struct tagDetectorsData {
			SWIGLAL_STRUCT(DetectorsData);
	UINT4 Ndetectors; /* number of detectors */		UINT4 Ndetectors; /* number of detectors */
	REAL4TimeSeries *data; /* data time series from all detectors */		REAL4TimeSeries *data; /* data time series from all detectors */
	} DetectorsData;		} DetectorsData;
	typedef struct tagCoherentEstimation {		typedef struct tagCoherentEstimation {
			SWIGLAL_STRUCT(CoherentEstimation);
	UINT4 Ndetectors; /* number of detectors */		UINT4 Ndetectors; /* number of detectors */
	LALDetector *detectors; /* vector of detectors info */		LALDetector *detectors; /* vector of detectors info */
	REAL8IIRFilter **filters; /* vector of pre-processing filters */		REAL8IIRFilter **filters; /* vector of pre-processing filters */
	BOOLEAN preProcessed; /* set to 0 to for pre-processing */		BOOLEAN preProcessed; /* set to 0 to for pre-processing */
	UINT2 nPreProcessed; /* number of times to apply pre-proc filters */		UINT2 nPreProcessed; /* number of times to apply pre-proc filters */
	SkyPosition *position; /* position of source (equatorial celestial coor dinates) */		SkyPosition *position; /* position of source (equatorial celestial coor dinates) */
	REAL8 polAngle; /* polarization angle: counter-clockwise angle x -axis makes with a line per- pendicular to meridian of source in Westward d irection (i.e. North of West), in decimal radians. */		REAL8 polAngle; /* polarization angle: counter-clockwise angle x -axis makes with a line per- pendicular to meridian of source in Westward d irection (i.e. North of West), in decimal radians. */
	skipping to change at line 103		skipping to change at line 106
	LALStatus *status,		LALStatus *status,
	DetectorsData *dat		DetectorsData *dat
	);		);
	void		void
	LALClearCoherentInfo (		LALClearCoherentInfo (
	LALStatus *status,		LALStatus *status,
	CoherentEstimation *dat		CoherentEstimation *dat
	);		);
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
			}
	#endif		#endif
			#endif /* _COHERENTESTIMATION_H */
End of changes. 8 change blocks.
	7 lines changed or deleted		14 lines changed or added

	ComplexFFT.h		ComplexFFT.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
	*/		*/
	/**** <lalVerbatim file="ComplexFFTHV">
	* $Id$
	**** </lalVerbatim> */
	/**** <lalLaTeX>
	*
	* \section{Header \texttt{ComplexFFT.h}}
	* \label{s:ComplexFFT.h}
	*
	* Performs complex-to-complex FFTs.
	*
	* \subsection*{Synopsis}
	* \begin{verbatim}
	* #include <lal/ComplexFFT.h>
	* \end{verbatim}
	*
	* Perform complex-to-complex fast Fourier transforms of vectors using the
	* package FFTW~\cite{fj:1998}.
	*
	**** </lalLaTeX> */
	#ifndef _COMPLEXFFT_H		#ifndef _COMPLEXFFT_H
	#define _COMPLEXFFT_H		#define _COMPLEXFFT_H
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
			#endif
			#ifdef __cplusplus
			#ifdef __GNUC__
			#define RESTRICT __restrict__
			#else
			#define RESTRICT
			#endif
			#else
			#define RESTRICT restrict
	#endif		#endif
	NRCSID( COMPLEXFFTH, "$Id$" );		NRCSID( COMPLEXFFTH, "$Id$" );
	/**** <lalLaTeX>		/**
	* \subsection*{Error conditions}		* \addtogroup ComplexFFT_h
	**** </lalLaTeX> */		*
	/**** <lalErrTable> */		* \brief Performs complex-to-complex FFTs.
			*
			* \heading{Synopsis}
			* \code
			* #include <lal/ComplexFFT.h>
			* \endcode
			*
			* Perform complex-to-complex fast Fourier transforms of vectors using the
			* package FFTW [\ref fj_1998].
			*
			*/
			/*@{*/
	#define COMPLEXFFTH_ENULL 1		/** \name Error Codes */ /*@{*/
	#define COMPLEXFFTH_ENNUL 2		#define COMPLEXFFTH_ENULL 1 /**< Null pointer */
	#define COMPLEXFFTH_ESIZE 4		#define COMPLEXFFTH_ENNUL 2 /**< Non-null pointer */
	#define COMPLEXFFTH_ESZMM 8		#define COMPLEXFFTH_ESIZE 4 /**< Invalid input size */
	#define COMPLEXFFTH_ESLEN 16		#define COMPLEXFFTH_ESZMM 8 /**< Size mismatch */
	#define COMPLEXFFTH_ESAME 32		#define COMPLEXFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */
	#define COMPLEXFFTH_EALOC 64		#define COMPLEXFFTH_ESAME 32 /**< Input/Output data vectors are the same
	#define COMPLEXFFTH_EFFTW 128		*/
	#define COMPLEXFFTH_ESNGL 256		#define COMPLEXFFTH_EALOC 64 /**< Memory allocation failed */
	#define COMPLEXFFTH_EINTL 512		#define COMPLEXFFTH_EFFTW 128 /**< Error in FFTW */
	#define COMPLEXFFTH_ESIGN 1024		#define COMPLEXFFTH_ESNGL 256 /**< FFTW library is not single-precision */
			#define COMPLEXFFTH_EINTL 512 /**< Error in Intel FFT library */
			#define COMPLEXFFTH_ESIGN 1024 /**< Unknown sign of transform in plan */
			/*@}*/
			/** \cond DONT_DOXYGEN */
	#define COMPLEXFFTH_MSGENULL "Null pointer"		#define COMPLEXFFTH_MSGENULL "Null pointer"
	#define COMPLEXFFTH_MSGENNUL "Non-null pointer"		#define COMPLEXFFTH_MSGENNUL "Non-null pointer"
	#define COMPLEXFFTH_MSGESIZE "Invalid input size"		#define COMPLEXFFTH_MSGESIZE "Invalid input size"
	#define COMPLEXFFTH_MSGESZMM "Size mismatch"		#define COMPLEXFFTH_MSGESZMM "Size mismatch"
	#define COMPLEXFFTH_MSGESLEN "Invalid/mismatched sequence lengths"		#define COMPLEXFFTH_MSGESLEN "Invalid/mismatched sequence lengths"
	#define COMPLEXFFTH_MSGESAME "Input/Output data vectors are the same"		#define COMPLEXFFTH_MSGESAME "Input/Output data vectors are the same"
	#define COMPLEXFFTH_MSGEFFTW "Error in FFTW"
	#define COMPLEXFFTH_MSGEALOC "Memory allocation failed"		#define COMPLEXFFTH_MSGEALOC "Memory allocation failed"
			#define COMPLEXFFTH_MSGEFFTW "Error in FFTW"
	#define COMPLEXFFTH_MSGESNGL "FFTW library is not single-precision"		#define COMPLEXFFTH_MSGESNGL "FFTW library is not single-precision"
	#define COMPLEXFFTH_MSGEINTL "Error in Intel FFT library"		#define COMPLEXFFTH_MSGEINTL "Error in Intel FFT library"
	#define COMPLEXFFTH_MSGESIGN "Unknown sign of transform in plan"		#define COMPLEXFFTH_MSGESIGN "Unknown sign of transform in plan"
			/** \endcond */
	/**** </lalErrTable> */
	/**** <lalLaTeX>
	*
	* \subsection*{Structures}
	*
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	/** Plan to perform FFT of COMPLEX8 data */		/** Plan to perform FFT of COMPLEX8 data */
	typedef struct tagCOMPLEX8FFTPlan COMPLEX8FFTPlan;		typedef struct tagCOMPLEX8FFTPlan COMPLEX8FFTPlan;
	/** Plan to perform FFT of COMPLEX16 data */		/** Plan to perform FFT of COMPLEX16 data */
	typedef struct tagCOMPLEX16FFTPlan COMPLEX16FFTPlan;		typedef struct tagCOMPLEX16FFTPlan COMPLEX16FFTPlan;
	#define tagComplexFFTPlan tagCOMPLEX8FFTPlan		#define tagComplexFFTPlan tagCOMPLEX8FFTPlan
	#define ComplexFFTPlan COMPLEX8FFTPlan		#define ComplexFFTPlan COMPLEX8FFTPlan
	/**** </lalVerbatim> */
	/**** <lalLaTeX>
	*
	* This structure contains the parameters necessary for performing an FFT o
	f a
	* given size and direction. The contents should not be manually adjusted.
	*
	* \newpage\input{ComplexFFTC}
	* \newpage\input{ComplexFFTTestC}
	**** </lalLaTeX> */
	/*		/*
	*		*
	* XLAL COMPLEX8 functions		* XLAL COMPLEX8 functions
	*		*
	*/		*/
	/** Returns a new COMPLEX8FFTPlan		/** Returns a new COMPLEX8FFTPlan
	*		*
	* A COMPLEX8FFTPlan is required to perform a FFT that involves complex dat a.		* A COMPLEX8FFTPlan is required to perform a FFT that involves complex dat a.
	skipping to change at line 234		skipping to change at line 223
	* @par Errors:		* @par Errors:
	* The \c XLALCOMPLEX8VectorFFT() function shall fail if:		* The \c XLALCOMPLEX8VectorFFT() 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 input and output data		* - [\c XLAL_EINVAL] A argument is invalid or the input and output data
	* vectors are the same.		* vectors are the same.
	* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are		* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are
	* incompatible.		* incompatible.
	* - [\c XLAL_ENOMEM] Insufficient storage space is available.		* - [\c XLAL_ENOMEM] Insufficient storage space is available.
	* .		* .
	*/		*/
	int XLALCOMPLEX8VectorFFT( COMPLEX8Vector * restrict output, COMPLEX8Vector * restrict input,		int XLALCOMPLEX8VectorFFT( COMPLEX8Vector * RESTRICT output, COMPLEX8Vector * RESTRICT input,
	const COMPLEX8FFTPlan *plan );		const COMPLEX8FFTPlan *plan );
	/*		/*
	*		*
	* XLAL COMPLEX16 functions		* XLAL COMPLEX16 functions
	*		*
	*/		*/
	/** Returns a new COMPLEX16FFTPlan		/** Returns a new COMPLEX16FFTPlan
	*		*
	skipping to change at line 366		skipping to change at line 355
	* @par Errors:		* @par Errors:
	* The \c XLALCOMPLEX16VectorFFT() function shall fail if:		* The \c XLALCOMPLEX16VectorFFT() 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 input and output data		* - [\c XLAL_EINVAL] A argument is invalid or the input and output data
	* vectors are the same.		* vectors are the same.
	* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are		* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are
	* incompatible.		* incompatible.
	* - [\c XLAL_ENOMEM] Insufficient storage space is available.		* - [\c XLAL_ENOMEM] Insufficient storage space is available.
	* .		* .
	*/		*/
	int XLALCOMPLEX16VectorFFT( COMPLEX16Vector * restrict output, COMPLEX16Vec tor * restrict input,		int XLALCOMPLEX16VectorFFT( COMPLEX16Vector * RESTRICT output, COMPLEX16Vec tor * RESTRICT input,
	const COMPLEX16FFTPlan *plan );		const COMPLEX16FFTPlan *plan );
	/*		/*
	*		*
	* LAL COMPLEX8 functions		* LAL COMPLEX8 functions
	*		*
	*/		*/
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan instead.		* @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan() instead.
	* @see XLALCreateForwardCOMPLEX8FFTPlan
	*/		*/
	void		void
	LALCreateForwardCOMPLEX8FFTPlan(		LALCreateForwardCOMPLEX8FFTPlan(
	LALStatus *status,		LALStatus *status,
	COMPLEX8FFTPlan **plan,		COMPLEX8FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan instead.		* @deprecated Use XLALCreateForwardCOMPLEX8FFTPlan() instead.
	* @see XLALCreateForwardCOMPLEX8FFTPlan
	*/		*/
	#define LALCreateForwardComplexFFTPlan LALCreateForwardCOMPLEX8FFTPlan		#define LALCreateForwardComplexFFTPlan LALCreateForwardCOMPLEX8FFTPlan
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan instead.		* @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan() instead.
	* @see XLALCreateReverseCOMPLEX8FFTPlan
	*/		*/
	void		void
	LALCreateReverseCOMPLEX8FFTPlan(		LALCreateReverseCOMPLEX8FFTPlan(
	LALStatus *status,		LALStatus *status,
	COMPLEX8FFTPlan **plan,		COMPLEX8FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan instead.		* @deprecated Use XLALCreateReverseCOMPLEX8FFTPlan() instead.
	* @see XLALCreateReverseCOMPLEX8FFTPlan
	*/		*/
	#define LALCreateReverseComplexFFTPlan LALCreateReverseCOMPLEX8FFTPlan		#define LALCreateReverseComplexFFTPlan LALCreateReverseCOMPLEX8FFTPlan
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALDestroyCOMPLEX8FFTPlan instead.		* @deprecated Use XLALDestroyCOMPLEX8FFTPlan() instead.
	* @see XLALDestroyCOMPLEX8FFTPlan
	*/		*/
	void		void
	LALDestroyCOMPLEX8FFTPlan (		LALDestroyCOMPLEX8FFTPlan (
	LALStatus *status,		LALStatus *status,
	COMPLEX8FFTPlan **plan		COMPLEX8FFTPlan **plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALDestroyCOMPLEX8FFTPlan instead.		* @deprecated Use XLALDestroyCOMPLEX8FFTPlan() instead.
	* @see XLALDestroyCOMPLEX8FFTPlan
	*/		*/
	#define LALDestroyComplexFFTPlan LALDestroyCOMPLEX8FFTPlan		#define LALDestroyComplexFFTPlan LALDestroyCOMPLEX8FFTPlan
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCOMPLEX8VectorFFT instead.		* @deprecated Use XLALCOMPLEX8VectorFFT() instead.
	* @see XLALCOMPLEX8VectorFFT
	*/		*/
	void		void
	LALCOMPLEX8VectorFFT (		LALCOMPLEX8VectorFFT (
	LALStatus *status,		LALStatus *status,
	COMPLEX8Vector *output,		COMPLEX8Vector *output,
	COMPLEX8Vector *input,		COMPLEX8Vector *input,
	COMPLEX8FFTPlan *plan		COMPLEX8FFTPlan *plan
	);		);
	/*		/*
	*		*
	* LAL COMPLEX16 functions		* LAL COMPLEX16 functions
	*		*
	*/		*/
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateForwardCOMPLEX16FFTPlan instead.		* @deprecated Use XLALCreateForwardCOMPLEX16FFTPlan() instead.
	* @see XLALCreateForwardCOMPLEX16FFTPlan
	*/		*/
	void		void
	LALCreateForwardCOMPLEX16FFTPlan(		LALCreateForwardCOMPLEX16FFTPlan(
	LALStatus *status,		LALStatus *status,
	COMPLEX16FFTPlan **plan,		COMPLEX16FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateReverseCOMPLEX16FFTPlan instead.		* @deprecated Use XLALCreateReverseCOMPLEX16FFTPlan() instead.
	* @see XLALCreateReverseCOMPLEX16FFTPlan
	*/		*/
	void		void
	LALCreateReverseCOMPLEX16FFTPlan(		LALCreateReverseCOMPLEX16FFTPlan(
	LALStatus *status,		LALStatus *status,
	COMPLEX16FFTPlan **plan,		COMPLEX16FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALDestroyCOMPLEX16FFTPlan instead.		* @deprecated Use XLALDestroyCOMPLEX16FFTPlan() instead.
	* @see XLALDestroyCOMPLEX16FFTPlan
	*/		*/
	void		void
	LALDestroyCOMPLEX16FFTPlan (		LALDestroyCOMPLEX16FFTPlan (
	LALStatus *status,		LALStatus *status,
	COMPLEX16FFTPlan **plan		COMPLEX16FFTPlan **plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCOMPLEX16VectorFFT instead.		* @deprecated Use XLALCOMPLEX16VectorFFT() instead.
	* @see XLALCOMPLEX16VectorFFT
	*/		*/
	void		void
	LALCOMPLEX16VectorFFT (		LALCOMPLEX16VectorFFT (
	LALStatus *status,		LALStatus *status,
	COMPLEX16Vector *output,		COMPLEX16Vector *output,
	COMPLEX16Vector *input,		COMPLEX16Vector *input,
	COMPLEX16FFTPlan *plan		COMPLEX16FFTPlan *plan
	);		);
	#ifdef __cplusplus		/*@} */
	#pragma {		#undef RESTRICT
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _COMPLEXFFT_H */		#endif /* _COMPLEXFFT_H */
End of changes. 25 change blocks.
	82 lines changed or deleted		64 lines changed or added

	ComputeDataQualityVector.h		ComputeDataQualityVector.h
	skipping to change at line 28		skipping to change at line 28
	*/		*/
	#ifndef _COMPUTE_DATA_QUALITY_VECTOR_H		#ifndef _COMPUTE_DATA_QUALITY_VECTOR_H
	#define _COMPUTE_DATA_QUALITY_VECTOR_H		#define _COMPUTE_DATA_QUALITY_VECTOR_H
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/BandPassTimeSeries.h>		#include <lal/BandPassTimeSeries.h>
	NRCSID (COMPUTE_DATA_QUALITY_VECTORH,"$Id$");		NRCSID (COMPUTE_DATA_QUALITY_VECTORH,"$Id$");
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma } /** to match the previous brace **/		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	int XLALComputeDQ(REAL4* sv_data, int r_sv,		int XLALComputeDQ(REAL4* sv_data, int r_sv,
	REAL4* lax_data, REAL4* lay_data, int r_light,		REAL4* lax_data, REAL4* lay_data, int r_light,
	COMPLEX16* gamma_data, int r_gamma,		COMPLEX16* gamma_data, int r_gamma,
	int t_bad_left, int t_bad_right, int wings,		int t_bad_left, int t_bad_right, int wings,
	int missing,		int missing,
	int* dq_data, int n_dq);		int* dq_data, int n_dq);
	#ifdef __cplusplus		#if 0
	#pragma { /** to match the next brace **/		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _COMPUTE_DATA_QUALITY_VECTOR_H */		#endif /* _COMPUTE_DATA_QUALITY_VECTOR_H */
End of changes. 3 change blocks.
	4 lines changed or deleted		6 lines changed or added

	ConfigFile.h		ConfigFile.h
	skipping to change at line 38		skipping to change at line 38
	/** \file		/** \file
	* \ingroup ConfigFile		* \ingroup ConfigFile
	* \author Reinhard Prix		* \author Reinhard Prix
	* \date $Date$		* \date $Date$
	* \brief Header file defining the API for ConfigFile.c.		* \brief Header file defining the API for ConfigFile.c.
	*/		*/
	#ifndef _CONFIGFILE_H /* Double-include protection. */		#ifndef _CONFIGFILE_H /* Double-include protection. */
	#define _CONFIGFILE_H		#define _CONFIGFILE_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/StringInput.h>		#include <lal/StringInput.h>
	/* C++ protection. */		/* C++ protection. */
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( CONFIGFILEH, "$Id$");		NRCSID( CONFIGFILEH, "$Id$");
	/** Levels of strictness for config-file parsing. */		/** Levels of strictness for config-file parsing. */
	typedef enum {		typedef enum {
	CONFIGFILE_IGNORE = 0, /**< ignore missing config-variable or unpar sed config-entries */		CONFIGFILE_IGNORE = 0, /**< ignore missing config-variable or unpar sed config-entries */
	CONFIGFILE_WARN, /**< issue a warning but don't report an err or. */		CONFIGFILE_WARN, /**< issue a warning but don't report an err or. */
	CONFIGFILE_ERROR, /**< issue an error-message and report a LAL -error */		CONFIGFILE_ERROR, /**< issue an error-message and report a LAL -error */
	CONFIGFILE_LAST		CONFIGFILE_LAST
	} ConfigStrictness;		} ConfigStrictness;
	/** This structure defines a config-variable to be read in using the		/** This structure defines a config-variable to be read in using the
	* general-purpose reading function LALReadConfigVariable(). */		* general-purpose reading function LALReadConfigVariable(). */
	typedef struct {		#ifdef SWIG /* SWIG interface directives */
			%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALConfigVar::secName;
			%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALConfigVar::varName;
			%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALConfigVar::fmt;
			#endif /* SWIG */
			typedef struct tagLALConfigVar {
			SWIGLAL_STRUCT(LALConfigVar);
	const CHAR *secName; /**< Section name within which to find varN ame. May be NULL */		const CHAR *secName; /**< Section name within which to find varN ame. May be NULL */
	const CHAR *varName; /**< Variable-name to be read in the config- file */		const CHAR *varName; /**< Variable-name to be read in the config- file */
	const CHAR *fmt; /**< Format string for reading (<tt>sscanf() </tt>-style) */		const CHAR *fmt; /**< Format string for reading (<tt>sscanf() </tt>-style) */
	ConfigStrictness strictness; /**< what to do if variable not found: ignor e, warn, error */		ConfigStrictness strictness; /**< what to do if variable not found: ignor e, warn, error */
	} LALConfigVar;		} LALConfigVar;
	/** This structure is returned by LALParseDataFile() and holds the contents of an		/** This structure is returned by LALParseDataFile() and holds the contents of an
	* ASCII data-file in a pre-parsed form, namely stripped from all comments ('#', ';'+),		* ASCII data-file in a pre-parsed form, namely stripped from all comments ('#', ';'+),
	* spurious whitespaces, and separated into lines (taking into account line -continuation		* spurious whitespaces, and separated into lines (taking into account line -continuation
	* by '\' at the end of lines).		* by '\' at the end of lines).
	* This is used as the input structure in the config-variable reading routi nes.		* This is used as the input structure in the config-variable reading routi nes.
	*/		*/
	typedef struct {		typedef struct tagLALParsedDataFile {
			SWIGLAL_STRUCT(LALParsedDataFile);
	TokenList *lines; /**< list of pre-parsed data-file lines */		TokenList *lines; /**< list of pre-parsed data-file lines */
	BOOLEAN *wasRead; /**< keep track of successfully read lines for stric tness-checking */		BOOLEAN *wasRead; /**< keep track of successfully read lines for stric tness-checking */
	} LALParsedDataFile;		} LALParsedDataFile;
	/* Function prototypes */		/* Function prototypes */
	int XLALParseDataFile (LALParsedDataFile **cfgdata, const CHAR *fname);		int XLALParseDataFile (LALParsedDataFile **cfgdata, const CHAR *fname);
	int XLALDestroyParsedDataFile (LALParsedDataFile **cfgdata);		int XLALDestroyParsedDataFile (LALParsedDataFile **cfgdata);
	int XLALConfigSectionExists(const LALParsedDataFile *, const CHAR *);		int XLALConfigSectionExists(const LALParsedDataFile *, const CHAR *);
End of changes. 3 change blocks.
	2 lines changed or deleted		14 lines changed or added

	Date.h		Date.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
	*/		*/
	/** \file		/**
	* \ingroup std		* \defgroup Date_h Time Conversions
	* \author Chin, D. W. and Creighton, J. D. E.		* \ingroup date
	* \brief Routines for converting between various time representations.		* \author D.W. Chin, J.D.E. Creighton and Kipp Cannon
	*		* \brief Provides routines for manipulating date and time information.
	*/
	/* <lalVerbatim file="DateHV">
	Author: David Chin <dwchin@umich.edu> +1-734-709-9119
	</lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{Date.h}}
	\label{s:Date.h}
	Provides routines for manipulating date and time information.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/Date.h>		#include <lal/Date.h>
	\end{verbatim}		\endcode
	This header covers routines for manipulating date and time		This header covers routines for manipulating date and time
	information. The various time systems are discussed in~\cite{esaa:1992}.		information. The various time systems are discussed in [\ref esaa1992].
	</lalLaTeX> */		*/
	#ifndef _DATE_H		#ifndef _DATE_H
	#define _DATE_H		#define _DATE_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#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
	* HOWEVER, they do no good if -ansi is used in gcc: warnings are generated		* HOWEVER, they do no good if -ansi is used in gcc: warnings are generated
	* that the prototypes have not been seen */		* that the prototypes have not been seen */
	/* HP-UX and Solaris */		/* HP-UX and Solaris */
	#ifndef _REENTRANT		#ifndef _REENTRANT
	# define _REENTRANT		# define _REENTRANT
	#endif		#endif
	skipping to change at line 88		skipping to change at line 80
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/DetectorSite.h>		#include <lal/DetectorSite.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C"		extern "C"
	{		{
	#endif		#endif
			#define XLAL_BILLION_INT4 1000000000
			#define XLAL_BILLION_INT8 LAL_INT8_C( 1000000000 )
			#define XLAL_BILLION_REAL8 1e9
			/** \ingroup Date_h *//*@{*/
	/** 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 117		skipping to change at line 114
	* \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.0 epoc h (2000 JAN 1 12h UTC). */
	#define XLAL_EPOCH_J2000_0_TAI_UTC 32 /**< Leap seconds (TAI-UTC) on the J2 000.0 epoch (2000 JAN 1 12h UTC). */		#define XLAL_EPOCH_J2000_0_TAI_UTC 32 /**< Leap seconds (TAI-UTC) on the J2 000.0 epoch (2000 JAN 1 12h UTC). */
	#define XLAL_EPOCH_J2000_0_GPS 630763213 /**< GPS seconds of the J2000.0 ep och (2000 JAN 1 12h UTC). */		#define XLAL_EPOCH_J2000_0_GPS 630763213 /**< GPS seconds of the J2000.0 ep och (2000 JAN 1 12h UTC). */
	#define XLAL_EPOCH_GPS_JD 2444244.5 /**< Julian Day of the GPS epoch (1980 JAN 6 0h UTC) */		#define XLAL_EPOCH_GPS_JD 2444244.5 /**< Julian Day of the GPS epoch (1980 JAN 6 0h UTC) */
	#define XLAL_EPOCH_GPS_TAI_UTC 19 /**< Leap seconds (TAI-UTC) on the GPS ep och (1980 JAN 6 0h UTC) */		#define XLAL_EPOCH_GPS_TAI_UTC 19 /**< Leap seconds (TAI-UTC) on the GPS ep och (1980 JAN 6 0h UTC) */
	#define XLAL_MJD_REF 2400000.5 /**< Reference Julian Day for Mean Julian Da y. */		#define XLAL_MJD_REF 2400000.5 /**< Reference Julian Day for Mean Julian Da y. */
	#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. */
			/*@}*/
	/** 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, INT4 gpsnan );		LIGOTimeGPS * XLALGPSSet( LIGOTimeGPS *epoch, INT4 gpssec, INT4 gpsnan );
	/** Sets GPS time given GPS seconds as a REAL8. */		/* Sets GPS time given GPS seconds as a REAL8. */
	LIGOTimeGPS * XLALGPSSetREAL8( LIGOTimeGPS *epoch, REAL8 t );		LIGOTimeGPS * XLALGPSSetREAL8( LIGOTimeGPS *epoch, REAL8 t );
	/** Returns GPS time as a REAL8. */		/* Returns GPS time as a REAL8. */
	REAL8 XLALGPSGetREAL8( const LIGOTimeGPS *epoch );		REAL8 XLALGPSGetREAL8( const LIGOTimeGPS *epoch );
	/** Adds dt to a GPS time. */		/* Adds dt to a GPS time. */
	LIGOTimeGPS * XLALGPSAdd( LIGOTimeGPS *epoch, REAL8 dt );		LIGOTimeGPS * XLALGPSAdd( LIGOTimeGPS *epoch, REAL8 dt );
	/** Adds two GPS times. */		/* Adds two GPS times. */
	LIGOTimeGPS * XLALGPSAddGPS( LIGOTimeGPS *epoch, const LIGOTimeGPS *dt );		LIGOTimeGPS * XLALGPSAddGPS( LIGOTimeGPS *epoch, const LIGOTimeGPS *dt );
	/** Difference between two GPS times. */		/* Difference between two GPS times. */
	REAL8 XLALGPSDiff( const LIGOTimeGPS *t1, const LIGOTimeGPS *t0 );		REAL8 XLALGPSDiff( const LIGOTimeGPS *t1, const LIGOTimeGPS *t0 );
	/** Compares two GPS times.		/* Compares two GPS times. */
	* Returns:
	* - -1 if t0 < t1
	* - 0 if t0 == t1
	* - 1 if t0 > t1.
	*/
	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 /**< [In] Seconds relative to GPS epoch.*/ );
	/** 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 /**< [In] Seconds relative to GPS epoch .*/ );
	/** 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 /**< [In] UTC as a broken down time.*/ );
	/** Returns the GPS seconds since the GPS epoch for a		/* Returns the GPS seconds since the GPS epoch for a specified UTC time str
	* specified UTC time structure. */		ucture. */
	INT4 XLALUTCToGPS( const struct tm *utc /**< [In] UTC time in a broken down time structure. */ );		INT4 XLALUTCToGPS( const struct tm *utc /**< [In] UTC time in a broken down time structure. */ );
	/** 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, /**< [Out] Pointer to tm struct where result is stored. */
	INT4 gpssec /**< [In] Seconds since the GPS epoch. */		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 /**< [In] UTC time in a broken do wn time structure. */ );
	/** Returns the Modified Julian Day (MJD) corresponding to the date given		/* Returns the Modified Julian Day (MJD) corresponding to the date given in
	* in a broken down time structure.		a broken down time structure.*/
	*
	* Note:
	* - By convention, MJD is an integer.
	* - MJD number starts at midnight rather than noon.
	*
	* If you want a Modified Julian Day that has a fractional part, simply use
	* the macro:
	*
	* #define XLAL_MODIFIED_JULIAN_DAY(utc) (XLALJulianDay(utc)-XLAL_MJD_REF)
	*/
	INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br oken down time structure. */ );		INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br oken down time structure. */ );
	/** 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		/* Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS
	* time. */		time. */
	REAL8 XLALGreenwichMeanSiderealTime(		REAL8 XLALGreenwichMeanSiderealTime(
	const LIGOTimeGPS *gpstime		const LIGOTimeGPS *gpstime
	);		);
	/** Returns the GPS time for the given Greenwich mean sidereal time (in		/* Returns the GPS time for the given Greenwich mean sidereal time (in radi
	* radians). */		ans). */
	LIGOTimeGPS *XLALGreenwichMeanSiderealTimeToGPS(		LIGOTimeGPS *XLALGreenwichMeanSiderealTimeToGPS(
	REAL8 gmst,		REAL8 gmst,
	LIGOTimeGPS *gps		LIGOTimeGPS *gps
	);		);
	/** Returns the GPS time for the given Greenwich sidereal time (in		/* Returns the GPS time for the given Greenwich sidereal time (in radians).
	* radians). */		*/
	LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS(		LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS(
	REAL8 gmst,		REAL8 gmst,
	REAL8 equation_of_equinoxes,		REAL8 equation_of_equinoxes,
	LIGOTimeGPS *gps		LIGOTimeGPS *gps
	);		);
	/* <lalLaTeX>		/** \ingroup Date_h
			* This structure is just the standard Unix \c tm structure, described
	\subsection*{Structures}		* in the man page for <tt>ctime(3)</tt>. We shall
			* {\em always} ignore the daylight savings time field, \c tm_isdst.
	\vfill{\footnotesize\input{DateHV}}
	\subsubsection*{Structure \texttt{LALUnixDate}}
	\idx[Type]{LALUnixDate}
	This structure is just the standard Unix \texttt{tm} structure, described
	in the man page for \texttt{ctime(3)}. We shall
	{\em always} ignore the daylight savings time field, \verb+tm_isdst+.
	</lalLaTeX> */
	/*
	* The standard Unix tm structure
	*/		*/
	typedef struct		typedef struct
	tm		tm
	LALUnixDate;		LALUnixDate;
	/* <lalLaTeX>		/** \ingroup Date_h
			* This structure stores pointers to a ::LALDetector and a
	\subsubsection{Structure \texttt{LALPlaceAndGPS}}		* ::LIGOTimeGPS. Its sole purpose is to aggregate these
	\idx[Type]{LALPlaceAndGPS}		* structures for passing to functions.
	This structure stores pointers to a \texttt{LALDetector} and a
	\texttt{LIGOTimeGPS}. Its sole purpose is to aggregate these
	structures for passing to functions. The fields are:
	\begin{description}
	\item{\verb+LALDetector *p_detector+} Pointer to a detector
	\item{\verb+LIGOTimeGPS *p_gps+} Pointer to a GPS time structure
	\end{description}
	</lalLaTeX> */
	/*
	* Place and time structures
	*/		*/
	/* First, with GPS */
	typedef struct		typedef struct
	tagLALPlaceAndGPS		tagLALPlaceAndGPS
	{		{
	LALDetector *p_detector; /* pointer to a detector */		SWIGLAL_STRUCT(LALPlaceAndGPS);
	LIGOTimeGPS *p_gps; /* pointer to GPS time */		LALDetector *p_detector; /**< pointer to a detector */
			LIGOTimeGPS *p_gps; /**< Pointer to a GPS time structure */
	}		}
	LALPlaceAndGPS;		LALPlaceAndGPS;
	/*		/*
	* Function prototypes		* 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
	);		);
	/* <lalLaTeX>
	\newpage\input{PlaygroundC}
	</lalLaTeX> */
	int		int
	XLALINT8NanoSecIsPlayground (		XLALINT8NanoSecIsPlayground (
	INT8 ns		INT8 ns
	);		);
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _DATE_H */		#endif /* _DATE_H */
End of changes. 35 change blocks.
	107 lines changed or deleted		59 lines changed or added

	DetResponse.h		DetResponse.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
	*/		*/
	/* <lalVerbatim file="DetResponseHV">
	Author: David Chin <dwchin@umich.edu> +1-734-709-9119
	$Id$
	</lalVerbatim>*/
	/*
	<lalLaTeX>
	\section{Header \texttt{DetResponse.h}}
	\label{sec:DetResponse.h}
	Provides routines to compute gravitational wave detector response to
	polarized planar gravitational wave originating from a given source,
	detected at a given time.
	\subsection{Synopsis}
	\label{ss:Synopsis}
	\begin{verbatim}
	#include <lal/DetResponse.h>
	\end{verbatim}
	</lalLaTeX>
	*/
	#ifndef _DETRESPONSE_H		#ifndef _DETRESPONSE_H
	#define _DETRESPONSE_H		#define _DETRESPONSE_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/LALStdio.h>		#include <lal/LALStdio.h>
	#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
	NRCSID( DETRESPONSEH, "$Id$" );		NRCSID( DETRESPONSEH, "$Id$" );
	/*		/**
	<lalLaTeX>		\author David Chin <dwchin@umich.edu>, Kipp Cannon <kipp@gravity.phys.uwm.e
	\subsection*{Error conditions}		du>
	</lalLaTeX>		\addtogroup DetResponse_h
	*/
	/*		\brief Provides routines to compute gravitational wave detector response to
	<lalErrTable>		polarized planar gravitational wave originating from a given source,
	*/		detected at a given time.
	#define DETRESPONSEH_ENULLINPUT 1
	#define DETRESPONSEH_ENULLOUTPUT 2
	#define DETRESPONSEH_ESRCNOTEQUATORIAL 3
	#define DETRESPONSEH_MSGENULLINPUT "Input is NULL"		\heading{Synopsis}
	#define DETRESPONSEH_MSGENULLOUTPUT "Output is NULL"
	#define DETRESPONSEH_MSGESRCNOTEQUATORIAL "Source coordinates not in Equato
	rial system"
	/*		\code
	</lalErrTable>		#include <lal/DetResponse.h>
	*/		\endcode
	/*		\heading{Description}
	<lalLaTeX>
	\subsection*{Types and Structures}
	</lalLaTeX>
	*/
	/* <lalLaTeX>		These routines compute the antenna beam pattern for all supported detector
			types. <tt>XLALComputeDetAMResponse()</tt> computes the response at one
			instance in time, and <tt>XLALComputeDetAMResponseSeries()</tt> computes a
			vector of response for some length of time.
	\vfill{\footnotesize\input{DetResponseHV}}		\heading{Algorithm}
	</lalLaTeX> */		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
			\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
			described in the \ref LALDetectors_h section of the \c tools package.
	/* <lalLaTeX>		\ref LALDetectors_h in the \c tools package provides predefined
	\subsubsection*{Structure \texttt{LALSource}}		\c LALDetector structures representing most current detectors,
	\idx[Type]{LALSource}		including LIGO (Hanford and Livingston), and GEO.
	This structure contains gravitational wave source position (in Equatorial		\heading{Uses}
	co\"{o}rdinates), and orientation angle. The orientation is measured		LALGPStoGMST1()
	counter-clockwise with respect to the ``line of ascending nodes'',
	\textit{i.e.} counter-clockwise with respect to a line perpendicular to the
	source's meridian and extending westwards. For a source in the Northern
	celestial hemisphere, and an observer in the Northern hemisphere standing
	such that they are facing South, this angle is measured counter-clockwise
	from a 3 o'clock position (pointing West) at the source. The polarization
	convention is chosen such that if the source orientation were zero, the
	source would be a pure $+$-polarized source.
	The fields are:		\heading{Notes}
	\begin{description}
	\item[\texttt{CHAR *name}] Name of source
	\item[\texttt{SkyPosition equatorialCoords}] Equatorial co\"{o}rdinates of
	source
	\item[\texttt{REAL8 orientation}] Orientation angle ($\psi$) of source:
	counter-clockwise angle $x$-axis makes with a line perpendicular to
	meridian of source in Westward direction (\textit{i.e.} North of West),
	in decimal radians.
	\end{description}
	</lalLaTeX> */		For examples of usage, please see the test programs in the \c test
			directory.
			*/
			/** @{ */
			/** \name Error Codes */
			/*@{*/
			#define DETRESPONSEH_ENULLINPUT 1 /**< Input is NULL */
			#define DETRESPONSEH_ENULLOUTPUT 2 /**< Output is NULL */
			#define DETRESPONSEH_ESRCNOTEQUATORIAL 3 /**< Source coordinates not
			in Equatorial system */
			/*@}*/
			/** \cond DONT_DOXYGEN */
			#define DETRESPONSEH_MSGENULLINPUT "Input is NULL"
			#define DETRESPONSEH_MSGENULLOUTPUT "Output is NULL"
			#define DETRESPONSEH_MSGESRCNOTEQUATORIAL "Source coordinates not in Equato
			rial system"
			/** \endcond */
			/** This structure contains gravitational wave source position (in Equatori
			al
			* coördinates), and orientation angle.
			* The orientation is measured counter-clockwise with respect to the "line
			of ascending nodes",
			* i.e. counter-clockwise with respect to a line perpendicular to the
			* source's meridian and extending westwards. For a source in the Northern
			* celestial hemisphere, and an observer in the Northern hemisphere standin
			g
			* such that they are facing South, this angle is measured counter-clockwis
			e
			* from a 3 o'clock position (pointing West) at the source. The polarizati
			on
			* convention is chosen such that if the source orientation were zero, the
			* source would be a pure \f$+\f$-polarized source.
			*/
	typedef struct		typedef struct
	tagLALSource		tagLALSource
	{		{
	CHAR name[LALNameLength]; /* name of source, e.g. catalog number		SWIGLAL_STRUCT(LALSource);
	*/		CHAR name[LALNameLength]; /**< name of source, eg catalog number
	SkyPosition equatorialCoords; /* equatorial coordinates of source,		*/
	in decimal RADIANS */		SkyPosition equatorialCoords; /**< equatorial coordinates of source,
	REAL8 orientation; /* counter-clockwise angle x-axis make		in decimal RADIANS */
	s		REAL8 orientation; /**< Orientation angle (\f$\psi\f$) of
	with a line perpendicular to meridi		source:
	an		* counter-clockwise angle \f$x\f$-axi
	of object in Westward direction, in		s makes with a line perpendicular to
	decimal RADIANS (i.e. North of West		* meridian of source in Westward dire
	) */		ction (i.e. North of West),
			* in decimal radians.
			*/
	}		}
	LALSource;		LALSource;
	/* <lalLaTeX>		/** This structure aggregates a pointer to a \c LALDetector and a
	\subsubsection*{Structure \texttt{LALDetAndSource}}		* \c LALSource. Its sole function is to allow the user to pass
	\idx[Type]{LALDetAndSource}		* detector and source parameters to the functions
			* LALComputeDetAMResponse() and
	This structure aggregates a pointer to a \texttt{LALDetector} and a		* LALComputeDetAMResponseSeries().
	\texttt{LALSource}. Its sole function is to allow the user to pass		*/
	detector and source parameters to the functions
	\texttt{LALComputeDetAMResponse()} and
	\texttt{LALComputeDetAMResponseSeries()}.
	The fields are:
	\begin{description}
	\item[\texttt{LALDetector *pDetector}] Pointer to \texttt{LALDetector}
	object containing information about the detector
	\item[\texttt{LALSource *pSource}] Pointer to \texttt{LALSource} object
	containing information about the source
	\end{description}
	</lalLaTeX> */
	typedef struct		typedef struct
	tagLALDetAndSource		tagLALDetAndSource
	{		{
	LALDetector *pDetector;		SWIGLAL_STRUCT(LALDetAndSource);
	LALSource *pSource;		LALDetector *pDetector; /**< Pointer to ::LALDetector object contain
			ing information about the detector */
			LALSource *pSource; /**< Pointer to ::LALSource object containin
			g information about the source */
	}		}
	LALDetAndSource;		LALDetAndSource;
	/* <lalLaTeX>		/** This structure encapsulates the detector AM (beam pattern) coefficients
	\subsubsection{Structure \texttt{LALDetAMResponse}}		for
	\idx[Type]{LALDetAMResponse}		* one source at one instance in time.
			*/
	This structure encapsulates the detector AM (beam pattern) coefficients for
	one source at one instance in time. The fields are:
	\begin{description}
	\item[\texttt{REAL4 plus}] Detector response to $+$-polarized gravitational
	radiation
	\item[\texttt{REAL4 cross}] Detector response to $\times$-polarized
	gravitational radiation
	\item[\texttt{REAL4 scalar}] Detector response to scalar gravitational
	radiation (NB: ignored at present -- scalar response computation is not
	yet implemented)
	\end{description}
	</lalLaTeX> */
	typedef struct		typedef struct
	tagLALDetAMResponse		tagLALDetAMResponse
	{		{
	REAL4 plus;		SWIGLAL_STRUCT(LALDetAMResponse);
	REAL4 cross;		REAL4 plus; /**< Detector response to \f$+\f$-polarized gravitational ra
	REAL4 scalar;		diation */
			REAL4 cross; /**< Detector response to \f$\times\f$-polarized gravitation
			al radiation */
			REAL4 scalar; /**< Detector response to scalar gravitational radia
			tion (NB: ignored at present -- scalar response computation not yet impleme
			nted) */
	}		}
	LALDetAMResponse;		LALDetAMResponse;
	/* <lalLaTeX>		/** This structure aggregates together three ::REAL4TimeSeries objects cont
	\subsubsection{Structure \texttt{LALDetAMResponseSeries}}		aining
	\idx[Type]{LALDetAMResponseSeries}		* time series of detector AM response.
			*/
	This structure aggregates together three \texttt{REAL4Vector}s containing
	time series of detector AM response. Since these quantities are
	dimensionless, they cannot be accurately stored in a \texttt{TimeSeries}
	structure. However, \texttt{REAL4Vector}s may be conveniently converted to
	\texttt{TimeSeries} format.
	\begin{description}
	\item[\texttt{REAL4TimeSeries *pPlus}] Pointer to a \texttt{REAL4TimeSeries
	}
	containing detector response to $+$-polarized gravitational radiation
	over a span of time
	\item[\texttt{REAL4TimeSeries *pCross}] Pointer to a \texttt{REAL4TimeSerie
	s}
	containing detector response to $\times$-polarized gravitational radiatio
	n
	over a span of time
	\item[\texttt{REAL4TimeSeries *pScalar}] Pointer to a \texttt{REAL4TimeSeri
	es}
	containing detector response to scalar gravitational radiation
	over a span of time. (NB: This is unused for the moment. Response to
	scalar gravitational radiation is not yet implemented.)
	\end{description}
	</lalLaTeX> */
	typedef struct		typedef struct
	tagLALDetAMResponseSeries		tagLALDetAMResponseSeries
	{		{
	REAL4TimeSeries *pPlus;		SWIGLAL_STRUCT(LALDetAMResponseSeries);
	REAL4TimeSeries *pCross;		REAL4TimeSeries *pPlus; /**< timeseries of detector response to \f$+
	REAL4TimeSeries *pScalar;		\f$-polarized gravitational radiation */
			REAL4TimeSeries *pCross; /**< timeseries of detector response to \f$\
			times\f$-polarized gravitational radiation */
			REAL4TimeSeries *pScalar; /**< timeseries of detector response to scal
			ar gravitational radiation (NB: not yet implemented.) */
	}		}
	LALDetAMResponseSeries;		LALDetAMResponseSeries;
	/* <lalLaTeX>		/** This structure encapsulates time and sampling information for computing
	\subsubsection*{Structure \texttt{LALTimeIntervalAndNSample}}		a
	\idx[Type]{LALTimeIntervalAndNSample}		* ::LALDetAMResponseSeries. Its fields correspond to some fields of the
			* TimeSeries structures for easy conversion.
	This structure encapsulates time and sampling information for computing a		*/
	\texttt{LALDetAMResponseSeries}. Its fields correspond to some fields of th
	e
	\texttt{TimeSeries} structures for easy conversion.
	\begin{description}
	\item[\texttt{LIGOTimeGPS epoch}] The start time $t_0$ of the time series
	\item[\texttt{REAL8 deltaT}] The sampling interval $\Delta t$, in seconds
	\item[\texttt{UINT4 nSample}] The total number of samples to be computed
	\item[\texttt{LALLeapSecAccuracy accuracy}] The required accuracy for handl
	ing leap seconds
	\end{description}
	</lalLaTeX> */
	typedef struct		typedef struct
	tagLALTimeIntervalAndNSample		tagLALTimeIntervalAndNSample
	{		{
	LIGOTimeGPS epoch;		SWIGLAL_STRUCT(LALTimeIntervalAndNSample);
	REAL8 deltaT; /* sampling interval */		LIGOTimeGPS epoch; /**< The start time \f$t_0\f$ of the time se
	UINT4 nSample; /* number of samples */		ries */
			REAL8 deltaT; /**< The sampling interval \f$\Delta t\f$, i
			n seconds */
			UINT4 nSample; /**< The total number of samples to be compu
			ted */
	}		}
	LALTimeIntervalAndNSample;		LALTimeIntervalAndNSample;
	/*		/*
	<lalLaTeX>
	\vfill{\footnotesize\input{DetResponseHV}}
	</lalLaTeX>
	*/
	/*
	* Function prototypes		* Function prototypes
	*/		*/
	/*
	<lalLaTeX>
	\newpage\input{DetResponseC}
	</lalLaTeX>
	*/
	void		void
	LALComputeDetAMResponse( LALStatus *status,		LALComputeDetAMResponse( LALStatus *status,
	LALDetAMResponse *pResponse,		LALDetAMResponse *pResponse,
	const LALDetAndSource *pDetAndSrc,		const LALDetAndSource *pDetAndSrc,
	const LIGOTimeGPS *gps);		const LIGOTimeGPS *gps);
	void XLALComputeDetAMResponse(		void XLALComputeDetAMResponse(
	double *fplus,		double *fplus,
	double *fcross,		double *fcross,
	REAL4 D[3][3],		REAL4 D[3][3],
	skipping to change at line 306		skipping to change at line 222
	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. 27 change blocks.
	196 lines changed or deleted		133 lines changed or added

	DetectorSite.h		DetectorSite.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
	*/		*/
	/********************************* <lalVerbatim file="DetectorSiteHV">		/*
	Author: J. T. Whelan <john.whelan@ligo.org>		* author John T. Whelan
	$Id$		* date 2007
	********************************** </lalVerbatim> */		* Dummy header file which includes LALDetectors.h for backwards compatibil
			ity
	/********************************* <lalLaTeX>
	\section{Header \texttt{DetectorSite.h}}
	\label{tools:s:DetectorSite.h}
	This is a dummy header which includes \texttt{LALDetectors.h}, for
	backwards compatibility.
	******************************************************* </lalLaTeX> */
	/**
	* \author John T. Whelan
	* \date 2007
	* \file
	* \ingroup tools
	* \brief Dummy header file which includes LALDetectors.h for backwards com
	patibility
	*
	* $Id$
	*		*
	*/		*/
	#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
	NRCSID (DETECTORSITEH, "$Id$");		NRCSID (DETECTORSITEH, "$Id$");
	/********************************** <lalVerbatim> */
	/** 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
	};		};
	/********************************** </lalVerbatim> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _DETECTORSITE_H */		#endif /* _DETECTORSITE_H */
End of changes. 3 change blocks.
	26 lines changed or deleted		5 lines changed or added

	Dirichlet.h		Dirichlet.h
	skipping to change at line 72		skipping to change at line 72
	\vfill{\footnotesize\input{DirichletHV}}		\vfill{\footnotesize\input{DirichletHV}}
	\newpage\input{DirichletC}		\newpage\input{DirichletC}
	\newpage\input{DirichletTestC}		\newpage\input{DirichletTestC}
	*********************************************************** </lalLaTeX> */		*********************************************************** </lalLaTeX> */
	#ifndef _DIRICHLET_H		#ifndef _DIRICHLET_H
	#define _DIRICHLET_H		#define _DIRICHLET_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (DIRICHLETH, "$Id$");		NRCSID (DIRICHLETH, "$Id$");
	/******************************** <lalErrTable file="DirichletHErrTable"> * /		/******************************** <lalErrTable file="DirichletHErrTable"> * /
	skipping to change at line 101		skipping to change at line 106
	#define DIRICHLETH_MSGENVALUE "Dirichlet parameter N less than or equal to zero"		#define DIRICHLETH_MSGENVALUE "Dirichlet parameter N less than or equal to zero"
	#define DIRICHLETH_MSGESIZE "Length parameter less than or equal to ze ro"		#define DIRICHLETH_MSGESIZE "Length parameter less than or equal to ze ro"
	#define DIRICHLETH_MSGEDELTAX "Spacing of x values less than or equal to zero"		#define DIRICHLETH_MSGEDELTAX "Spacing of x values less than or equal to zero"
	#define DIRICHLETH_MSGENULLPOUT "Null pointer to ouput vector"		#define DIRICHLETH_MSGENULLPOUT "Null pointer to ouput vector"
	#define DIRICHLETH_MSGESIZEMM "Length of data member of output vector do es not equal length specified in input parameters"		#define DIRICHLETH_MSGESIZEMM "Length of data member of output vector do es not equal length specified in input parameters"
	#define DIRICHLETH_MSGENULLPDOUT "Null pointer to data member of output vec tor"		#define DIRICHLETH_MSGENULLPDOUT "Null pointer to data member of output vec tor"
	/************************************ </lalErrTable> */		/************************************ </lalErrTable> */
	typedef struct tagDirichletParameters{		typedef struct tagDirichletParameters{
			SWIGLAL_STRUCT(DirichletParameters);
	UINT4 n; /* LALDirichlet parameter N */		UINT4 n; /* LALDirichlet parameter N */
	UINT4 length; /* specified length of output vector */		UINT4 length; /* specified length of output vector */
	REAL8 deltaX; /* spacing of x values */		REAL8 deltaX; /* spacing of x values */
	} DirichletParameters;		} DirichletParameters;
	void		void
	LALDirichlet(LALStatus*,		LALDirichlet(LALStatus*,
	REAL4Vector*,		REAL4Vector*,
	const DirichletParameters*);		const DirichletParameters*);
End of changes. 2 change blocks.
	0 lines changed or deleted		6 lines changed or added

	EllipsoidOverlapTools.h		EllipsoidOverlapTools.h
	skipping to change at line 32		skipping to change at line 32
	* File Name: EllipsoidOverlapTools.h		* File Name: EllipsoidOverlapTools.h
	*		*
	* Author: Robinson, C. A., and Sengupta, A.		* Author: Robinson, C. A., and Sengupta, A.
	*		*
	* Revision: $Id$		* Revision: $Id$
	*		*
	*-----------------------------------------------------------------------		*-----------------------------------------------------------------------
	*/		*/
	#if 0		#if 0
	<lalVerbatim file="EllipsoidOverlapToolsHV">
	Author: Robinson, C. A. and Sengupta, A. S.		Author: Robinson, C. A. and Sengupta, A. S.
	$Id$
	</lalVerbatim>
	#endif		#endif
	#ifndef _ELLIPSOIDOVERLAPTOOLS_H		#ifndef _ELLIPSOIDOVERLAPTOOLS_H
	#define _ELLIPSOIDOVERLAPTOOLS_H		#define _ELLIPSOIDOVERLAPTOOLS_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <math.h>		#include <math.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/LALGSL.h>		#include <lal/LALGSL.h>
	#include <lal/LALError.h>		#include <lal/LALError.h>
	#include <gsl/gsl_errno.h>		#include <gsl/gsl_errno.h>
	#include <gsl/gsl_math.h>		#include <gsl/gsl_math.h>
	#include <gsl/gsl_min.h>		#include <gsl/gsl_min.h>
	#include <gsl/gsl_vector.h>		#include <gsl/gsl_vector.h>
	#include <gsl/gsl_matrix.h>		#include <gsl/gsl_matrix.h>
	skipping to change at line 62		skipping to change at line 64
	#include <gsl/gsl_linalg.h>		#include <gsl/gsl_linalg.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( ELLIPSOIDOVERLAPTOOLSH, "$Id$" );		NRCSID( ELLIPSOIDOVERLAPTOOLSH, "$Id$" );
	typedef struct tagfContactWorkSpace		typedef struct tagfContactWorkSpace
	{		{
			SWIGLAL_STRUCT(fContactWorkSpace);
	/* Dimension of the matrices & vectors */		/* Dimension of the matrices & vectors */
	UINT4 n;		UINT4 n;
	/* Vector r_AB = r_B - r_A and */		/* Vector r_AB = r_B - r_A and */
	/* shape matrices for ellipsoid centered */		/* shape matrices for ellipsoid centered */
	/* at points A and B */		/* at points A and B */
	gsl_vector *r_AB;		gsl_vector *r_AB;
	const gsl_matrix *invQ1, *invQ2;		const gsl_matrix *invQ1, *invQ2;
	/* Parameters for minimizing the contact function */		/* Parameters for minimizing the contact function */
End of changes. 4 change blocks.
	3 lines changed or deleted		6 lines changed or added

	FileIO.h		FileIO.h
	skipping to change at line 45		skipping to change at line 45
	\noindent Only use \texttt{FileIO.h} in test code that links to		\noindent Only use \texttt{FileIO.h} in test code that links to
	the \texttt{lalsupport} library.		the \texttt{lalsupport} library.
	\vfill{\footnotesize\input{FileIOHV}}		\vfill{\footnotesize\input{FileIOHV}}
	\newpage\input{FileIOC}		\newpage\input{FileIOC}
	</lalLaTeX> */		</lalLaTeX> */
	#ifndef _FILEIO_H		#ifndef _FILEIO_H
	#define _FILEIO_H		#define _FILEIO_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	#include <stdio.h>		#include <stdio.h>
	#include <stdarg.h>		#include <stdarg.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#include <lal/LALStdio.h>		#include <lal/LALStdio.h>
	NRCSID( FILEIOH, "$Id$" );		NRCSID( FILEIOH, "$Id$" );
	/* maximum string size to print with LAL Printf routines */		/* maximum string size to print with LAL Printf routines */
	#define LAL_PRINTF_BUFSIZE 4096		#define LAL_PRINTF_BUFSIZE 4096
	FILE *		FILE *
	LALOpenDataFile( const char * );		LALOpenDataFile( const char * );
	typedef struct tagLALFILE { int compression; void *fp; } LALFILE;		typedef struct tagLALFILE {
			SWIGLAL_STRUCT(LALFILE);
			int compression;
			void *fp;
			} LALFILE;
	LALFILE *lalstdin(void);		LALFILE *lalstdin(void);
	LALFILE *lalstdout(void);		LALFILE *lalstdout(void);
	LALFILE *lalstderr(void);		LALFILE *lalstderr(void);
	#define lalstdin (lalstdin())		#define LALSTDIN (lalstdin())
	#define lalstdout (lalstdout())		#define LALSTDOUT (lalstdout())
	#define lalstderr (lalstderr())		#define LALSTDERR (lalstderr())
	int XLALFileIsCompressed( const char *path );		int XLALFileIsCompressed( const char *path );
	LALFILE * XLALFileOpenRead( const char *path );		LALFILE * XLALFileOpenRead( const char *path );
	LALFILE * XLALFileOpenWrite( const char *path, int compression );		LALFILE * XLALFileOpenWrite( const char *path, int compression );
	LALFILE * XLALFileOpenAppend( const char *path, int compression );		LALFILE * XLALFileOpenAppend( const char *path, int compression );
	LALFILE * XLALFileOpen( const char *path, const char *mode );		LALFILE * XLALFileOpen( const char *path, const char *mode );
	int XLALFileClose( LALFILE * file );		int XLALFileClose( LALFILE * file );
	size_t XLALFileRead( void *ptr, size_t size, size_t nobj, LALFILE *file );		size_t XLALFileRead( void *ptr, size_t size, size_t nobj, LALFILE *file );
	size_t XLALFileWrite( const void *ptr, size_t size, size_t nobj, LALFILE *f ile );		size_t XLALFileWrite( const void *ptr, size_t size, size_t nobj, LALFILE *f ile );
	int XLALFileGetc( LALFILE *file );		int XLALFileGetc( LALFILE *file );
	int XLALFilePutc( int c, LALFILE *file );		int XLALFilePutc( int c, LALFILE *file );
	char * XLALFileGets( char * s, int size, LALFILE *file );		char * XLALFileGets( char * s, int size, LALFILE *file );
	int XLALFilePuts( const char * s, LALFILE *file );		int XLALFilePuts( const char * s, LALFILE *file );
			#ifndef SWIG /* exclude from SWIG interface */
	int XLALFileVPrintf( LALFILE *file, const char *fmt, va_list ap );		int XLALFileVPrintf( LALFILE *file, const char *fmt, va_list ap );
			#endif /* SWIG */
	int XLALFilePrintf( LALFILE *file, const char *fmt, ... );		int XLALFilePrintf( LALFILE *file, const char *fmt, ... );
	int XLALFileFlush( LALFILE *file );		int XLALFileFlush( LALFILE *file );
	int XLALFileSeek( LALFILE *file, long offset, int whence );		int XLALFileSeek( LALFILE *file, long offset, int whence );
	long XLALFileTell( LALFILE *file );		long XLALFileTell( LALFILE *file );
	void XLALFileRewind( LALFILE *file );		void XLALFileRewind( LALFILE *file );
	int XLALFileEOF( LALFILE *file );		int XLALFileEOF( LALFILE *file );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
End of changes. 5 change blocks.
	4 lines changed or deleted		15 lines changed or added

	FindRoot.h		FindRoot.h
	skipping to change at line 47		skipping to change at line 47
	\noindent This header covers the routines for root finding.		\noindent This header covers the routines for root finding.
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	#ifndef _FINDROOT_H		#ifndef _FINDROOT_H
	#define _FINDROOT_H		#define _FINDROOT_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (FINDROOTH, "$Id$");		NRCSID (FINDROOTH, "$Id$");
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	skipping to change at line 129		skipping to change at line 134
	\item[\texttt{xacc}] The accuracy desired for the root.		\item[\texttt{xacc}] The accuracy desired for the root.
	\end{description}		\end{description}
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	typedef struct		typedef struct
	tagSFindRootIn		tagSFindRootIn
	{		{
			SWIGLAL_STRUCT(SFindRootIn);
	void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);		void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);
	REAL4 xmax;		REAL4 xmax;
	REAL4 xmin;		REAL4 xmin;
	REAL4 xacc;		REAL4 xacc;
	}		}
	SFindRootIn;		SFindRootIn;
	typedef struct		typedef struct
	tagDFindRootIn		tagDFindRootIn
	{		{
			SWIGLAL_STRUCT(DFindRootIn);
	void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);		void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);
	REAL8 xmax;		REAL8 xmax;
	REAL8 xmin;		REAL8 xmin;
	REAL8 xacc;		REAL8 xacc;
	}		}
	DFindRootIn;		DFindRootIn;
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	<lalLaTeX>		<lalLaTeX>
End of changes. 3 change blocks.
	0 lines changed or deleted		7 lines changed or added

	FlatLatticeTiling.h		FlatLatticeTiling.h
	skipping to change at line 22		skipping to change at line 22
	* 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		* \author Karl Wette
	* \file		* \ingroup pulsarTODO
	* \brief Lattice-based template generation for flat metric parameter space s		* \brief Lattice-based template generation for flat metric parameter space s
	*/		*/
	#ifndef _FLATLATTICETILING_H		#ifndef _FLATLATTICETILING_H
	#define _FLATLATTICETILING_H		#define _FLATLATTICETILING_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <gsl/gsl_vector.h>		#include <gsl/gsl_vector.h>
	#include <gsl/gsl_matrix.h>		#include <gsl/gsl_matrix.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/Random.h>		#include <lal/Random.h>
	#include <lal/GSLSupport.h>		#include <lal/GSLSupport.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID(FLATLATTICETILINGH, "$Id$");		NRCSID(FLATLATTICETILINGH, "$Id$");
	/**
	* Flat lattice tiling bound
	*/
	typedef BOOLEAN (*FlatLatticeTilingBoundFunc)(
	void *data, /**< Arbi
	trary data describing parameter space */
	INT4 dimension, /**< Dime
	nsion on which bound applies */
	gsl_vector *point, /**< Poin
	t on which to find bounds */
	REAL8 *lower, /**< Lowe
	r bound on point in dimension */
	REAL8 *upper /**< Uppe
	r bound on point in dimension */
	);
	typedef void (*FlatLatticeTilingBoundFree)(
	void *data /**< Arbitrary data
	describing parameter space */
	);
	typedef struct tagFlatLatticeTilingBound {
	/* Number of bound dimensions */
	INT4 dimensions;
	/* Dimensions which are bound */
	UINT8 is_bound;
	/* Parameter space bound function */
	FlatLatticeTilingBoundFunc func;
	/* Arbitrary data describing parameter space */
	void *data;
	/* Cleanup function */
	FlatLatticeTilingBoundFree free;
	} FlatLatticeTilingBound;
	/**
	* Flat lattice tiling subspace
	*/
	typedef struct tagFlatLatticeTilingSubspace {
	/* Total number of tiled (non-flat) dimensions */
	INT4 dimensions;
	/* Dimensions which are tiled (non-flat) */
	UINT8 is_tiled;
	/* Padding of bounds along each dimension */
	gsl_vector *padding;
	/* Increment vectors of the lattice tiling generator */		/**
	gsl_matrix *increment;		* Flat lattice tiling bound
			*/
			typedef BOOLEAN (*FlatLatticeTilingBoundFunc)(
			void *data, /**< Arbit
			rary data describing parameter space */
			INT4 dimension, /**< Dimen
			sion on which bound applies */
			gsl_vector *point, /**< Point
			on which to find bounds */
			REAL8 *lower, /**< Lower
			bound on point in dimension */
			REAL8 *upper /**< Upper
			bound on point in dimension */
			);
			typedef void (*FlatLatticeTilingBoundFree)(
			void *data /**< Arbitrary data d
			escribing parameter space */
			);
			typedef struct tagFlatLatticeTilingBound FlatLatticeTilingBound;
	} FlatLatticeTilingSubspace;		/**
			* Flat lattice tiling subspace
			*/
			typedef struct tagFlatLatticeTilingSubspace FlatLatticeTilingSubspace;
	/**		/**
	* Flat tiling lattice generator		* Flat tiling lattice generator
	*/		*/
	typedef int (*FlatTilingLatticeGenerator)(		typedef int (*FlatTilingLatticeGenerator)(
	INT4 dimensions, /**< Num		INT4 dimensions, /**< Numb
	ber of dimensions */		er of dimensions */
	gsl_matrix** generator, /**< Gen		gsl_matrix** generator, /**< Gene
	erator matrix */		rator matrix */
	REAL8* norm_thickness /**< Nor		REAL8* norm_thickness /**< Norm
	malised thickness */		alised thickness */
	);		);
	/**		/**
	* State of the flat lattice tiling algorithm		* Flat lattice tiling state/input structure
	*/		*/
	typedef enum tagFlatLatticeTilingState {		typedef struct tagFlatLatticeTiling {
	FLT_S_NotInitialised,		SWIGLAL_STRUCT(FlatLatticeTiling);
	FLT_S_NotStarted,
	FLT_S_InProgress,
	FLT_S_Finished
	} FlatLatticeTilingState;
	typedef struct tagFlatLatticeTiling {
	/* Dimension of the parameter space */		/* Dimension of the parameter space */
	INT4 dimensions;		INT4 dimensions;
	/* Parameter space bounds */		/* Parameter space bounds */
	INT4 num_bounds;		INT4 num_bounds;
	FlatLatticeTilingBound **bounds;		FlatLatticeTilingBound **bounds;
	gsl_vector_int *bound_map;		gsl_vector_int *bound_map;
	gsl_vector *bound_point;		gsl_vector *bound_point;
	/* Metric of the parameter space in normalised coordinates */		/* Metric of the parameter space in normalised coordinates */
	gsl_matrix *metric;		gsl_matrix *metric;
	/* Normalised to real parameter coordinates scaling and offset */		/* Normalised to real parameter coordinates scaling and offset */
	gsl_vector *real_scale;		gsl_vector *real_scale;
	gsl_vector *real_offset;		gsl_vector *real_offset;
	/* Maximum metric mismatch between the templates */		/* Maximum metric mismatch between the templates */
	REAL8 max_mismatch;		REAL8 max_mismatch;
	/* Flat tiling lattice generator */		/* Flat tiling lattice generator */
	FlatTilingLatticeGenerator generator;		FlatTilingLatticeGenerator generator;
	/* Cache of generated tiling subspaces */		/* Cache of generated tiling subspaces */
	INT4 num_subspaces;		INT4 num_subspaces;
	FlatLatticeTilingSubspace **subspaces;		FlatLatticeTilingSubspace **subspaces;
	/* Scaling of the padding of bounds (for testing) */		/* Scaling of the padding of bounds (for testing) */
	REAL8 scale_padding;		REAL8 scale_padding;
	/* Current dimensions which are tiled (non-flat) */		/* Current dimensions which are tiled (non-flat) */
	UINT8 curr_is_tiled;		UINT8 curr_is_tiled;
	/* Current tiling subspace */		/* Current tiling subspace */
	FlatLatticeTilingSubspace *curr_subspace;		FlatLatticeTilingSubspace *curr_subspace;
	/* Current lattice point */		/* Current lattice point */
	gsl_vector *curr_point;		gsl_vector *curr_point;
	/* Bounds on current point */		/* Bounds on current point */
	gsl_vector *curr_lower;		gsl_vector *curr_lower;
	gsl_vector *curr_upper;		gsl_vector *curr_upper;
	/* Current template */		/* Current template */
	gsl_vector *current;		gsl_vector *current;
	/* Total number of points generated so far */		/* Total number of points generated so far */
	UINT4 count;		UINT4 count;
	/* State of the tiling */		/* State of the tiling */
	FlatLatticeTilingState state;		int state;
	} FlatLatticeTiling;		} FlatLatticeTiling;
	/**		/**
	* Core functions		* Core functions
	*/		*/
	FlatLatticeTiling* XLALCreateFlatLatticeTiling(INT4);		FlatLatticeTiling* XLALCreateFlatLatticeTiling(INT4);
	void XLALFreeFlatLatticeTiling(FlatLatticeTiling*);		void XLALFreeFlatLatticeTiling(FlatLatticeTiling*);
	int XLALAddFlatLatticeTilingBound(FlatLatticeTiling*, UINT8, FlatLatticeT		int XLALAddFlatLatticeTilingBound(FlatLatticeTiling*, UINT8, FlatLatticeTil
	ilingBoundFunc, void*, FlatLatticeTilingBoundFree);		ingBoundFunc, void*, FlatLatticeTilingBoundFree);
	int XLALSetFlatLatticeTilingMetric(FlatLatticeTiling*, gsl_matrix*, REAL8		int XLALSetFlatLatticeTilingMetric(FlatLatticeTiling*, gsl_matrix*, REAL8,
	, gsl_vector*);		gsl_vector*);
	int XLALSetFlatTilingLattice(FlatLatticeTiling*, FlatTilingLatticeGenerat		int XLALSetFlatTilingLattice(FlatLatticeTiling*, FlatTilingLatticeGenerator
	or);		);
	int XLALNextFlatLatticePoint(FlatLatticeTiling*);		int XLALNextFlatLatticePoint(FlatLatticeTiling*);
	UINT4 XLALTotalFlatLatticePointCount(FlatLatticeTiling*);		UINT4 XLALTotalFlatLatticePointCount(FlatLatticeTiling*);
	int XLALRandomPointInFlatLatticeParamSpace(FlatLatticeTiling*, RandomPara		int XLALRandomPointInFlatLatticeParamSpace(FlatLatticeTiling*, RandomParams
	ms*, gsl_vector*, gsl_vector*, REAL8*);		*, gsl_vector*, gsl_vector*, REAL8*);
	/**		/**
	* Support functions		* Support functions
	*/		*/
	gsl_matrix* XLALMetricEllipsePrincipalAxes(gsl_matrix*, REAL8);		gsl_matrix* XLALMetricEllipsePrincipalAxes(gsl_matrix*, REAL8);
	gsl_vector* XLALMetricEllipseBoundingBox(gsl_matrix*, REAL8);		gsl_vector* XLALMetricEllipseBoundingBox(gsl_matrix*, REAL8);
	int XLALOrthonormaliseWRTMetric(gsl_matrix*, gsl_matrix*);		int XLALOrthonormaliseWRTMetric(gsl_matrix*, gsl_matrix*);
	gsl_matrix* XLALSquareLowerTriangularLatticeGenerator(gsl_matrix*);		gsl_matrix* XLALSquareLowerTriangularLatticeGenerator(gsl_matrix*);
	int XLALNormaliseLatticeGenerator(gsl_matrix*, REAL8, REAL8);		int XLALNormaliseLatticeGenerator(gsl_matrix*, REAL8, REAL8);
	/**		/**
	* Specific lattices and parameter spaces		* Specific lattices and parameter spaces
	*/		*/
	int XLALSetFlatTilingCubicLattice(FlatLatticeTiling*);		int XLALSetFlatTilingCubicLattice(FlatLatticeTiling*);
	int XLALSetFlatTilingAnstarLattice(FlatLatticeTiling*);		int XLALSetFlatTilingAnstarLattice(FlatLatticeTiling*);
	int XLALAddFlatLatticeTilingConstantBound(FlatLatticeTiling*, INT4, REAL8		int XLALAddFlatLatticeTilingConstantBound(FlatLatticeTiling*, INT4, REAL8,
	, REAL8);		REAL8);
	#ifdef __cplusplus		#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif		#endif
End of changes. 29 change blocks.
	147 lines changed or deleted		120 lines changed or added

	FrequencySeries.h		FrequencySeries.h
	skipping to change at line 26		skipping to change at line 26
	* You should have received a copy of the GNU General Public License along		* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,		* with this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/		*/
	#ifndef _FREQUENCYSERIES_H		#ifndef _FREQUENCYSERIES_H
	#define _FREQUENCYSERIES_H		#define _FREQUENCYSERIES_H
	#include <stddef.h>		#include <stddef.h>
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
			#if defined(__cplusplus)
			extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
	NRCSID(FREQUENCYSERIESH, "$Id:");		NRCSID(FREQUENCYSERIESH, "$Id:");
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* COMPLEX8 prototypes */
	\idx{XLALDestroyCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyCOMPLEX8FrequencySeries (		void XLALDestroyCOMPLEX8FrequencySeries (
	COMPLEX8FrequencySeries *series		COMPLEX8FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	COMPLEX8FrequencySeries *XLALCutCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALCutCOMPLEX8FrequencySeries (
	const COMPLEX8FrequencySeries *series,		const COMPLEX8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	COMPLEX8FrequencySeries *XLALResizeCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALResizeCOMPLEX8FrequencySeries (
	COMPLEX8FrequencySeries *series,		COMPLEX8FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	COMPLEX8FrequencySeries *XLALShrinkCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALShrinkCOMPLEX8FrequencySeries (
	COMPLEX8FrequencySeries *series,		COMPLEX8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	COMPLEX8FrequencySeries *XLALAddCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALAddCOMPLEX8FrequencySeries (
	COMPLEX8FrequencySeries *arg1,		COMPLEX8FrequencySeries *arg1,
	const COMPLEX8FrequencySeries *arg2		const COMPLEX8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesConjugateP">
	\idx{XLALConjugateCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesConjugateP"> */
	COMPLEX8FrequencySeries *XLALConjugateCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALConjugateCOMPLEX8FrequencySeries (
	COMPLEX8FrequencySeries *series		COMPLEX8FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyCOMPLEX8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	COMPLEX8FrequencySeries *XLALMultiplyCOMPLEX8FrequencySeries (		COMPLEX8FrequencySeries *XLALMultiplyCOMPLEX8FrequencySeries (
	COMPLEX8FrequencySeries *arg1,		COMPLEX8FrequencySeries *arg1,
	const COMPLEX8FrequencySeries *arg2		const COMPLEX8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* COMPLEX 16 prototypes */
	\idx{XLALDestroyCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyCOMPLEX16FrequencySeries (		void XLALDestroyCOMPLEX16FrequencySeries (
	COMPLEX16FrequencySeries *series		COMPLEX16FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	COMPLEX16FrequencySeries *XLALCreateCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALCreateCOMPLEX16FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	COMPLEX16FrequencySeries *XLALCutCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALCutCOMPLEX16FrequencySeries (
	const COMPLEX16FrequencySeries *series,		const COMPLEX16FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	COMPLEX16FrequencySeries *XLALResizeCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALResizeCOMPLEX16FrequencySeries (
	COMPLEX16FrequencySeries *series,		COMPLEX16FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	COMPLEX16FrequencySeries *XLALShrinkCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALShrinkCOMPLEX16FrequencySeries (
	COMPLEX16FrequencySeries *series,		COMPLEX16FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	COMPLEX16FrequencySeries *XLALAddCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALAddCOMPLEX16FrequencySeries (
	COMPLEX16FrequencySeries *arg1,		COMPLEX16FrequencySeries *arg1,
	const COMPLEX16FrequencySeries *arg2		const COMPLEX16FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesConjugateP">
	\idx{XLALConjugateCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesConjugateP"> */
	COMPLEX16FrequencySeries *XLALConjugateCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALConjugateCOMPLEX16FrequencySeries (
	COMPLEX16FrequencySeries *series		COMPLEX16FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyCOMPLEX16FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	COMPLEX16FrequencySeries *XLALMultiplyCOMPLEX16FrequencySeries (		COMPLEX16FrequencySeries *XLALMultiplyCOMPLEX16FrequencySeries (
	COMPLEX16FrequencySeries *arg1,		COMPLEX16FrequencySeries *arg1,
	const COMPLEX16FrequencySeries *arg2		const COMPLEX16FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* REAL4 prototypes */
	\idx{XLALDestroyREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyREAL4FrequencySeries (		void XLALDestroyREAL4FrequencySeries (
	REAL4FrequencySeries *series		REAL4FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	REAL4FrequencySeries *XLALCreateREAL4FrequencySeries (		REAL4FrequencySeries *XLALCreateREAL4FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	REAL4FrequencySeries *XLALCutREAL4FrequencySeries (		REAL4FrequencySeries *XLALCutREAL4FrequencySeries (
	const REAL4FrequencySeries *series,		const REAL4FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	REAL4FrequencySeries *XLALResizeREAL4FrequencySeries (		REAL4FrequencySeries *XLALResizeREAL4FrequencySeries (
	REAL4FrequencySeries *series,		REAL4FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	REAL4FrequencySeries *XLALShrinkREAL4FrequencySeries (		REAL4FrequencySeries *XLALShrinkREAL4FrequencySeries (
	REAL4FrequencySeries *series,		REAL4FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	REAL4FrequencySeries *XLALAddREAL4FrequencySeries (		REAL4FrequencySeries *XLALAddREAL4FrequencySeries (
	REAL4FrequencySeries *arg1,		REAL4FrequencySeries *arg1,
	const REAL4FrequencySeries *arg2		const REAL4FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyREAL4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	REAL4FrequencySeries *XLALMultiplyREAL4FrequencySeries (		REAL4FrequencySeries *XLALMultiplyREAL4FrequencySeries (
	REAL4FrequencySeries *arg1,		REAL4FrequencySeries *arg1,
	const REAL4FrequencySeries *arg2		const REAL4FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* REAL8 prototypes */
	\idx{XLALDestroyREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyREAL8FrequencySeries (		void XLALDestroyREAL8FrequencySeries (
	REAL8FrequencySeries *series		REAL8FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	REAL8FrequencySeries *XLALCreateREAL8FrequencySeries (		REAL8FrequencySeries *XLALCreateREAL8FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	REAL8FrequencySeries *XLALCutREAL8FrequencySeries (		REAL8FrequencySeries *XLALCutREAL8FrequencySeries (
	const REAL8FrequencySeries *series,		const REAL8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	REAL8FrequencySeries *XLALResizeREAL8FrequencySeries (		REAL8FrequencySeries *XLALResizeREAL8FrequencySeries (
	REAL8FrequencySeries *series,		REAL8FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	REAL8FrequencySeries *XLALShrinkREAL8FrequencySeries (		REAL8FrequencySeries *XLALShrinkREAL8FrequencySeries (
	REAL8FrequencySeries *series,		REAL8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	REAL8FrequencySeries *XLALAddREAL8FrequencySeries (		REAL8FrequencySeries *XLALAddREAL8FrequencySeries (
	REAL8FrequencySeries *arg1,		REAL8FrequencySeries *arg1,
	const REAL8FrequencySeries *arg2		const REAL8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyREAL8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	REAL8FrequencySeries *XLALMultiplyREAL8FrequencySeries (		REAL8FrequencySeries *XLALMultiplyREAL8FrequencySeries (
	REAL8FrequencySeries *arg1,		REAL8FrequencySeries *arg1,
	const REAL8FrequencySeries *arg2		const REAL8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* INT2 prototypes */
	\idx{XLALDestroyINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyINT2FrequencySeries (		void XLALDestroyINT2FrequencySeries (
	INT2FrequencySeries *series		INT2FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	INT2FrequencySeries *XLALCreateINT2FrequencySeries (		INT2FrequencySeries *XLALCreateINT2FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	INT2FrequencySeries *XLALCutINT2FrequencySeries (		INT2FrequencySeries *XLALCutINT2FrequencySeries (
	const INT2FrequencySeries *series,		const INT2FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	INT2FrequencySeries *XLALResizeINT2FrequencySeries (		INT2FrequencySeries *XLALResizeINT2FrequencySeries (
	INT2FrequencySeries *series,		INT2FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	INT2FrequencySeries *XLALShrinkINT2FrequencySeries (		INT2FrequencySeries *XLALShrinkINT2FrequencySeries (
	INT2FrequencySeries *series,		INT2FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	INT2FrequencySeries *XLALAddINT2FrequencySeries (		INT2FrequencySeries *XLALAddINT2FrequencySeries (
	INT2FrequencySeries *arg1,		INT2FrequencySeries *arg1,
	const INT2FrequencySeries *arg2		const INT2FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	INT2FrequencySeries *XLALMultiplyINT2FrequencySeries (		INT2FrequencySeries *XLALMultiplyINT2FrequencySeries (
	INT2FrequencySeries *arg1,		INT2FrequencySeries *arg1,
	const INT2FrequencySeries *arg2		const INT2FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* INT4 prototypes */
	\idx{XLALDestroyINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyINT4FrequencySeries (		void XLALDestroyINT4FrequencySeries (
	INT4FrequencySeries *series		INT4FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	INT4FrequencySeries *XLALCreateINT4FrequencySeries (		INT4FrequencySeries *XLALCreateINT4FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	INT4FrequencySeries *XLALCutINT4FrequencySeries (		INT4FrequencySeries *XLALCutINT4FrequencySeries (
	const INT4FrequencySeries *series,		const INT4FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	INT4FrequencySeries *XLALResizeINT4FrequencySeries (		INT4FrequencySeries *XLALResizeINT4FrequencySeries (
	INT4FrequencySeries *series,		INT4FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	INT4FrequencySeries *XLALShrinkINT4FrequencySeries (		INT4FrequencySeries *XLALShrinkINT4FrequencySeries (
	INT4FrequencySeries *series,		INT4FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	INT4FrequencySeries *XLALAddINT4FrequencySeries (		INT4FrequencySeries *XLALAddINT4FrequencySeries (
	INT4FrequencySeries *arg1,		INT4FrequencySeries *arg1,
	const INT4FrequencySeries *arg2		const INT4FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	INT4FrequencySeries *XLALMultiplyINT4FrequencySeries (		INT4FrequencySeries *XLALMultiplyINT4FrequencySeries (
	INT4FrequencySeries *arg1,		INT4FrequencySeries *arg1,
	const INT4FrequencySeries *arg2		const INT4FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* INT8 prototypes */
	\idx{XLALDestroyINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyINT8FrequencySeries (		void XLALDestroyINT8FrequencySeries (
	INT8FrequencySeries *series		INT8FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	INT8FrequencySeries *XLALCreateINT8FrequencySeries (		INT8FrequencySeries *XLALCreateINT8FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	INT8FrequencySeries *XLALCutINT8FrequencySeries (		INT8FrequencySeries *XLALCutINT8FrequencySeries (
	const INT8FrequencySeries *series,		const INT8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	INT8FrequencySeries *XLALResizeINT8FrequencySeries (		INT8FrequencySeries *XLALResizeINT8FrequencySeries (
	INT8FrequencySeries *series,		INT8FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	INT8FrequencySeries *XLALShrinkINT8FrequencySeries (		INT8FrequencySeries *XLALShrinkINT8FrequencySeries (
	INT8FrequencySeries *series,		INT8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	INT8FrequencySeries *XLALAddINT8FrequencySeries (		INT8FrequencySeries *XLALAddINT8FrequencySeries (
	INT8FrequencySeries *arg1,		INT8FrequencySeries *arg1,
	const INT8FrequencySeries *arg2		const INT8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	INT8FrequencySeries *XLALMultiplyINT8FrequencySeries (		INT8FrequencySeries *XLALMultiplyINT8FrequencySeries (
	INT8FrequencySeries *arg1,		INT8FrequencySeries *arg1,
	const INT8FrequencySeries *arg2		const INT8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* UINT2 prototypes */
	\idx{XLALDestroyUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyUINT2FrequencySeries (		void XLALDestroyUINT2FrequencySeries (
	UINT2FrequencySeries *series		UINT2FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	UINT2FrequencySeries *XLALCreateUINT2FrequencySeries (		UINT2FrequencySeries *XLALCreateUINT2FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	UINT2FrequencySeries *XLALCutUINT2FrequencySeries (		UINT2FrequencySeries *XLALCutUINT2FrequencySeries (
	const UINT2FrequencySeries *series,		const UINT2FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	UINT2FrequencySeries *XLALResizeUINT2FrequencySeries (		UINT2FrequencySeries *XLALResizeUINT2FrequencySeries (
	UINT2FrequencySeries *series,		UINT2FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	UINT2FrequencySeries *XLALShrinkUINT2FrequencySeries (		UINT2FrequencySeries *XLALShrinkUINT2FrequencySeries (
	UINT2FrequencySeries *series,		UINT2FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	UINT2FrequencySeries *XLALAddUINT2FrequencySeries (		UINT2FrequencySeries *XLALAddUINT2FrequencySeries (
	UINT2FrequencySeries *arg1,		UINT2FrequencySeries *arg1,
	const UINT2FrequencySeries *arg2		const UINT2FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyUINT2FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	UINT2FrequencySeries *XLALMultiplyUINT2FrequencySeries (		UINT2FrequencySeries *XLALMultiplyUINT2FrequencySeries (
	UINT2FrequencySeries *arg1,		UINT2FrequencySeries *arg1,
	const UINT2FrequencySeries *arg2		const UINT2FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* UINT4 prototypes */
	\idx{XLALDestroyUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyUINT4FrequencySeries (		void XLALDestroyUINT4FrequencySeries (
	UINT4FrequencySeries *series		UINT4FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	UINT4FrequencySeries *XLALCreateUINT4FrequencySeries (		UINT4FrequencySeries *XLALCreateUINT4FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	UINT4FrequencySeries *XLALCutUINT4FrequencySeries (		UINT4FrequencySeries *XLALCutUINT4FrequencySeries (
	const UINT4FrequencySeries *series,		const UINT4FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	UINT4FrequencySeries *XLALResizeUINT4FrequencySeries (		UINT4FrequencySeries *XLALResizeUINT4FrequencySeries (
	UINT4FrequencySeries *series,		UINT4FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	UINT4FrequencySeries *XLALShrinkUINT4FrequencySeries (		UINT4FrequencySeries *XLALShrinkUINT4FrequencySeries (
	UINT4FrequencySeries *series,		UINT4FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	UINT4FrequencySeries *XLALAddUINT4FrequencySeries (		UINT4FrequencySeries *XLALAddUINT4FrequencySeries (
	UINT4FrequencySeries *arg1,		UINT4FrequencySeries *arg1,
	const UINT4FrequencySeries *arg2		const UINT4FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyUINT4FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	UINT4FrequencySeries *XLALMultiplyUINT4FrequencySeries (		UINT4FrequencySeries *XLALMultiplyUINT4FrequencySeries (
	UINT4FrequencySeries *arg1,		UINT4FrequencySeries *arg1,
	const UINT4FrequencySeries *arg2		const UINT4FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesDestroyP">		/* UINT8 prototypes */
	\idx{XLALDestroyUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesDestroyP"> */
	void XLALDestroyUINT8FrequencySeries (		void XLALDestroyUINT8FrequencySeries (
	UINT8FrequencySeries *series		UINT8FrequencySeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCreateP">
	\idx{XLALCreateUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCreateP"> */
	UINT8FrequencySeries *XLALCreateUINT8FrequencySeries (		UINT8FrequencySeries *XLALCreateUINT8FrequencySeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaF,		REAL8 deltaF,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesCutP">
	\idx{XLALCutUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesCutP"> */
	UINT8FrequencySeries *XLALCutUINT8FrequencySeries (		UINT8FrequencySeries *XLALCutUINT8FrequencySeries (
	const UINT8FrequencySeries *series,		const UINT8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALResizeUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	UINT8FrequencySeries *XLALResizeUINT8FrequencySeries (		UINT8FrequencySeries *XLALResizeUINT8FrequencySeries (
	UINT8FrequencySeries *series,		UINT8FrequencySeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesShrinkP">
	\idx{XLALShrinkUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesShrinkP"> */
	UINT8FrequencySeries *XLALShrinkUINT8FrequencySeries (		UINT8FrequencySeries *XLALShrinkUINT8FrequencySeries (
	UINT8FrequencySeries *series,		UINT8FrequencySeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesAddP">
	\idx{XLALAddUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesAddP"> */
	UINT8FrequencySeries *XLALAddUINT8FrequencySeries (		UINT8FrequencySeries *XLALAddUINT8FrequencySeries (
	UINT8FrequencySeries *arg1,		UINT8FrequencySeries *arg1,
	const UINT8FrequencySeries *arg2		const UINT8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="FrequencySeriesMultiplyP">
	\idx{XLALMultiplyUINT8FrequencySeries ()}
	</lalLaTeX> <lalVerbatim file="FrequencySeriesMultiplyP"> */
	UINT8FrequencySeries *XLALMultiplyUINT8FrequencySeries (		UINT8FrequencySeries *XLALMultiplyUINT8FrequencySeries (
	UINT8FrequencySeries *arg1,		UINT8FrequencySeries *arg1,
	const UINT8FrequencySeries *arg2		const UINT8FrequencySeries *arg2
	);		);
	/* </lalVerbatim> */
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
			}
			#endif
	#endif /* _FREQUENCYSERIES_H */		#endif /* _FREQUENCYSERIES_H */
End of changes. 146 change blocks.
	289 lines changed or deleted		33 lines changed or added

	GSLSupport.h		GSLSupport.h
	skipping to change at line 61		skipping to change at line 61
	}		}
	#endif		#endif
	#endif		#endif
	/**		/**
	* Macros		* Macros
	*/		*/
	/* Allocate, print, and free 1D things */		/* Allocate, print, and free 1D things */
	#define ALLOC_GSL_1D(type, var, n, xlalerr)		#define ALLOC_GSL_1D(type, var, n, errval)
	\		\
	if ((var = gsl_ ## type ## _alloc(n)) == NULL)		if ((var = gsl_ ## type ## _alloc(n)) == NULL) {
	\		\
	xlalerr("Could not allocate '" #var "'", XLAL_ENOMEM);		XLALPrintError("%s: Could not allocate '%s'", __func__, #var);
			\
			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 */		/* Allocate, print, and free 2D things */
	#define ALLOC_GSL_2D(type, var, m, n, xlalerr)		#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) {
	\		\
	xlalerr("Could not allocate '" #var "'", XLAL_ENOMEM);		XLALPrintError("%s: Could not allocate '%s'", __func__, #var);
			\
			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) \
	for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size1; ++GSLSUPPORT_i) { \		for (GSLSUPPORT_i = 0; GSLSUPPORT_i < var->size1; ++GSLSUPPORT_i) { \
	for (GSLSUPPORT_j = 0; GSLSUPPORT_j < var->size2; ++GSLSUPPORT_j) \		for (GSLSUPPORT_j = 0; GSLSUPPORT_j < var->size2; ++GSLSUPPORT_j) \
	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 */		/* Allocate, print, and free gsl_vector */
	#define ALLOC_GSL_VECTOR(var, n, xlalerr) ALLOC_GSL_1D(vector, var, n, xlal		#define ALLOC_GSL_VECTOR(var, n, errval) ALLOC_GSL_1D(vector, var, n, errva
	err)		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 */		/* Allocate, print, and free gsl_vector_int */
	#define ALLOC_GSL_VECTOR_INT(var, n, xlalerr) ALLOC_GSL_1D(vector_int, var,		#define ALLOC_GSL_VECTOR_INT(var, n, errval) ALLOC_GSL_1D(vector_int, var,
	n, xlalerr)		n, errval)
	#define PRINT_GSL_VECTOR_INT(var) PRINT_GSL_1D(vector_int, var,		#define PRINT_GSL_VECTOR_INT(var) PRINT_GSL_1D(vector_int, var,
	"%i ")		"%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 */		/* Allocate, print, and free gsl_matrix */
	#define ALLOC_GSL_MATRIX(var, m, n, xlalerr) ALLOC_GSL_2D(matrix, var, m, n		#define ALLOC_GSL_MATRIX(var, m, n, errval) ALLOC_GSL_2D(matrix, var, m, n,
	, xlalerr)		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 */		/* Allocate, print, and free gsl_matrix_int */
	#define ALLOC_GSL_MATRIX_INT(var, m, n, xlalerr) ALLOC_GSL_2D(matrix_int, v		#define ALLOC_GSL_MATRIX_INT(var, m, n, errval) ALLOC_GSL_2D(matrix_int, va
	ar, m, n, xlalerr)		r, m, n, errval)
	#define PRINT_GSL_MATRIX_INT(var) PRINT_GSL_2D(matrix_int, v		#define PRINT_GSL_MATRIX_INT(var) PRINT_GSL_2D(matrix_int, va
	ar, "%i ")		r, "%i ")
	#define FREE_GSL_MATRIX_INT(var) FREE_GSL_2D(matrix_int, va		#define FREE_GSL_MATRIX_INT(var) FREE_GSL_2D(matrix_int, var
	r)		)
	/* Allocate, print, and free gsl_combination */		/* Allocate, print, and free gsl_combination */
	#define ALLOC_GSL_COMBINATION(var, n, xlalerr) ALLOC_GSL_1D(combination, va		#define ALLOC_GSL_COMBINATION(var, n, errval) ALLOC_GSL_1D(combination, var
	r, n, xlalerr)		, n, errval)
	#define PRINT_GSL_COMBINATION(var) PRINT_GSL_1D(combination, va		#define PRINT_GSL_COMBINATION(var) PRINT_GSL_1D(combination, var
	r, "%i ")		, "%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 */		/* Allocate, print, and free gsl_permutation */
	#define ALLOC_GSL_PERMUTATION(var, n, xlalerr) ALLOC_GSL_1D(permutation, va		#define ALLOC_GSL_PERMUTATION(var, n, errval) ALLOC_GSL_1D(permutation, var
	r, n, xlalerr)		, n, errval)
	#define PRINT_GSL_PERMUTATION(var) PRINT_GSL_1D(permutation, va		#define PRINT_GSL_PERMUTATION(var) PRINT_GSL_1D(permutation, var
	r, "%i ")		, "%i ")
	#define FREE_GSL_PERMUTATION(var) FREE_GSL_1D(permutation, var		#define FREE_GSL_PERMUTATION(var) FREE_GSL_1D(permutation, var)
	)
End of changes. 8 change blocks.
	36 lines changed or deleted		43 lines changed or added

	Grid.h		Grid.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
	*/		*/
	/***************************************** <lalVerbatim file="GridHV">		/**
	Author: Creighton, T. D.		\author Creighton, T. D.
	$Id$		\file
	**************************************************** </lalVerbatim> */
	/********************************************************** <lalLaTeX>
	\section{Header \texttt{Grid.h}}
	\label{s:Grid.h}
	Provides a structured datatype for a multidimensional rectilinear		\brief Provides a structured datatype for a multidimensional rectilinear gr
	grid.		id.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/Grid.h>		#include <lal/Grid.h>
	\end{verbatim}		\endcode
	\noindent This header provides a new structured datatype storing data		This header provides a new structured datatype storing data
	on a multidimensional rectilinear grid. It is in some sense a		on a multidimensional rectilinear grid. It is in some sense a
	generalization of the series datatypes (frequency series, time series,		generalization of the series datatypes (frequency series, time series,
	etc.), representing evenly-sampled data over some physical parameter		etc.), representing evenly-sampled data over some physical parameter
	space.		space.
	******************************************************* </lalLaTeX> */		*/
	#ifndef _GRID_H		#ifndef _GRID_H
	#define _GRID_H		#define _GRID_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( GRIDH, "$Id$" );		NRCSID( GRIDH, "$Id$" );
	/********************************************************** <lalLaTeX>		/**
	\subsection*{Error conditions}		\heading{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		\name Error Codes */ /*@{*/
	#define GRIDH_ENUL 1		#define GRIDH_ENUL 1
	#define GRIDH_EOUT 2		#define GRIDH_EOUT 2
	#define GRIDH_EMEM 3		#define GRIDH_EMEM 3
	#define GRIDH_MSGENUL "Unexpected null pointer in arguments"		#define GRIDH_MSGENUL "Unexpected null pointer in arguments"
	#define GRIDH_MSGEOUT "Output handle points to a non-null pointer"		#define GRIDH_MSGEOUT "Output handle points to a non-null pointer"
	#define GRIDH_MSGEMEM "Memory allocation error"		#define GRIDH_MSGEMEM "Memory allocation error"
	/******************************************** </lalErrTable><lalLaTeX>		/*@}*//**
	\subsection*{Types}		\heading{Types}
	\subsubsection*{Structure \texttt{<datatype>Grid}}		\heading{Structure <tt>\<datatype\>Grid</tt>}
	\idx[Type]{INT2Grid}
	\idx[Type]{INT4Grid}
	\idx[Type]{INT8Grid}
	\idx[Type]{UINT2Grid}
	\idx[Type]{UINT4Grid}
	\idx[Type]{UINT8Grid}
	\idx[Type]{REAL4Grid}
	\idx[Type]{REAL8Grid}
	\idx[Type]{COMPLEX8Grid}
	\idx[Type]{COMPLEX16Grid}
	\noindent This structure is a generalization of the LAL series types,		This structure is a generalization of the LAL series types,
	storing data on an $m$-dimensional rectangular grid on a physical		storing data on an \f$m\f$-dimensional rectangular grid on a physical
	parameter space. The values on the grid are of type \verb@<datatype>@		parameter space. The values on the grid are of type <tt>\<datatype\></tt>
	which can be any LAL primitive \emph{numerical} datatype (\verb@INT2@,		which can be any LAL primitive \e numerical datatype (\c INT2,
	\verb@INT4@, \verb@INT8@, \verb@UINT2@, \verb@UINT4@, \verb@UINT8@,		\c INT4, \c INT8, \c UINT2, \c UINT4, \c UINT8,
	\verb@REAL4@, \verb@REAL8@, \verb@COMPLEX8@, \verb@COMPLEX16@). The		\c REAL4, \c REAL8, \c COMPLEX8, \c COMPLEX16). The
	data are stored in an array of dimension $M\geq m$: if $M=m$, then the		data are stored in an array of dimension \f$M\geq m\f$: if \f$M=m\f$, then
	structure stores a single value for each grid point; if $M>m$, then		the
			structure stores a single value for each grid point; if \f$M>m\f$, then
	the structure stores a vector or array of values on the ``tangent		the structure stores a vector or array of values on the ``tangent
	space'' of each grid point. We refer to $m$ as the \emph{grid}		space'' of each grid point. We refer to \f$m\f$ as the \e grid
	dimension and $M$ as the \emph{data} dimension. The fields of the		dimension and \f$M\f$ as the \e data dimension. The fields of the
	structure are:		structure are:
	\begin{description}		<dl>
	\item[\texttt{CHAR name[LALNameLength]}] A name identifying the grid		<dt><tt>CHAR name[LALNameLength]</tt></dt><dd> A name identifying the grid
	and/or the data being sampled.		and/or the data being sampled.</dd>
	\item[\texttt{LALUnit sampleUnits}] The physical units of the		<dt><tt>LALUnit sampleUnits</tt></dt><dd> The physical units of the
	quantities on the grid.		quantities on the grid.</dd>
	\item[\texttt{LALUnit *dimUnits}] The physical units of the grid axes.		<dt><tt>LALUnit *dimUnits</tt></dt><dd> The physical units of the grid axes
	This must be allocated as an array of length $m$.		.
			This must be allocated as an array of length \f$m\f$.</dd>
	\item[\texttt{REAL8Vector *offset}] A vector $\mathbf{p}_0$		<dt><tt>REAL8Vector *offset</tt></dt><dd> A vector \f$\mathbf{p}_0\f$
	specifying the location of the grid point indexed by $(0,\ldots,0)$.		specifying the location of the grid point indexed by \f$(0,\ldots,0)\f$.
	Must have dimensionality $m$.		Must have dimensionality \f$m\f$.</dd>
	\item[\texttt{REAL8Vector *interval}] The vector $\Delta\mathbf{p}$		<dt><tt>REAL8Vector *interval</tt></dt><dd> The vector \f$\Delta\mathbf{p}\ f$
	specifying the grid spacing in each dimension. Must have		specifying the grid spacing in each dimension. Must have
	dimensionality $m$.		dimensionality \f$m\f$.</dd>
	\item[\texttt{<datatype>Array *data}] Pointer to an array storing the		<dt><tt>\<datatype\>Array *data</tt></dt><dd> Pointer to an array storing t he
	data values at the corresponding grid points. The data dimension		data values at the corresponding grid points. The data dimension
	$M=$\verb@data->dimLength->length@ must be greater than or equal to		\f$M=\f$<tt>data->dimLength->length</tt> must be greater than or equal to
	the grid dimension $m=$\verb@offset->length@=\verb@interval->length@.		the grid dimension \f$m=\f$<tt>offset->length</tt>=<tt>interval->length</tt
	An index $\mathbf{i}=(i_0,\ldots,i_{M-1})$, where $i_k$ are integers		>.
	from 0 to \verb@data->dimLength->data@${}_k$, specifies a grid point		An index \f$\mathbf{i}=(i_0,\ldots,i_{M-1})\f$, where \f$i_k\f$ are integer
	located at $\mathbf{p}=\mathbf{p}_0+\sum_{k=0}^{n-1}\hat{\mathbf{e}}_k		s
	i_k \Delta p_k$ if $M=m$, or an array element $\mathsf{A}_{i_m\cdots		from 0 to <tt>data->dimLength->data</tt>\f${}_k\f$, specifies a grid point
	i_{M-1}}$ at that grid point if $M>m$. The values in		located at \f$\mathbf{p}=\mathbf{p}_0+\sum_{k=0}^{n-1}\hat{\mathbf{e}}_k
	\verb@data->data@ are the value stored at each grid point (or array		i_k \Delta p_k\f$ if \f$M=m\f$, or an array element \f$\mathsf{A}_{i_m\cdot
			s
			i_{M-1}}\f$ at that grid point if \f$M>m\f$. The values in
			<tt>data->data</tt> are the value stored at each grid point (or array
	element at each grid point), arranged in the manner discussed in		element at each grid point), arranged in the manner discussed in
	\verb@LALDatatypes.h@.		\ref LALDatatypes.h.</dd>
	\end{description}		</dl>
	******************************************************* </lalLaTeX> */		*/
	typedef struct tagINT2Grid {		typedef struct tagINT2Grid {
			SWIGLAL_STRUCT(INT2Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	INT2Array *data;		INT2Array *data;
	} INT2Grid;		} INT2Grid;
	typedef struct tagINT4Grid {		typedef struct tagINT4Grid {
			SWIGLAL_STRUCT(INT4Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	INT4Array *data;		INT4Array *data;
	} INT4Grid;		} INT4Grid;
	typedef struct tagINT8Grid {		typedef struct tagINT8Grid {
			SWIGLAL_STRUCT(INT8Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	INT8Array *data;		INT8Array *data;
	} INT8Grid;		} INT8Grid;
	typedef struct tagUINT2Grid {		typedef struct tagUINT2Grid {
			SWIGLAL_STRUCT(UINT2Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	UINT2Array *data;		UINT2Array *data;
	} UINT2Grid;		} UINT2Grid;
	typedef struct tagUINT4Grid {		typedef struct tagUINT4Grid {
			SWIGLAL_STRUCT(UINT4Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	UINT4Array *data;		UINT4Array *data;
	} UINT4Grid;		} UINT4Grid;
	typedef struct tagUINT8Grid {		typedef struct tagUINT8Grid {
			SWIGLAL_STRUCT(UINT8Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	UINT8Array *data;		UINT8Array *data;
	} UINT8Grid;		} UINT8Grid;
	typedef struct tagREAL4Grid {		typedef struct tagREAL4Grid {
			SWIGLAL_STRUCT(REAL4Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	REAL4Array *data;		REAL4Array *data;
	} REAL4Grid;		} REAL4Grid;
	typedef struct tagREAL8Grid {		typedef struct tagREAL8Grid {
			SWIGLAL_STRUCT(REAL8Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	REAL8Array *data;		REAL8Array *data;
	} REAL8Grid;		} REAL8Grid;
	typedef struct tagCOMPLEX8Grid {		typedef struct tagCOMPLEX8Grid {
			SWIGLAL_STRUCT(COMPLEX8Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	COMPLEX8Array *data;		COMPLEX8Array *data;
	} COMPLEX8Grid;		} COMPLEX8Grid;
	typedef struct tagCOMPLEX16Grid {		typedef struct tagCOMPLEX16Grid {
			SWIGLAL_STRUCT(COMPLEX16Grid);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LALUnit sampleUnits;		LALUnit sampleUnits;
	LALUnit *dimUnits;		LALUnit *dimUnits;
	REAL8Vector *offset;		REAL8Vector *offset;
	REAL8Vector *interval;		REAL8Vector *interval;
	COMPLEX16Array *data;		COMPLEX16Array *data;
	} COMPLEX16Grid;		} COMPLEX16Grid;
	/* <lalLaTeX>
	\vfill{\footnotesize\input{GridHV}}
	</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{GridC}
	</lalLaTeX> */
	void		void
	LALI2CreateGrid( LALStatus *status, INT2Grid **grid, UINT4Vector *dimLength , UINT4 dimension );		LALI2CreateGrid( LALStatus *status, INT2Grid **grid, UINT4Vector *dimLength , UINT4 dimension );
	void		void
	LALI4CreateGrid( LALStatus *status, INT4Grid **grid, UINT4Vector *dimLength , UINT4 dimension );		LALI4CreateGrid( LALStatus *status, INT4Grid **grid, UINT4Vector *dimLength , UINT4 dimension );
	void		void
	LALI8CreateGrid( LALStatus *status, INT8Grid **grid, UINT4Vector *dimLength , UINT4 dimension );		LALI8CreateGrid( LALStatus *status, INT8Grid **grid, UINT4Vector *dimLength , UINT4 dimension );
	void		void
	skipping to change at line 288		skipping to change at line 279
	void		void
	LALDDestroyGrid( LALStatus *status, REAL8Grid **grid );		LALDDestroyGrid( LALStatus *status, REAL8Grid **grid );
	void		void
	LALCDestroyGrid( LALStatus *status, COMPLEX8Grid **grid );		LALCDestroyGrid( LALStatus *status, COMPLEX8Grid **grid );
	void		void
	LALZDestroyGrid( LALStatus *status, COMPLEX16Grid **grid );		LALZDestroyGrid( LALStatus *status, COMPLEX16Grid **grid );
	/* <lalLaTeX>		/**
	%\newpage\input{GridTestC}		%
	</lalLaTeX> */		*/
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _GRID_H */		#endif /* _GRID_H */
End of changes. 35 change blocks.
	76 lines changed or deleted		73 lines changed or added

	IIRFilter.h		IIRFilter.h
	skipping to change at line 109		skipping to change at line 109
	I have adopted the convention of including a redundant recursive		I have adopted the convention of including a redundant recursive
	coefficient $d_0$, in order to make the indexing more intuitive. For		coefficient $d_0$, in order to make the indexing more intuitive. For
	formal correctness $d_0$ should be set to $-1$, although the filtering		formal correctness $d_0$ should be set to $-1$, although the filtering
	routines never actually use this coefficient.		routines never actually use this coefficient.
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
	#ifndef _IIRFILTER_H		#ifndef _IIRFILTER_H
	#define _IIRFILTER_H		#define _IIRFILTER_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/ZPGFilter.h>		#include <lal/ZPGFilter.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID(IIRFILTERH,"$Id$");		NRCSID(IIRFILTERH,"$Id$");
	/********************************************************** <lalLaTeX>		/********************************************************** <lalLaTeX>
	\subsection*{Error conditions}		\subsection*{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		****************************************** </lalLaTeX><lalErrTable> */
	#define IIRFILTERH_ENUL 1		#define IIRFILTERH_ENUL 1
	#define IIRFILTERH_EOUT 2		#define IIRFILTERH_EOUT 2
	#define IIRFILTERH_EMEM 3		#define IIRFILTERH_EMEM 3
	skipping to change at line 162		skipping to change at line 168
	coefficients.		coefficients.
	\item[\texttt{<datatype>Vector *recursCoef}] The recursive filter		\item[\texttt{<datatype>Vector *recursCoef}] The recursive filter
	coefficients.		coefficients.
	\item[\texttt{<datatype>Vector *history}] The previous values of $w$.		\item[\texttt{<datatype>Vector *history}] The previous values of $w$.
	\end{description}		\end{description}
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
			#ifdef SWIG /* SWIG interface directives */
			%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL4IIRFilter::name;
			#endif /* SWIG */
	typedef struct tagREAL4IIRFilter{		typedef struct tagREAL4IIRFilter{
			SWIGLAL_STRUCT(REAL4IIRFilter);
	const CHAR *name; /* User assigned name. */		const CHAR *name; /* User assigned name. */
	REAL8 deltaT; /* Sampling time interval. */		REAL8 deltaT; /* Sampling time interval. */
	REAL4Vector *directCoef; /* The direct filter coefficients. */		REAL4Vector *directCoef; /* The direct filter coefficients. */
	REAL4Vector *recursCoef; /* The recursive filter coefficients. */		REAL4Vector *recursCoef; /* The recursive filter coefficients. */
	REAL4Vector *history; /* The previous values of w. */		REAL4Vector *history; /* The previous values of w. */
	} REAL4IIRFilter;		} REAL4IIRFilter;
			#ifdef SWIG /* SWIG interface directives */
			%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL8IIRFilter::name;
			#endif /* SWIG */
	typedef struct tagREAL8IIRFilter{		typedef struct tagREAL8IIRFilter{
			SWIGLAL_STRUCT(REAL8IIRFilter);
	const CHAR *name; /* User assigned name. */		const CHAR *name; /* User assigned name. */
	REAL8 deltaT; /* Sampling time interval. */		REAL8 deltaT; /* Sampling time interval. */
	REAL8Vector *directCoef; /* The direct filter coefficients. */		REAL8Vector *directCoef; /* The direct filter coefficients. */
	REAL8Vector *recursCoef; /* The recursive filter coefficients. */		REAL8Vector *recursCoef; /* The recursive filter coefficients. */
	REAL8Vector *history; /* The previous values of w. */		REAL8Vector *history; /* The previous values of w. */
	} REAL8IIRFilter;		} REAL8IIRFilter;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vfill{\footnotesize\input{IIRFilterHV}}		\vfill{\footnotesize\input{IIRFilterHV}}
	</lalLaTeX> */		</lalLaTeX> */
	skipping to change at line 280		skipping to change at line 294
	void		void
	LALDIIRFilterREAL4VectorR( LALStatus *status,		LALDIIRFilterREAL4VectorR( LALStatus *status,
	REAL4Vector *vector,		REAL4Vector *vector,
	REAL8IIRFilter *filter );		REAL8IIRFilter *filter );
	/* <lalLaTeX>		/* <lalLaTeX>
	\newpage\input{IIRFilterTestC}		\newpage\input{IIRFilterTestC}
	</lalLaTeX> */		</lalLaTeX> */
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _IIRFILTER_H */		#endif /* _IIRFILTER_H */
End of changes. 8 change blocks.
	4 lines changed or deleted		19 lines changed or added

	Inject.h		Inject.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
	*/		*/
	/*************************************** <lalVerbatim file="InjectHV">		#ifndef _INJECT_H
	Author: Creighton, T. D.		#define _INJECT_H
	$Id$
	**************************************************** </lalVerbatim> */
	/********************************************************** <lalLaTeX>		#include <lal/LALStdlib.h>
			#include <lal/Random.h>
	\section{Header \texttt{Inject.h}}		#if defined(__cplusplus)
	\label{s:Inject.h}		extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
	Provides routines to inject a signal into detector output.		NRCSID( INJECTH, "$Id$" );
	\subsection*{Synopsis}		/**
	\begin{verbatim}		\author Creighton, T. D.
			\addtogroup Inject_h
			\brief Provides routines to inject a signal into detector output.
			\heading{Synopsis}
			\code
	#include <lal/Inject.h>		#include <lal/Inject.h>
	\end{verbatim}		\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
	represents the ADC output of a detector channel.		represents the ADC output of a detector channel.
	The basic concept at work here is that of \emph{dithering}. That is,		The basic concept at work here is that of \e dithering. That is,
	to add a real signal $x(t_k)$ to the integer output $n(t_k)$ of an		to add a real signal \f$x(t_k)\f$ to the integer output \f$n(t_k)\f$ of an
	ADC, we cannot simply compute $x+n$ at each time $t_k$ and round to		ADC, we cannot simply compute \f$x+n\f$ at each time \f$t_k\f$ and round to
	the nearest integer. To see this, consider injecting a sinusoid with		the nearest integer. To see this, consider injecting a sinusoid with
	an amplitude less than half the ADC resolution, $|x|<0.5$. Then		an amplitude less than half the ADC resolution, \f$|x|<0.5\f$. Then
	adding $x+n$ and rounding will always give back $n$, and the signal		adding \f$x+n\f$ and rounding will always give back \f$n\f$, and the signal
	injection will have no effect on the output.		injection will have no effect on the output.
	Instead, what we would like to do is to add $x$ to the ADC		Instead, what we would like to do is to add \f$x\f$ to the ADC
	\emph{input} before rounding occurs, and then round to an integer.		\e input before rounding occurs, and then round to an integer.
	That is, the ADC input was actually $n+d$, where $d\in[-0.5,0.5)$; we		That is, the ADC input was actually \f$n+d\f$, where \f$d\in[-0.5,0.5)\f$;
	want to compute the rounded value of $n+d+x$, which may occasionally		we
	be different from $n$. In principle, a Fourier transforms can detect		want to compute the rounded value of \f$n+d+x\f$, which may occasionally
			be different from \f$n\f$. In principle, a Fourier transforms can detect
	a sinusoidal signal with an output much smaller than the ADC		a sinusoidal signal with an output much smaller than the ADC
	resolution: by integrating enough data, one can eventually detect a		resolution: by integrating enough data, one can eventually detect a
	statistically significant phase correlation between the occasional		statistically significant phase correlation between the occasional
	increments and decrements in $n$.		increments and decrements in \f$n\f$.
	Of course given the output time series $n(t_k)$ we can only guess at		Of course given the output time series \f$n(t_k)\f$ we can only guess at
	the input series $n(t_k)+d(t_k)$ that produced it. The simplest guess		the input series \f$n(t_k)+d(t_k)\f$ that produced it. The simplest guess
	is to assume that each $d(t_k)$ is an independent random variable with		is to assume that each \f$d(t_k)\f$ is an independent random variable with
	a flat distribution over the range $[-0.5,0.5)$. This is a reasonable		a flat distribution over the range \f$[-0.5,0.5)\f$. This is a reasonable
	guess to make if the root mean square variation between succesive		guess to make if the root mean square variation between succesive
	output values $n$ is a few or more ADC counts; i.e. if the		output values \f$n\f$ is a few or more ADC counts; i.e. if the
	dimensionless power spectral density $\sqrt{fS(f)}$ has a value of a		dimensionless power spectral density \f$\sqrt{fS(f)}\f$ has a value of a
	few or more around the sampling freqeuncy $f$. This is almost always		few or more around the sampling freqeuncy \f$f\f$. This is almost always
	true of any detector designed to work at or near its noise limit: the		true of any detector designed to work at or near its noise limit: the
	input to the ADC will first be whitened so that $\sqrt{fS(f)}$ is		input to the ADC will first be whitened so that \f$\sqrt{fS(f)}\f$ is
	nearly flat, and then amplified so that $\sqrt{fS(f)}$ is on the order		nearly flat, and then amplified so that \f$\sqrt{fS(f)}\f$ is on the order
	of several (or more) ADC counts.		of several (or more) ADC counts.
	In the routines covered by this header we will take it for granted		In the routines covered by this header we will take it for granted
	that the above is a reasonable approximation, and will not check for		that the above is a reasonable approximation, and will not check for
	it. We will further assume that the signal to be injected has already		it. We will further assume that the signal to be injected has already
	been subjected to the same whitening and amplification, so that the		been subjected to the same whitening and amplification, so that the
	units of $x(t_k)$ are normalized ADC counts (although it is still a		units of \f$x(t_k)\f$ are normalized ADC counts (although it is still a
	real number, not an integer).		real number, not an integer).
	The dithering routines should be used whenever one is injecting a		The dithering routines should be used whenever one is injecting a
	signal into a time series representing raw digitized data. In some		signal into a time series representing raw digitized data. In some
	data storage specifications, ADC output is not stored as an integer,		data storage specifications, ADC output is not stored as an integer,
	but as a floating-point number representing an integer value. Such		but as a floating-point number representing an integer value. Such
	data must be cast to integers before being passed to the digitizing		data must be cast to integers before being passed to the digitizing
	routines.		routines.
	This header also provides even simpler routines for injecting a signal		This header also provides even simpler routines for injecting a signal
	into floating-point data, without dithering. These should only be		into floating-point data, without dithering. These should only be
	used when the data is genuinely continuous in character. This can		used when the data is genuinely continuous in character. This can
	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.
	******************************************************* </lalLaTeX> */		@{
			\defgroup InjectVector_c Module InjectVector.c
	#ifndef _INJECT_H		\defgroup InjectTimeSeries_c Module InjectTimeSeries.c
	#define _INJECT_H		*/
			/** \name Error Codes */ /**@{*/
	#include <lal/LALStdlib.h>		#define INJECTH_ENUL 1 /**< Unexpected null pointer in arguments. *
	#include <lal/Random.h>		/
			#define INJECTH_EBAD 2 /**< A sampling interval is (effectively) zero */
	#ifdef __cplusplus		#define INJECTH_EUNIT 3 /**< Input or output is not in units of ADC
	extern "C" {		counts */
	#pragma }		/** @}*/
	#endif		/** @}*/
	NRCSID( INJECTH, "$Id$" );
	/********************************************************** <lalLaTeX>
	\subsection*{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */
	#define INJECTH_ENUL 1
	#define INJECTH_EBAD 2
	#define INJECTH_EUNIT 3
	#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"
	/******************************************** </lalErrTable><lalLaTeX>
	\subsection*{Types}
	******************************************************* </lalLaTeX> */
	/* <lalLaTeX>
	\vfill{\footnotesize\input{InjectHV}}
	</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{InjectVectorC}
	</lalLaTeX> */
	void		void
	LALSI2InjectVector( LALStatus *,		LALSI2InjectVector( LALStatus *,
	INT2Vector *output,		INT2Vector *output,
	REAL4Vector *signalvec,		REAL4Vector *signalvec,
	RandomParams *params );		RandomParams *params );
	void		void
	LALSSInjectVector( LALStatus *,		LALSSInjectVector( LALStatus *,
	REAL4Vector *output,		REAL4Vector *output,
	REAL4Vector *signalvec );		REAL4Vector *signalvec );
	/* <lalLaTeX>
	\newpage\input{InjectTimeSeriesC}
	</lalLaTeX> */
	void		void
	LALSI2InjectTimeSeries( LALStatus *,		LALSI2InjectTimeSeries( LALStatus *,
	INT2TimeSeries *output,		INT2TimeSeries *output,
	REAL4TimeSeries *signalvec,		REAL4TimeSeries *signalvec,
	RandomParams *params );		RandomParams *params );
	void		void
	LALSSInjectTimeSeries( LALStatus *,		LALSSInjectTimeSeries( LALStatus *,
	REAL4TimeSeries *output,		REAL4TimeSeries *output,
	REAL4TimeSeries *signalvec );		REAL4TimeSeries *signalvec );
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _INJECT_H */		#endif /* _INJECT_H */
End of changes. 19 change blocks.
	69 lines changed or deleted		56 lines changed or added

	Integrate.h		Integrate.h
	/*		/*
	* Copyright (C) 2007 Jolien Creighton		* Copyright (C) 2007 Jolien Creighton, Drew Keppel
	*		*
	* This program is free software; you can redistribute it and/or modify		* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by		* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or		* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.		* (at your option) any later version.
	*		*
	* This program is distributed in the hope that it will be useful,		* This program is distributed in the hope that it will be useful,
	* 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.
	skipping to change at line 47		skipping to change at line 47
	\noindent This header covers the routines for integrating a function.		\noindent This header covers the routines for integrating a function.
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	#ifndef _INTEGRATE_H		#ifndef _INTEGRATE_H
	#define _INTEGRATE_H		#define _INTEGRATE_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (INTEGRATEH, "$Id$");		NRCSID (INTEGRATEH, "$Id$");
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	skipping to change at line 175		skipping to change at line 180
	SingularLowerLimit, /* integrate an inv sqrt singularity at lower limit */		SingularLowerLimit, /* integrate an inv sqrt singularity at lower limit */
	SingularUpperLimit, /* integrate an inv sqrt singularity at upper limit */		SingularUpperLimit, /* integrate an inv sqrt singularity at upper limit */
	InfiniteDomainPow, /* integrate infinite domain with power-law falloff */		InfiniteDomainPow, /* integrate infinite domain with power-law falloff */
	InfiniteDomainExp /* integrate infinite domain with exponential falloff */		InfiniteDomainExp /* integrate infinite domain with exponential falloff */
	}		}
	IntegralType;		IntegralType;
	typedef struct		typedef struct
	tagSIntegrateIn		tagSIntegrateIn
	{		{
			SWIGLAL_STRUCT(SIntegrateIn);
	void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);		void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);
	REAL4 xmax;		REAL4 xmax;
	REAL4 xmin;		REAL4 xmin;
	IntegralType type;		IntegralType type;
	}		}
	SIntegrateIn;		SIntegrateIn;
	typedef struct		typedef struct
	tagDIntegrateIn		tagDIntegrateIn
	{		{
			SWIGLAL_STRUCT(DIntegrateIn);
	void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);		void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);
	REAL8 xmax;		REAL8 xmax;
	REAL8 xmin;		REAL8 xmin;
	IntegralType type;		IntegralType type;
	}		}
	DIntegrateIn;		DIntegrateIn;
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	<lalLaTeX>		<lalLaTeX>
	skipping to change at line 216		skipping to change at line 223
	);		);
	void		void
	LALDRombergIntegrate (		LALDRombergIntegrate (
	LALStatus *status,		LALStatus *status,
	REAL8 *result,		REAL8 *result,
	DIntegrateIn *input,		DIntegrateIn *input,
	void *params		void *params
	);		);
			REAL8
			XLALREAL8RombergIntegrate (
			REAL8 (*f)(REAL8 x, void *params),
			void *params,
			REAL8 xmin,
			REAL8 xmax,
			IntegralType type
			);
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	<lalLaTeX>		<lalLaTeX>
	\newpage\input{IntegrateTestC}		\newpage\input{IntegrateTestC}
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
End of changes. 5 change blocks.
	1 lines changed or deleted		17 lines changed or added

	Interpolate.h		Interpolate.h
	/*		/*
	* Copyright (C) 2007 Jolien Creighton		* Copyright (C) 2007 Jolien Creighton, Drew Keppel
	*		*
	* This program is free software; you can redistribute it and/or modify		* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by		* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or		* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.		* (at your option) any later version.
	*		*
	* This program is distributed in the hope that it will be useful,		* This program is distributed in the hope that it will be useful,
	* 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.
	skipping to change at line 47		skipping to change at line 47
	\noindent This header covers the routines for interpolation.		\noindent This header covers the routines for interpolation.
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	#ifndef _INTERPOLATE_H		#ifndef _INTERPOLATE_H
	#define _INTERPOLATE_H		#define _INTERPOLATE_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (INTERPOLATEH, "$Id: Interpolate.h");		NRCSID (INTERPOLATEH, "$Id: Interpolate.h");
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	skipping to change at line 143		skipping to change at line 148
	\item[\texttt{y}] The array of values to interpolate.		\item[\texttt{y}] The array of values to interpolate.
	\end{description}		\end{description}
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	typedef struct		typedef struct
	tagSInterpolateOut		tagSInterpolateOut
	{		{
			SWIGLAL_STRUCT(SInterpolateOut);
	REAL4 y;		REAL4 y;
	REAL4 dy;		REAL4 dy;
	}		}
	SInterpolateOut;		SInterpolateOut;
	typedef struct		typedef struct
	tagDInterpolateOut		tagDInterpolateOut
	{		{
			SWIGLAL_STRUCT(DInterpolateOut);
	REAL8 y;		REAL8 y;
	REAL8 dy;		REAL8 dy;
	}		}
	DInterpolateOut;		DInterpolateOut;
	typedef struct		typedef struct
	tagSInterpolatePar		tagSInterpolatePar
	{		{
			SWIGLAL_STRUCT(SInterpolatePar);
	UINT4 n;		UINT4 n;
	REAL4 *x;		REAL4 *x;
	REAL4 *y;		REAL4 *y;
	}		}
	SInterpolatePar;		SInterpolatePar;
	typedef struct		typedef struct
	tagDInterpolatePar		tagDInterpolatePar
	{		{
			SWIGLAL_STRUCT(DInterpolatePar);
	UINT4 n;		UINT4 n;
	REAL8 *x;		REAL8 *x;
	REAL8 *y;		REAL8 *y;
	}		}
	DInterpolatePar;		DInterpolatePar;
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	<lalLaTeX>		<lalLaTeX>
	\newpage\input{InterpolateC}		\newpage\input{InterpolateC}
	skipping to change at line 198		skipping to change at line 207
	);		);
	void		void
	LALDPolynomialInterpolation (		LALDPolynomialInterpolation (
	LALStatus *status,		LALStatus *status,
	DInterpolateOut *output,		DInterpolateOut *output,
	REAL8 target,		REAL8 target,
	DInterpolatePar *params		DInterpolatePar *params
	);		);
			REAL8
			XLALREAL8PolynomialInterpolation (
			REAL8 *yout,
			REAL8 xtarget,
			REAL8 *y,
			REAL8 *x,
			UINT4 n
			);
	#if 0 /* autodoc block */		#if 0 /* autodoc block */
	<lalLaTeX>		<lalLaTeX>
	\newpage\input{InterpolateTestC}		\newpage\input{InterpolateTestC}
	</lalLaTeX>		</lalLaTeX>
	#endif /* autodoc block */		#endif /* autodoc block */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
End of changes. 7 change blocks.
	1 lines changed or deleted		19 lines changed or added

	LALAtomicDatatypes.h		LALAtomicDatatypes.h
	skipping to change at line 284		skipping to change at line 284
	This structure stores a double-precision complex number in 16~bytes of		This structure stores a double-precision complex number in 16~bytes of
	memory. The fields are:		memory. The fields are:
	\begin{description}		\begin{description}
	\item[\texttt{REAL8 re}] The real part.		\item[\texttt{REAL8 re}] The real part.
	\item[\texttt{REAL8 im}] The imaginary part.		\item[\texttt{REAL8 im}] The imaginary part.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	/** Single-precision floating-point complex number (8 bytes total) */		/** Single-precision floating-point complex number (8 bytes total) */
			#ifndef SWIG /* exclude from SWIG interface */
	typedef struct		typedef struct
	tagCOMPLEX8		tagCOMPLEX8
	{		{
	REAL4 re; /**< The real part. */		REAL4 re; /**< The real part. */
	REAL4 im; /**< The imaginary part. */		REAL4 im; /**< The imaginary part. */
	}		}
	COMPLEX8;		COMPLEX8;
			#endif /* SWIG */
	/** Double-precision floating-point complex number (16 bytes total) */		/** Double-precision floating-point complex number (16 bytes total) */
			#ifndef SWIG /* exclude from SWIG interface */
	typedef struct		typedef struct
	tagCOMPLEX16		tagCOMPLEX16
	{		{
	REAL8 re; /**< The real part. */		REAL8 re; /**< The real part. */
	REAL8 im; /**< The imaginary part. */		REAL8 im; /**< The imaginary part. */
	}		}
	COMPLEX16;		COMPLEX16;
			#endif /* SWIG */
	/* <lalLaTeX>		/* <lalLaTeX>
	\vfill{\footnotesize\input{LALAtomicDatatypesHV}}		\vfill{\footnotesize\input{LALAtomicDatatypesHV}}
	</lalLaTeX> */		</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALATOMICDATATYPES_H */		#endif /* _LALATOMICDATATYPES_H */
End of changes. 4 change blocks.
	0 lines changed or deleted		4 lines changed or added

	LALBarycenter.h		LALBarycenter.h
	skipping to change at line 23		skipping to change at line 23
	*		*
	* 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 _LALBARYCENTER_H /* Protect against double-inclusion */		#ifndef _LALBARYCENTER_H /* Protect against double-inclusion */
	#define _LALBARYCENTER_H		#define _LALBARYCENTER_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <stdio.h>		#include <stdio.h>
	#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
	skipping to change at line 44		skipping to change at line 49
	/** \cond DONT_DOXYGEN */		/** \cond DONT_DOXYGEN */
	NRCSID (LALBARYCENTERH,"$Id$");		NRCSID (LALBARYCENTERH,"$Id$");
	/** \endcond */		/** \endcond */
	/** \name Error codes */		/** \name Error codes */
	/*@{*/ /** \ingroup Barycenter_h */		/*@{*/ /** \ingroup Barycenter_h */
	#define LALBARYCENTERH_ENULL 2		#define LALBARYCENTERH_ENULL 2
	#define LALBARYCENTERH_EOUTOFRANGEE 4		#define LALBARYCENTERH_EOUTOFRANGEE 4
	#define LALBARYCENTERH_EOUTOFRANGES 8		#define LALBARYCENTERH_EOUTOFRANGES 8
	#define LALBARYCENTERH_EBADSOURCEPOS 16		#define LALBARYCENTERH_EBADSOURCEPOS 16
			#define LALBARYCENTERH_EXLAL 32
	#define LALBARYCENTERH_MSGENULL "Null input to Barycenter routine."		#define LALBARYCENTERH_MSGENULL "Null input to Barycenter routine."
	#define LALBARYCENTERH_MSGEOUTOFRANGEE "tgps not in range of earth.dat fil e"		#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_MSGEOUTOFRANGES "tgps not in range of sun.dat file"
	#define LALBARYCENTERH_MSGEBADSOURCEPOS "source position not in standard ra nge"		#define LALBARYCENTERH_MSGEBADSOURCEPOS "source position not in standard ra nge"
			#define LALBARYCENTERH_MSGEXLAL "XLAL function failed."
	/*@}*/		/*@}*/
	/**		/**
	* \defgroup LALBarycenter_h Barycentering		* \defgroup LALBarycenter_h Barycentering
	* \author Curt Cutler		* \author Curt Cutler
	* \date 2001		* \date 2001
	* \ingroup pulsarCommon		* \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.
	*		*
	skipping to change at line 85		skipping to change at line 92
	* (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
	* Earth's position \f$(x,y,z)\f$,		* Earth's position \f$(x,y,z)\f$,
	* velocity \f$(v_x, v_y, v_z)\f$, and acceleration \f$(a_x, a_y, a_z)\f$		* velocity \f$(v_x, v_y, v_z)\f$, and acceleration \f$(a_x, a_y, a_z)\f$
	* at that instant. All in units of seconds; e.g. positions have		* at that instant. All in units of seconds; e.g. positions have
	* units of seconds, and accelerations have units 1/sec.		* units of seconds, and accelerations have units 1/sec.
	*		*
	* \deprecated Use XLALInitBarycenter() instead.		* \deprecated Use XLALInitBarycenter() instead.
	*/		*/
	typedef struct		typedef struct tagEphemerisFilenames
	{		{
			SWIGLAL_STRUCT(EphemerisFilenames);
	CHAR *earthEphemeris; /**< File containing Earth's position. */		CHAR *earthEphemeris; /**< File containing Earth's position. */
	CHAR *sunEphemeris; /**< File containing Sun's position. */		CHAR *sunEphemeris; /**< File containing Sun's position. */
	}		}
	EphemerisFilenames;		EphemerisFilenames;
	/** Structure holding a REAL8 time, and a position, velocity and		/** Structure holding a REAL8 time, and a position, velocity and
	* acceleration vector. */		* acceleration vector. */
	typedef struct		typedef struct tagPosVelAcc
	{		{
			SWIGLAL_STRUCT(PosVelAcc);
	REAL8 gps; /**< REAL8 timestamp */		REAL8 gps; /**< REAL8 timestamp */
	REAL8 pos[3]; /**< position-vector */		REAL8 pos[3]; /**< position-vector */
	REAL8 vel[3]; /**< velocity-vector */		REAL8 vel[3]; /**< velocity-vector */
	REAL8 acc[3]; /**< acceleration-vector */		REAL8 acc[3]; /**< acceleration-vector */
	}		}
	PosVelAcc;		PosVelAcc;
	/** This structure contains all information about the		/** This structure contains all information about the
	* center-of-mass positions of the Earth and Sun, listed at regular		* center-of-mass positions of the Earth and Sun, listed at regular
	* time intervals.		* time intervals.
	*/		*/
	typedef struct		typedef struct tagEphemerisData
	{		{
			SWIGLAL_STRUCT(EphemerisData);
	EphemerisFilenames ephiles; /**< Names of the two files containing positi ons of		EphemerisFilenames ephiles; /**< Names of the two files containing positi ons of
	* Earth and Sun, respectively at evenly spac ed times. */		* Earth and Sun, respectively at evenly spac ed times. */
	INT4 nentriesE; /**< The number of entries in Earth ephemeris table . */		INT4 nentriesE; /**< The number of entries in Earth ephemeris table . */
	INT4 nentriesS; /**< The number of entries in Sun ephemeris table. */		INT4 nentriesS; /**< The number of entries in Sun ephemeris table. */
	REAL8 dtEtable; /**< The spacing in sec between consecutive intants in Earth ephemeris table.*/		REAL8 dtEtable; /**< The spacing in sec between consecutive intants in Earth ephemeris table.*/
	REAL8 dtStable; /**< The spacing in sec between consecutive intants in Sun ephemeris table.*/		REAL8 dtStable; /**< The spacing in sec between consecutive intants in Sun ephemeris table.*/
	PosVelAcc *ephemE; /**< Array containing pos,vel,acc of earth, as extr acted from earth		PosVelAcc *ephemE; /**< Array containing pos,vel,acc of earth, as extr acted from earth
	* ephem file. Units are sec, 1, 1/sec respectively */		* ephem file. Units are sec, 1, 1/sec respectively */
	PosVelAcc *ephemS; /**< Array with pos, vel and acc for the sun (see e phemE) */		PosVelAcc *ephemS; /**< Array with pos, vel and acc for the sun (see e phemE) */
	}		}
	EphemerisData;		EphemerisData;
	/** Basic output structure of LALBarycenterEarth.c.		/** Basic output structure of LALBarycenterEarth.c.
	*/		*/
	typedef struct		typedef struct tagEarthState
	{		{
			SWIGLAL_STRUCT(EarthState);
	REAL8 einstein; /**< the einstein delay equiv TDB - TDT */		REAL8 einstein; /**< the einstein delay equiv TDB - TDT */
	REAL8 deinstein; /**< d(einstein)/d(tgps) */		REAL8 deinstein; /**< d(einstein)/d(tgps) */
	REAL8 posNow[3]; /**< Cartesian coords of Earth's center at tgps,		REAL8 posNow[3]; /**< Cartesian coords of Earth's center at tgps,
	* extrapolated from JPL DE405 ephemeris; units= se c */		* extrapolated from JPL DE405 ephemeris; units= se c */
	REAL8 velNow[3]; /**< dimensionless velocity of Earth's center at tg ps,		REAL8 velNow[3]; /**< dimensionless velocity of Earth's center at tg ps,
	* extrapolated from JPL DE405 ephemeris */		* extrapolated from JPL DE405 ephemeris */
	REAL8 gmstRad; /**< Greenwich Mean Sidereal Time (GMST) in radians , at tgps */		REAL8 gmstRad; /**< Greenwich Mean Sidereal Time (GMST) in radians , at tgps */
	REAL8 gastRad; /**< Greenwich Apparent Sidereal Time, in radians, at tgps;		REAL8 gastRad; /**< Greenwich Apparent Sidereal Time, in radians, at tgps;
	skipping to change at line 155		skipping to change at line 166
	REAL8 se[3]; /**< vector that points from Sun to Earth at instan t tgps,		REAL8 se[3]; /**< vector that points from Sun to Earth at instan t tgps,
	* in DE405 coords; units = sec */		* in DE405 coords; units = sec */
	REAL8 dse[3]; /**< d(se[3])/d(tgps); Dimensionless */		REAL8 dse[3]; /**< d(se[3])/d(tgps); Dimensionless */
	REAL8 rse; /**< length of vector se[3]; units = sec */		REAL8 rse; /**< length of vector se[3]; units = sec */
	REAL8 drse; /**< d(rse)/d(tgps); dimensionless */		REAL8 drse; /**< d(rse)/d(tgps); dimensionless */
	}		}
	EarthState;		EarthState;
	/** Basic input structure to LALBarycenter.c.		/** Basic input structure to LALBarycenter.c.
	*/		*/
	typedef struct		typedef struct tagBarycenterInput
	{		{
			SWIGLAL_STRUCT(BarycenterInput);
	LIGOTimeGPS tgps; /**< input GPS arrival time. I use tgps (lower case )		LIGOTimeGPS tgps; /**< input GPS arrival time. I use tgps (lower case )
	* to remind that here the LAL structure is a		* to remind that here the LAL structure is a
	* field in the larger structure BarycenterInput.		* field in the larger structure BarycenterInput.
	* I use tGPS as an input structure (by itself) to		* I use tGPS as an input structure (by itself) to
	* LALBarycenterEarth */		* LALBarycenterEarth */
	LALDetector site; /**< detector site info. <b>NOTE:</b>		LALDetector site; /**< detector site info. <b>NOTE:</b>
	* the <tt>site.location</tt> field must be modifie d		* the <tt>site.location</tt> field must be modifie d
	* to give the detector location in units of		* to give the detector location in units of
	* <em>seconds</em> (i.e. divide the values normall y		* <em>seconds</em> (i.e. divide the values normall y
	skipping to change at line 180		skipping to change at line 192
	REAL8 delta; /**< Source declination in ICRS J2000 coords (radia ns) */		REAL8 delta; /**< Source declination in ICRS J2000 coords (radia ns) */
	REAL8 dInv; /**< 1/(distance to source), in 1/sec.		REAL8 dInv; /**< 1/(distance to source), in 1/sec.
	* This is needed to correct Roemer delay for very		* This is needed to correct Roemer delay for very
	* nearby sources; correction is about 10 microsec for		* nearby sources; correction is about 10 microsec for
	* source at 100 pc */		* source at 100 pc */
	}		}
	BarycenterInput;		BarycenterInput;
	/** Basic output structure produced by LALBarycenter.c.		/** Basic output structure produced by LALBarycenter.c.
	*/		*/
	typedef struct		typedef struct tagEmissionTime
	{		{
			SWIGLAL_STRUCT(EmissionTime);
	REAL8 deltaT; /**< \f$t_e\f$(TDB) - \f$t_a\f$(GPS)		REAL8 deltaT; /**< \f$t_e\f$(TDB) - \f$t_a\f$(GPS)
	* + (light-travel-time from source to SSB) */		* + (light-travel-time from source to SSB) */
	LIGOTimeGPS te; /**< pulse emission time (TDB); also sometimes call ed		LIGOTimeGPS te; /**< pulse emission time (TDB); also sometimes call ed
	* ``arrival time (TDB) of same wavefront at SSB'' */		* ``arrival time (TDB) of same wavefront at SSB'' */
	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. */
	skipping to change at line 209		skipping to change at line 222
	/*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. */
	void LALBarycenterEarth(LALStatus *, EarthState *, const LIGOTimeGPS *, con		int XLALBarycenterEarth ( EarthState *earth, const LIGOTimeGPS *tGPS, const
	st EphemerisData *);		EphemerisData *edat);
			int XLALBarycenter ( EmissionTime *emit, const BarycenterInput *baryinput,
			const EarthState *earth);
	void LALBarycenter(LALStatus *, EmissionTime *, const BarycenterInput *, co		void LALBarycenterEarth ( LALStatus *status, EarthState *earth, const LIGOT
	nst EarthState *);		imeGPS *tGPS, const EphemerisData *edat);
			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. 17 change blocks.
	10 lines changed or deleted		27 lines changed or added

	LALCache.h		LALCache.h
	skipping to change at line 31		skipping to change at line 31
	* \ingroup support		* \ingroup support
	* \author Creighton, J. D. E.		* \author Creighton, J. D. E.
	* \date 2007		* \date 2007
	* \brief This header covers routines to create and manipulate LALCache		* \brief This header covers routines to create and manipulate LALCache
	* structures and to read LAL cache files.		* structures and to read LAL cache files.
	*		*
	*/		*/
	#ifndef _LALCACHE_H_		#ifndef _LALCACHE_H_
	#define _LALCACHE_H_		#define _LALCACHE_H_
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	#include <stdio.h>		#include <stdio.h>
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/FileIO.h>		#include <lal/FileIO.h>
	NRCSID( LALCACHEH, "$Id$" );		NRCSID( LALCACHEH, "$Id$" );
	/** An entry in a LAL cache */		/** An entry in a LAL cache */
	typedef struct tagLALCacheEntry {		typedef struct tagLALCacheEntry {
	CHAR *src; /**< File source field */		SWIGLAL_STRUCT(LALCacheEntry);
	CHAR *dsc; /**< File description field */		CHAR *src; /**< File source field */
	INT4 t0; /**< GPS time (seconds) of beginning of data in f		CHAR *dsc; /**< File description field */
	ile */		INT4 t0; /**< GPS time (seconds) of beginning of data in file */
	INT4 dt; /**< Duration (seconds) of data in file */		INT4 dt; /**< Duration (seconds) of data in file */
	CHAR *url; /**< URL of file */		CHAR *url; /**< URL of file */
	} LALCacheEntry;		} LALCacheEntry;
	/** The LALCache structure is an array of entries */		/** The LALCache structure is an array of entries */
	typedef struct tagLALCache { UINT4 length; LALCacheEntry *list; } LALCache;		typedef struct tagLALCache {
			SWIGLAL_STRUCT(LALCache);
			UINT4 length;
			LALCacheEntry *list;
			} LALCache;
	/** Creates a LALCache structure */		/** Creates a LALCache structure */
	LALCache * XLALCreateCache( UINT4 length );		LALCache * XLALCreateCache( UINT4 length );
	/** Destroys a LALCache structure */		/** Destroys a LALCache structure */
	void XLALDestroyCache( LALCache *cache );		void XLALDestroyCache( LALCache *cache );
	/** Duplicates a LALCache structure */		/** Duplicates a LALCache structure */
	LALCache * XLALCacheDuplicate( LALCache *cache );		LALCache * XLALCacheDuplicate( LALCache *cache );
	/** Returns a new LALCache structure that is the merge of two */		/** Returns a new LALCache structure that is the merge of two */
	LALCache * XLALCacheMerge( LALCache *cache1, LALCache *cache2 );		LALCache * XLALCacheMerge( LALCache *cache1, LALCache *cache2 );
	/** Reads a LAL cache file and produces a LALCache structure */		/** Reads a LAL cache file and produces a LALCache structure */
	LALCache * XLALCacheFileRead( LALFILE *fp );		LALCache * XLALCacheFileRead( LALFILE *fp );
	/** Globs a directory and construct LALCache from matching entries */		/** Globs a directory and construct LALCache from matching entries */
	LALCache * XLALCacheGlob(		LALCache * XLALCacheGlob(
	const char *dirstr, /**< colon-delimited list of directories		const char *dirstr, /**< colon-delimited list of directorie
	*/		s */
	const char *fnptrn /**< glob pattern for matching files */		const char *fnptrn /**< glob pattern for matching files */
	);		);
	/** Writes a LALCache structure to an output LAL cache file */		/** Writes a LALCache structure to an output LAL cache file */
	int XLALCacheFileWrite( LALFILE *fp, LALCache *cache );		int XLALCacheFileWrite( LALFILE *fp, LALCache *cache );
	/** Sorts entries in a LALCache structure */		/** Sorts entries in a LALCache structure */
	int XLALCacheSort( LALCache *cache );		int XLALCacheSort( LALCache *cache );
	/** Prunes duplicate entries keeping the second one; cache is reduced in		/** Prunes duplicate entries keeping the second one; cache is reduced in
	* length if there are. Entries are duplicates if their metadata are		* length if there are. Entries are duplicates if their metadata are
	* the same (even if the urls are different */		* the same (even if the urls are different */
	int XLALCacheUniq( LALCache *cache );		int XLALCacheUniq( LALCache *cache );
	/** Selects only matching entries in a LALCache structure -- other entries		/** Selects only matching entries in a LALCache structure -- other entries
	* are deleted from the LALCache structure */		* are deleted from the LALCache structure */
	int XLALCacheSieve(		int XLALCacheSieve(
	LALCache *cache, /**< The LALCache structure - modified */		LALCache *cache, /**< The LALCache structure - modified */
	INT4 t0, /**< Remove entries ending before t0 (0 to disable)		INT4 t0, /**< Remove entries ending before t0 (0 to disable
	*/		) */
	INT4 t1, /**< Remove entries ending after t1 (0 to disable)		INT4 t1, /**< Remove entries ending after t1 (0 to disable)
	*/		*/
	const char *srcregex, /**< Regular expression to match src f		const char *srcregex, /**< Regular expression to match src
	ield (NULL to disable) */		field (NULL to disable) */
	const char *dscregex, /**< Regular expression to match dsc f		const char *dscregex, /**< Regular expression to match dsc
	ield (NULL to disable) */		field (NULL to disable) */
	const char *urlregex /**< Regular expression to match url fi		const char *urlregex /**< Regular expression to match url f
	eld (NULL to disable) */		ield (NULL to disable) */
	);		);
	/** Open a file identified by an entry in a LALCache structure */		/** Open a file identified by an entry in a LALCache structure */
	LALFILE * XLALCacheEntryOpen( LALCacheEntry *entry );		LALFILE * XLALCacheEntryOpen( LALCacheEntry *entry );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALCACHE_H_ */		#endif /* _LALCACHE_H_ */
End of changes. 5 change blocks.
	23 lines changed or deleted		32 lines changed or added

	LALCalibration.h		LALCalibration.h
	skipping to change at line 23		skipping to change at line 23
	*		*
	* 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 _LALCALIBRATION_H		#ifndef _LALCALIBRATION_H
	#define _LALCALIBRATION_H		#define _LALCALIBRATION_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	NRCSID( LALCALIBRATIONH, "$Id$" );		NRCSID( LALCALIBRATIONH, "$Id$" );
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	/** 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);
	REAL4TimeSeries *cavityFactors;		REAL4TimeSeries *cavityFactors;
	REAL4TimeSeries *openLoopFactors;		REAL4TimeSeries *openLoopFactors;
	COMPLEX8FrequencySeries *responseReference;		COMPLEX8FrequencySeries *responseReference;
	COMPLEX8FrequencySeries *cavityGainReference;		COMPLEX8FrequencySeries *cavityGainReference;
	COMPLEX8FrequencySeries *openLoopGainReference;		COMPLEX8FrequencySeries *openLoopGainReference;
	COMPLEX8FrequencySeries *actuationReference;		COMPLEX8FrequencySeries *actuationReference;
	COMPLEX8FrequencySeries *digitalFilterReference;		COMPLEX8FrequencySeries *digitalFilterReference;
	}		}
	LALCalData;		LALCalData;
End of changes. 2 change blocks.
	0 lines changed or deleted		6 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 */
	/* $Id$ */		/* $Id$ */
	#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.5.0"		#define LAL_VERSION "6.6.0"
	/* 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 5		#define LAL_VERSION_MINOR 6
	/* LAL Version Micro Number */		/* LAL Version Micro Number */
	#define LAL_VERSION_MICRO 0		#define LAL_VERSION_MICRO 0
	/* 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.5.0' '--exec-prefix=/home/andrey/upstream-tracker /testing/lal/6.5.0' '--sysconfdir=/home/andrey/upstream-tracker/testing/lal /6.5.0' '--datadir=/home/andrey/upstream-tracker/testing/lal/6.5.0' 'CFLAGS =-w -fpermissive' 'CXXFLAGS=-w -fpermissive'"		#define LAL_CONFIGURE_ARGS " '--enable-shared' '--prefix=/home/andrey/upstr eam-tracker/testing/lal/6.6.0' '--exec-prefix=/home/andrey/upstream-tracker /testing/lal/6.6.0' '--sysconfdir=/home/andrey/upstream-tracker/testing/lal /6.6.0' '--datadir=/home/andrey/upstream-tracker/testing/lal/6.6.0' 'CFLAGS =-w -fpermissive' 'CXXFLAGS=-w -fpermissive'"
	/* LAL Configure Date */		/* LAL Configure Date */
	#define LAL_CONFIGURE_DATE "2012-05-12T12:13:58+0400"		#define LAL_CONFIGURE_DATE "2012-05-12T12:12:07+0400"
	/* LAL Install Prefix */		/* LAL Install Prefix */
	#define LAL_PREFIX "/opt/lscsoft/lal"		#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 */
	/* Use pthread mutex lock for threadsafety */		/* Use pthread mutex lock for threadsafety */
	/* #undef LAL_PTHREAD_LOCK */		/* #undef LAL_PTHREAD_LOCK */
End of changes. 5 change blocks.
	5 lines changed or deleted		5 lines changed or added

	LALCorrelation.h		LALCorrelation.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
	*/		*/
	/********************************* <lalVerbatim file="LALCorrelationHV">
	Author: Yakushin, Igor
	$Id$
	********************************** </lalVerbatim> */
	/********************************* <lalLaTeX>
	\section{Header \texttt{LALCorrelation.h}}
	[One sentence briefly defining scope of the header]
	\subsection*{Synopsis}
	\begin{verbatim}
	#include <lal/LALCorrelation.h>
	\end{verbatim}
	[Generic documentation on the header; this is the main place to
	document any stuff not specific to the module]
	\subsection*{Error conditions}
	\input{LALCorrelationHE}
	\subsection*{Structures}
	[Document here any structures defined in the header.
	Also include any of them in the index; e.g.:]
	% \index{\texttt{LALCorrelationOutput}}
	% \index{\texttt{LALCorrelationInput}}
	% \index{\texttt{LALCorrelationParams}}
	\vfill{\footnotesize\input{LALCorrelationHV}}
	\newpage\input{LALCorrelationC}
	\newpage\input{LALCorrelationTestC}
	********************************** </lalLaTeX> */
	#ifndef _LALCORRELATION_H		#ifndef _LALCORRELATION_H
	#define _LALCORRELATION_H		#define _LALCORRELATION_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#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
	NRCSID (LALCORRELATIONH, "$Id$");		NRCSID (LALCORRELATIONH, "$Id$");
	/******************************** <lalErrTable file="LALCorrelationHE"> */		/**
			\author Yakushin, Igor
			\addtogroup LALCorrelation_h
	#define LALCORRELATIONH_ENULLP 1		\brief [One sentence briefly defining scope of the header]
	#define LALCORRELATIONH_ESTART 2
	#define LALCORRELATIONH_ESAMPLING 3
			\heading{Synopsis}
			\code
			#include <lal/LALCorrelation.h>
			\endcode
			[Generic documentation on the header; this is the main place to
			document any stuff not specific to the module]
			*/
			/** @{ */
			/**\name Error Codes */ /*@{*/
			#define LALCORRELATIONH_ENULLP 1 /**< Null pointer */
			#define LALCORRELATIONH_ESTART 2 /**< Time series do
			not start simultaneously */
			#define LALCORRELATIONH_ESAMPLING 3 /**< Time series are
			not sampled with the same rate */
			/*@}*/
			/** \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 */
	/* *********************************** </lalErrTable> */		/* ***** DEFINE OTHER GLOBAL CONSTANTS OR MACROS ************/
	/****** DEFINE OTHER GLOBAL CONSTANTS OR MACROS ************/
	/****** DEFINE NEW STRUCTURES AND TYPES ************/		/* ***** DEFINE NEW STRUCTURES AND TYPES ************/
	typedef struct		typedef struct
	tagCorrelationParams		tagCorrelationParams
	{		{
			SWIGLAL_STRUCT(CorrelationParams);
	REAL4 maxTimeShiftNan;		REAL4 maxTimeShiftNan;
	}		}
	CorrelationParams;		CorrelationParams;
	typedef struct		typedef struct
	tagInputCorrelation		tagInputCorrelation
	{		{
			SWIGLAL_STRUCT(InputCorrelation);
	REAL4TimeSeries *one;		REAL4TimeSeries *one;
	REAL4TimeSeries *two;		REAL4TimeSeries *two;
	}		}
	InputCorrelation;		InputCorrelation;
			/** OutputCorrelation structure */
	typedef struct		typedef struct
	tagOutputCorrelation		tagOutputCorrelation
	{		{
	REAL4 *timeShiftedCorrelation; /* cor(x(t-T),y(t)) or cor(x(t),y(t-T)) as		SWIGLAL_STRUCT(OutputCorrelation);
	a function of T*/		REAL4 *timeShiftedCorrelation; /**< cor(x(t-T),y(t)) or cor(x(t),y(t-T))
			as a function of T*/
	INT4 maxCorrelationTimeShift; /* time step (from shift=0) at which corre		INT4 maxCorrelationTimeShift; /**< time step (from shift=0) at which cor
	lation is maximum */		relation is maximum */
	REAL4 maxCorrelationValue; /* maximum value of the correlation for th		REAL4 maxCorrelationValue; /**< maximum value of the correlation for
	e range of shifts */		the range of shifts */
	INT4 minCorrelationTimeShift;		INT4 minCorrelationTimeShift; /**< UNDOCUMENTED */
	REAL4 minCorrelationValue;		REAL4 minCorrelationValue; /**< UNDOCUMENTED */
	LIGOTimeGPS start; /* start time for the time series under consideration		LIGOTimeGPS start; /**< start time for the time series under co
	*/		nsideration */
	INT4 length; /* number of time steps in the time series */		INT4 length; /**< number of time steps in the tim
	REAL8 deltaT; /* time separation in seconds between different time steps		e series */
	*/		REAL8 deltaT; /**< time separation in seconds between diff
			erent time steps */
	INT4 shift; /* max time step shift between time series */		INT4 shift; /**< max time step shift between time series */
	}		}
	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. 19 change blocks.
	60 lines changed or deleted		55 lines changed or added

	LALDatatypes.h		LALDatatypes.h
	skipping to change at line 72		skipping to change at line 72
	This header file is automatically included by the header		This header file is automatically included by the header
	\verb@LALStdlib.h@. In turn, this header file starts by including the		\verb@LALStdlib.h@. In turn, this header file starts by including the
	header \verb@LALAtomicDatatypes.h@, which is discussed in the		header \verb@LALAtomicDatatypes.h@, which is discussed in the
	following section.		following section.
	</lalLaTeX> */		</lalLaTeX> */
	#ifndef _LALDATATYPES_H		#ifndef _LALDATATYPES_H
	#define _LALDATATYPES_H		#define _LALDATATYPES_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
			#if !defined(SWIG) && !defined(SWIGLAL_DYNAMIC_1DARRAY)
			#define SWIGLAL_DYNAMIC_1DARRAY(...)
			#endif
			#if !defined(SWIG) && !defined(SWIGLAL_DYNAMIC_2DARRAY)
			#define SWIGLAL_DYNAMIC_2DARRAY(...)
			#endif
	/* <lalLaTeX>		/* <lalLaTeX>
	\newpage\input{LALAtomicDatatypesH}		\newpage\input{LALAtomicDatatypesH}
	</lalLaTeX> */		</lalLaTeX> */
	#include <lal/LALAtomicDatatypes.h>		#include <lal/LALAtomicDatatypes.h>
	/**** <lalLaTeX>		/**** <lalLaTeX>
	* \newpage		* \newpage
	* \subsection{Atomic datatypes codes}		* \subsection{Atomic datatypes codes}
	* \label{ss:atomic-datatype-codes}		* \label{ss:atomic-datatype-codes}
	* \idx[Constant]{LAL\_1\_BYTE\_TYPE\_SIZE}		* \idx[Constant]{LAL\_1\_BYTE\_TYPE\_SIZE}
	skipping to change at line 327		skipping to change at line 338
	* n_{m-3}\times(\cdots(i_1 + n_0\times i_0)\cdots))\mathtt{]}\f$; that is,		* n_{m-3}\times(\cdots(i_1 + n_0\times i_0)\cdots))\mathtt{]}\f$; that is,
	* the index of \c data[] runs over the internal indecies of each		* the index of \c data[] runs over the internal indecies of each
	* array element before incrementing to the next array element.		* array element before incrementing to the next array element.
	*		*
	*/		*/
	/*@{*/		/*@{*/
	/** Vector of type CHAR. */		/** Vector of type CHAR. */
	typedef struct		typedef struct
	tagCHARVector		tagCHARVector
	{		{
			SWIGLAL_STRUCT(CHARVector);
			SWIGLAL_DYNAMIC_1DARRAY(CHAR, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	CHAR *data; /**< Pointer to the data array. */		CHAR *data; /**< Pointer to the data array. */
	}		}
	CHARVector;		CHARVector;
	/** Vector of type CHAR*, ie 'strings' */		/** Vector of type CHAR*, ie 'strings' */
	typedef struct {		typedef struct tagLALStringVector {
			SWIGLAL_STRUCT(LALStringVector);
			SWIGLAL_DYNAMIC_1DARRAY(CHAR*, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	CHAR **data; /**< Pointer to the data array. */		CHAR **data; /**< Pointer to the data array. */
	} LALStringVector;		} LALStringVector;
	/** Vector of type INT2. */		/** Vector of type INT2. */
	typedef struct		typedef struct
	tagINT2Vector		tagINT2Vector
	{		{
			SWIGLAL_STRUCT(INT2Vector);
			SWIGLAL_DYNAMIC_1DARRAY(INT2, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	INT2 *data; /**< Pointer to the data array. */		INT2 *data; /**< Pointer to the data array. */
	}		}
	INT2Vector;		INT2Vector;
	/** Vector of type UINT2. */		/** Vector of type UINT2. */
	typedef struct		typedef struct
	tagUINT2Vector		tagUINT2Vector
	{		{
			SWIGLAL_STRUCT(UINT2Vector);
			SWIGLAL_DYNAMIC_1DARRAY(UINT2, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	UINT2 *data; /**< Pointer to the data array. */		UINT2 *data; /**< Pointer to the data array. */
	}		}
	UINT2Vector;		UINT2Vector;
	/** Vector of type INT4. */		/** Vector of type INT4. */
	typedef struct		typedef struct
	tagINT4Vector		tagINT4Vector
	{		{
			SWIGLAL_STRUCT(INT4Vector);
			SWIGLAL_DYNAMIC_1DARRAY(INT4, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	INT4 *data; /**< Pointer to the data array. */		INT4 *data; /**< Pointer to the data array. */
	}		}
	INT4Vector;		INT4Vector;
	/** Vector of type UINT4. */		/** Vector of type UINT4. */
	typedef struct		typedef struct
	tagUINT4Vector		tagUINT4Vector
	{		{
			SWIGLAL_STRUCT(UINT4Vector);
			SWIGLAL_DYNAMIC_1DARRAY(UINT4, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	UINT4 *data; /**< Pointer to the data array. */		UINT4 *data; /**< Pointer to the data array. */
	}		}
	UINT4Vector;		UINT4Vector;
	/** Vector of type INT8. */		/** Vector of type INT8. */
	typedef struct		typedef struct
	tagINT8Vector		tagINT8Vector
	{		{
			SWIGLAL_STRUCT(INT8Vector);
			SWIGLAL_DYNAMIC_1DARRAY(INT8, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	INT8 *data; /**< Pointer to the data array. */		INT8 *data; /**< Pointer to the data array. */
	}		}
	INT8Vector;		INT8Vector;
	/** Vector of type UINT8. */		/** Vector of type UINT8. */
	typedef struct		typedef struct
	tagUINT8Vector		tagUINT8Vector
	{		{
			SWIGLAL_STRUCT(UINT8Vector);
			SWIGLAL_DYNAMIC_1DARRAY(UINT8, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	UINT8 *data; /**< Pointer to the data array. */		UINT8 *data; /**< Pointer to the data array. */
	}		}
	UINT8Vector;		UINT8Vector;
	/** Vector of type REAL4. */		/** Vector of type REAL4. */
	typedef struct		typedef struct
	tagREAL4Vector		tagREAL4Vector
	{		{
			SWIGLAL_STRUCT(REAL4Vector);
			SWIGLAL_DYNAMIC_1DARRAY(REAL4, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	REAL4 *data; /**< Pointer to the data array. */		REAL4 *data; /**< Pointer to the data array. */
	}		}
	REAL4Vector;		REAL4Vector;
	/** Vector of type REAL8. */		/** Vector of type REAL8. */
	typedef struct tagREAL8Vector		typedef struct tagREAL8Vector
	{		{
			SWIGLAL_STRUCT(REAL8Vector);
			SWIGLAL_DYNAMIC_1DARRAY(REAL8, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	REAL8 *data; /**< Pointer to the data array. */		REAL8 *data; /**< Pointer to the data array. */
	}		}
	REAL8Vector;		REAL8Vector;
	/** Vector of type COMPLEX8. */		/** Vector of type COMPLEX8. */
	typedef struct tagCOMPLEX8Vector		typedef struct tagCOMPLEX8Vector
	{		{
			SWIGLAL_STRUCT(COMPLEX8Vector);
			SWIGLAL_DYNAMIC_1DARRAY(COMPLEX8, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	COMPLEX8 *data; /**< Pointer to the data array. */		COMPLEX8 *data; /**< Pointer to the data array. */
	}		}
	COMPLEX8Vector;		COMPLEX8Vector;
	/** Vector of type COMPLEX16. */		/** Vector of type COMPLEX16. */
	typedef struct tagCOMPLEX16Vector		typedef struct tagCOMPLEX16Vector
	{		{
			SWIGLAL_STRUCT(COMPLEX16Vector);
			SWIGLAL_DYNAMIC_1DARRAY(COMPLEX16, data, UINT4, length);
	UINT4 length; /**< Number of elements in array. */		UINT4 length; /**< Number of elements in array. */
	COMPLEX16 *data; /**< Pointer to the data array. */		COMPLEX16 *data; /**< Pointer to the data array. */
	}		}
	COMPLEX16Vector;		COMPLEX16Vector;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vspace{2ex}		\vspace{2ex}
	\begin{verbatim}		\begin{verbatim}
	<datatype>Array		<datatype>Array
	skipping to change at line 456		skipping to change at line 491
	the index of \verb@data[]@ runs over the entire range of an index		the index of \verb@data[]@ runs over the entire range of an index
	$i_{k+1}$ before incrementing $i_k$.		$i_{k+1}$ before incrementing $i_k$.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	/** Multidimentional array of INT2. */		/** Multidimentional array of INT2. */
	typedef struct		typedef struct
	tagINT2Array		tagINT2Array
	{		{
			SWIGLAL_STRUCT(INT2Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	INT2 *data; /**< Pointer to the data array. */		INT2 *data; /**< Pointer to the data array. */
	}		}
	INT2Array;		INT2Array;
	/** Multidimentional array of UINT2. */		/** Multidimentional array of UINT2. */
	typedef struct		typedef struct
	tagUINT2Array		tagUINT2Array
	{		{
			SWIGLAL_STRUCT(UINT2Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	UINT2 *data; /**< Pointer to the data array. */		UINT2 *data; /**< Pointer to the data array. */
	}		}
	UINT2Array;		UINT2Array;
	/** Multidimentional array of INT4. */		/** Multidimentional array of INT4. */
	typedef struct		typedef struct
	tagINT4Array		tagINT4Array
	{		{
			SWIGLAL_STRUCT(INT4Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	INT4 *data; /**< Pointer to the data array. */		INT4 *data; /**< Pointer to the data array. */
	}		}
	INT4Array;		INT4Array;
	/** Multidimentional array of UINT4. */		/** Multidimentional array of UINT4. */
	typedef struct		typedef struct
	tagUINT4Array		tagUINT4Array
	{		{
			SWIGLAL_STRUCT(UINT4Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	UINT4 *data; /**< Pointer to the data array. */		UINT4 *data; /**< Pointer to the data array. */
	}		}
	UINT4Array;		UINT4Array;
	/** Multidimentional array of INT8. */		/** Multidimentional array of INT8. */
	typedef struct		typedef struct
	tagINT8Array		tagINT8Array
	{		{
			SWIGLAL_STRUCT(INT8Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	INT8 *data; /**< Pointer to the data array. */		INT8 *data; /**< Pointer to the data array. */
	}		}
	INT8Array;		INT8Array;
	/** Multidimentional array of UINT8. */		/** Multidimentional array of UINT8. */
	typedef struct		typedef struct
	tagUINT8Array		tagUINT8Array
	{		{
			SWIGLAL_STRUCT(UINT8Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	UINT8 *data; /**< Pointer to the data array. */		UINT8 *data; /**< Pointer to the data array. */
	}		}
	UINT8Array;		UINT8Array;
	/** Multidimentional array of REAL4. */		/** Multidimentional array of REAL4. */
	typedef struct		typedef struct
	tagREAL4Array		tagREAL4Array
	{		{
			SWIGLAL_STRUCT(REAL4Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	REAL4 *data; /**< Pointer to the data array. */		REAL4 *data; /**< Pointer to the data array. */
	}		}
	REAL4Array;		REAL4Array;
	/** Multidimentional array of REAL8. */		/** Multidimentional array of REAL8. */
	typedef struct		typedef struct
	tagREAL8Array		tagREAL8Array
	{		{
			SWIGLAL_STRUCT(REAL8Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	REAL8 *data; /**< Pointer to the data array. */		REAL8 *data; /**< Pointer to the data array. */
	}		}
	REAL8Array;		REAL8Array;
	/** Multidimentional array of COMPLEX8. */		/** Multidimentional array of COMPLEX8. */
	typedef struct		typedef struct
	tagCOMPLEX8Array		tagCOMPLEX8Array
	{		{
			SWIGLAL_STRUCT(COMPLEX8Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	COMPLEX8 *data; /**< Pointer to the data array. */		COMPLEX8 *data; /**< Pointer to the data array. */
	}		}
	COMPLEX8Array;		COMPLEX8Array;
	/** Multidimentional array of COMPLEX16. */		/** Multidimentional array of COMPLEX16. */
	typedef struct		typedef struct
	tagCOMPLEX16Array		tagCOMPLEX16Array
	{		{
			SWIGLAL_STRUCT(COMPLEX16Array);
	UINT4Vector *dimLength; /**< Vector of array dimensions. */		UINT4Vector *dimLength; /**< Vector of array dimensions. */
	COMPLEX16 *data; /**< Pointer to the data array. */		COMPLEX16 *data; /**< Pointer to the data array. */
	}		}
	COMPLEX16Array;		COMPLEX16Array;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vspace{2ex}		\vspace{2ex}
	\begin{verbatim}		\begin{verbatim}
	<datatype>Sequence		<datatype>Sequence
	skipping to change at line 601		skipping to change at line 646
	that is, the index of \verb@data[]@ runs over the internal index of		that is, the index of \verb@data[]@ runs over the internal index of
	each vector element before incrementing to the next vector element.		each vector element before incrementing to the next vector element.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	/** Sequence of CHAR Vectors. */		/** Sequence of CHAR Vectors. */
	typedef struct		typedef struct
	tagCHARVectorSequence		tagCHARVectorSequence
	{		{
			SWIGLAL_STRUCT(CHARVectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(CHAR, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	CHAR *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		CHAR *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	CHARVectorSequence;		CHARVectorSequence;
	/** Sequence of INT2 Vectors. */		/** Sequence of INT2 Vectors. */
	typedef struct		typedef struct
	tagINT2VectorSequence		tagINT2VectorSequence
	{		{
			SWIGLAL_STRUCT(INT2VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(INT2, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	INT2 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		INT2 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	INT2VectorSequence;		INT2VectorSequence;
	/** Sequence of UINT2 Vectors. */		/** Sequence of UINT2 Vectors. */
	typedef struct		typedef struct
	tagUINT2VectorSequence		tagUINT2VectorSequence
	{		{
			SWIGLAL_STRUCT(UINT2VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(UINT2, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	UINT2 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		UINT2 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	UINT2VectorSequence;		UINT2VectorSequence;
	/** Sequence of INT4 Vectors. */		/** Sequence of INT4 Vectors. */
	typedef struct		typedef struct
	tagINT4VectorSequence		tagINT4VectorSequence
	{		{
			SWIGLAL_STRUCT(INT4VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(INT4, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	INT4 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		INT4 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	INT4VectorSequence;		INT4VectorSequence;
	/** Sequence of UINT4 Vectors. */		/** Sequence of UINT4 Vectors. */
	typedef struct		typedef struct
	tagUINT4VectorSequence		tagUINT4VectorSequence
	{		{
			SWIGLAL_STRUCT(UINT4VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(UINT4, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	UINT4 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		UINT4 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	UINT4VectorSequence;		UINT4VectorSequence;
	/** Sequence of INT8 Vectors. */		/** Sequence of INT8 Vectors. */
	typedef struct		typedef struct
	tagINT8VectorSequence		tagINT8VectorSequence
	{		{
			SWIGLAL_STRUCT(INT8VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(INT8, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	INT8 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		INT8 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	INT8VectorSequence;		INT8VectorSequence;
	/** Sequence of UINT8 Vectors. */		/** Sequence of UINT8 Vectors. */
	typedef struct		typedef struct
	tagUINT8VectorSequence		tagUINT8VectorSequence
	{		{
			SWIGLAL_STRUCT(UINT8VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(UINT8, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	UINT8 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		UINT8 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	UINT8VectorSequence;		UINT8VectorSequence;
	/** Sequence of REAL4 Vectors. */		/** Sequence of REAL4 Vectors. */
	typedef struct		typedef struct
	tagREAL4VectorSequence		tagREAL4VectorSequence
	{		{
			SWIGLAL_STRUCT(REAL4VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(REAL4, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	REAL4 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		REAL4 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	REAL4VectorSequence;		REAL4VectorSequence;
	/** Sequence of REAL8 Vectors. */		/** Sequence of REAL8 Vectors. */
	typedef struct		typedef struct
	tagREAL8VectorSequence		tagREAL8VectorSequence
	{		{
			SWIGLAL_STRUCT(REAL8VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(REAL8, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	REAL8 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		REAL8 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	REAL8VectorSequence;		REAL8VectorSequence;
	/** Sequence of COMPLEX8 Vectors. */		/** Sequence of COMPLEX8 Vectors. */
	typedef struct		typedef struct
	tagCOMPLEX8VectorSequence		tagCOMPLEX8VectorSequence
	{		{
			SWIGLAL_STRUCT(COMPLEX8VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(COMPLEX8, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	COMPLEX8 *data; /**< Pointer to the data array. Element \a i of vector \ a j is \c data[ \a jn + \a i \c ]. */		COMPLEX8 *data; /**< Pointer to the data array. Element \a i of vector \ a j is \c data[ \a jn + \a i \c ]. */
	}		}
	COMPLEX8VectorSequence;		COMPLEX8VectorSequence;
	/** Sequence of COMPLEX16 Vectors. */		/** Sequence of COMPLEX16 Vectors. */
	typedef struct		typedef struct
	tagCOMPLEX16VectorSequence		tagCOMPLEX16VectorSequence
	{		{
			SWIGLAL_STRUCT(COMPLEX16VectorSequence);
			SWIGLAL_DYNAMIC_2DARRAY(COMPLEX16, data, UINT4, length, vectorLength);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 vectorLength; /**< The length \a n of each vector. */		UINT4 vectorLength; /**< The length \a n of each vector. */
	COMPLEX16 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */		COMPLEX16 *data; /**< Pointer to the data array. Element \a i of vector \a j is \c data[ \a jn + \a i \c ]. */
	}		}
	COMPLEX16VectorSequence;		COMPLEX16VectorSequence;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vspace{2ex}		\vspace{2ex}
	\begin{verbatim}		\begin{verbatim}
	skipping to change at line 746		skipping to change at line 813
	the index of \verb@data[]@ runs over the internal indecies of each		the index of \verb@data[]@ runs over the internal indecies of each
	array element before incrementing to the next array element.		array element before incrementing to the next array element.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	/** Sequency of INT2 multidimensional arrays. */		/** Sequency of INT2 multidimensional arrays. */
	typedef struct		typedef struct
	tagINT2ArraySequence		tagINT2ArraySequence
	{		{
			SWIGLAL_STRUCT(INT2ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	INT2 *data; /**< Pointer to the data array. */		INT2 *data; /**< Pointer to the data array. */
	}		}
	INT2ArraySequence;		INT2ArraySequence;
	/** Sequency of UINT2 multidimensional arrays. */		/** Sequency of UINT2 multidimensional arrays. */
	typedef struct		typedef struct
	tagUINT2ArraySequence		tagUINT2ArraySequence
	{		{
			SWIGLAL_STRUCT(UINT2ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	UINT2 *data; /**< Pointer to the data array. */		UINT2 *data; /**< Pointer to the data array. */
	}		}
	UINT2ArraySequence;		UINT2ArraySequence;
	/** Sequency of INT4 multidimensional arrays. */		/** Sequency of INT4 multidimensional arrays. */
	typedef struct		typedef struct
	tagINT4ArraySequence		tagINT4ArraySequence
	{		{
			SWIGLAL_STRUCT(INT4ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	INT4 *data; /**< Pointer to the data array. */		INT4 *data; /**< Pointer to the data array. */
	}		}
	INT4ArraySequence;		INT4ArraySequence;
	/** Sequency of UINT4 multidimensional arrays. */		/** Sequency of UINT4 multidimensional arrays. */
	typedef struct		typedef struct
	tagUINT4ArraySequence		tagUINT4ArraySequence
	{		{
			SWIGLAL_STRUCT(UINT4ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	UINT4 *data; /**< Pointer to the data array. */		UINT4 *data; /**< Pointer to the data array. */
	}		}
	UINT4ArraySequence;		UINT4ArraySequence;
	/** Sequency of INT8 multidimensional arrays. */		/** Sequency of INT8 multidimensional arrays. */
	typedef struct		typedef struct
	tagINT8ArraySequence		tagINT8ArraySequence
	{		{
			SWIGLAL_STRUCT(INT8ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	INT8 *data; /**< Pointer to the data array. */		INT8 *data; /**< Pointer to the data array. */
	}		}
	INT8ArraySequence;		INT8ArraySequence;
	/** Sequency of UINT8 multidimensional arrays. */		/** Sequency of UINT8 multidimensional arrays. */
	typedef struct		typedef struct
	tagUINT8ArraySequence		tagUINT8ArraySequence
	{		{
			SWIGLAL_STRUCT(UINT8ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	UINT8 *data; /**< Pointer to the data array. */		UINT8 *data; /**< Pointer to the data array. */
	}		}
	UINT8ArraySequence;		UINT8ArraySequence;
	/** Sequency of REAL4 multidimensional arrays. */		/** Sequency of REAL4 multidimensional arrays. */
	typedef struct		typedef struct
	tagREAL4ArraySequence		tagREAL4ArraySequence
	{		{
			SWIGLAL_STRUCT(REAL4ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	REAL4 *data; /**< Pointer to the data array. */		REAL4 *data; /**< Pointer to the data array. */
	}		}
	REAL4ArraySequence;		REAL4ArraySequence;
	/** Sequency of REAL8 multidimensional arrays. */		/** Sequency of REAL8 multidimensional arrays. */
	typedef struct		typedef struct
	tagREAL8ArraySequence		tagREAL8ArraySequence
	{		{
			SWIGLAL_STRUCT(REAL8ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	REAL8 *data; /**< Pointer to the data array. */		REAL8 *data; /**< Pointer to the data array. */
	}		}
	REAL8ArraySequence;		REAL8ArraySequence;
	/** Sequency of COMPLEX8 multidimensional arrays. */		/** Sequency of COMPLEX8 multidimensional arrays. */
	typedef struct		typedef struct
	tagCOMPLEX8ArraySequence		tagCOMPLEX8ArraySequence
	{		{
			SWIGLAL_STRUCT(COMPLEX8ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	COMPLEX8 *data; /**< Pointer to the data array. */		COMPLEX8 *data; /**< Pointer to the data array. */
	}		}
	COMPLEX8ArraySequence;		COMPLEX8ArraySequence;
	/** Sequency of COMPLEX16 multidimensional arrays. */		/** Sequency of COMPLEX16 multidimensional arrays. */
	typedef struct		typedef struct
	tagCOMPLEX16ArraySequence		tagCOMPLEX16ArraySequence
	{		{
			SWIGLAL_STRUCT(COMPLEX16ArraySequence);
	UINT4 length; /**< The number \a l of vectors. */		UINT4 length; /**< The number \a l of vectors. */
	UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */		UINT4 arrayDim; /**< The number of data \a N in each array element (this is not the number \a m of indices). */
	UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */		UINT4Vector *dimLength; /**< Pointer to a vector of length \a m storing t he array dimensions */
	COMPLEX16 *data; /**< Pointer to the data array. */		COMPLEX16 *data; /**< Pointer to the data array. */
	}		}
	COMPLEX16ArraySequence;		COMPLEX16ArraySequence;
	/*@}*/		/*@}*/
	/* <lalLaTeX>		/* <lalLaTeX>
	\newpage		\newpage
	skipping to change at line 910		skipping to change at line 987
	* specific physical information, such as the GPS time, or the factored		* specific physical information, such as the GPS time, or the factored
	* response function of a filter.		* response function of a filter.
	*		*
	*/		*/
	/*@{*/		/*@{*/
	/** Epoch relative to GPS epoch */		/** Epoch relative to GPS epoch */
	typedef struct		typedef struct
	tagLIGOTimeGPS		tagLIGOTimeGPS
	{		{
			SWIGLAL_STRUCT(LIGOTimeGPS);
	INT4 gpsSeconds; /**< Seconds since 0h UTC 6 Jan 1980. */		INT4 gpsSeconds; /**< Seconds since 0h UTC 6 Jan 1980. */
	INT4 gpsNanoSeconds; /**< Residual nanoseconds. */		INT4 gpsNanoSeconds; /**< Residual nanoseconds. */
	}		}
	LIGOTimeGPS;		LIGOTimeGPS;
	#define LIGOTIMEGPSZERO { 0, 0 }		#define LIGOTIMEGPSZERO { 0, 0 }
	/* <lalLaTeX>		/* <lalLaTeX>
	\vspace{2ex}		\vspace{2ex}
	skipping to change at line 993		skipping to change at line 1071
	* The indexes of the units can be specified using the constants		* The indexes of the units can be specified using the constants
	* LALUnitIndexMeter, LALUnitIndexKiloGram,		* LALUnitIndexMeter, LALUnitIndexKiloGram,
	* LALUnitIndexSecond, LALUnitIndexAmpere,		* LALUnitIndexSecond, LALUnitIndexAmpere,
	* LALUnitIndexKelvin, LALUnitIndexStrain,		* LALUnitIndexKelvin, LALUnitIndexStrain,
	* LALUnitIndexADCCount, while LALNumUnits is the total number of units.		* LALUnitIndexADCCount, while LALNumUnits is the total number of units.
	*		*
	*/		*/
	typedef struct		typedef struct
	tagLALUnit		tagLALUnit
	{		{
			SWIGLAL_STRUCT(LALUnit);
	INT2 powerOfTen; /**< Overall power-of-ten scaling is 10^\c powerOfTen. */		INT2 powerOfTen; /**< Overall power-of-ten scaling is 10^\c powerOfTen. */
	INT2 unitNumerator[LALNumUnits]; /**< Array of unit power numerators. */		INT2 unitNumerator[LALNumUnits]; /**< Array of unit power numerators. */
	UINT2 unitDenominatorMinusOne[LALNumUnits]; /**< Array of unit power deno minators-minus-one. */		UINT2 unitDenominatorMinusOne[LALNumUnits]; /**< Array of unit power deno minators-minus-one. */
	}		}
	LALUnit;		LALUnit;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vspace{2ex}		\vspace{2ex}
	\begin{verbatim}		\begin{verbatim}
	skipping to change at line 1030		skipping to change at line 1109
	seconds.		seconds.
	\item[\texttt{REAL8 f0}] The heterodyning frequency $f_0$, in hertz.		\item[\texttt{REAL8 f0}] The heterodyning frequency $f_0$, in hertz.
	\item[\texttt{LALUnit sampleUnits}] The physical units of the		\item[\texttt{LALUnit sampleUnits}] The physical units of the
	quantity being sampled.		quantity being sampled.
	\item[\texttt{<datatype>Sequence *data}] The sequence of sampled data.		\item[\texttt{<datatype>Sequence *data}] The sequence of sampled data.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	/** Length of name fields of LAL structured data types. */		/** Length of name fields of LAL structured data types. */
	enum { LALNameLength = 64 };		enum enumLALNameLength { LALNameLength = 64 };
	/** Time series of INT2 data. */		/** Time series of INT2 data. */
	typedef struct		typedef struct
	tagINT2TimeSeries		tagINT2TimeSeries
	{		{
			SWIGLAL_STRUCT(INT2TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time seri es in seconds. */		REAL8 deltaT; /**< The time step between samples of the time seri es in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	INT2Sequence *data; /**< The sequence of sampled data. */		INT2Sequence *data; /**< The sequence of sampled data. */
	}		}
	INT2TimeSeries;		INT2TimeSeries;
	/** Time series of UINT2 data. */		/** Time series of UINT2 data. */
	typedef struct		typedef struct
	tagUINT2TimeSeries		tagUINT2TimeSeries
	{		{
			SWIGLAL_STRUCT(UINT2TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */		REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	UINT2Sequence *data; /**< The sequence of sampled data. */		UINT2Sequence *data; /**< The sequence of sampled data. */
	}		}
	UINT2TimeSeries;		UINT2TimeSeries;
	/** Time series of INT4 data. */		/** Time series of INT4 data. */
	typedef struct		typedef struct
	tagINT4TimeSeries		tagINT4TimeSeries
	{		{
			SWIGLAL_STRUCT(INT4TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time seri es in seconds. */		REAL8 deltaT; /**< The time step between samples of the time seri es in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	INT4Sequence *data; /**< The sequence of sampled data. */		INT4Sequence *data; /**< The sequence of sampled data. */
	}		}
	INT4TimeSeries;		INT4TimeSeries;
	/** Time series of UINT4 data. */		/** Time series of UINT4 data. */
	typedef struct		typedef struct
	tagUINT4TimeSeries		tagUINT4TimeSeries
	{		{
			SWIGLAL_STRUCT(UINT4TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */		REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	UINT4Sequence *data; /**< The sequence of sampled data. */		UINT4Sequence *data; /**< The sequence of sampled data. */
	}		}
	UINT4TimeSeries;		UINT4TimeSeries;
	/** Time series of INT8 data. */		/** Time series of INT8 data. */
	typedef struct		typedef struct
	tagINT8TimeSeries		tagINT8TimeSeries
	{		{
			SWIGLAL_STRUCT(INT8TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time seri es in seconds. */		REAL8 deltaT; /**< The time step between samples of the time seri es in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	INT8Sequence *data; /**< The sequence of sampled data. */		INT8Sequence *data; /**< The sequence of sampled data. */
	}		}
	INT8TimeSeries;		INT8TimeSeries;
	/** Time series of UINT8 data. */		/** Time series of UINT8 data. */
	typedef struct		typedef struct
	tagUINT8TimeSeries		tagUINT8TimeSeries
	{		{
			SWIGLAL_STRUCT(UINT8TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */		REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	UINT8Sequence *data; /**< The sequence of sampled data. */		UINT8Sequence *data; /**< The sequence of sampled data. */
	}		}
	UINT8TimeSeries;		UINT8TimeSeries;
	/** Time series of REAL4 data. */		/** Time series of REAL4 data. */
	typedef struct		typedef struct
	tagREAL4TimeSeries		tagREAL4TimeSeries
	{		{
			SWIGLAL_STRUCT(REAL4TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */		REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	REAL4Sequence *data; /**< The sequence of sampled data. */		REAL4Sequence *data; /**< The sequence of sampled data. */
	}		}
	REAL4TimeSeries;		REAL4TimeSeries;
	/** Time series of REAL8 data. */		/** Time series of REAL8 data. */
	typedef struct		typedef struct
	tagREAL8TimeSeries		tagREAL8TimeSeries
	{		{
			SWIGLAL_STRUCT(REAL8TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */		REAL8 deltaT; /**< The time step between samples of the time ser ies in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	REAL8Sequence *data; /**< The sequence of sampled data. */		REAL8Sequence *data; /**< The sequence of sampled data. */
	}		}
	REAL8TimeSeries;		REAL8TimeSeries;
	/** Time series of COMPLEX8 data. */		/** Time series of COMPLEX8 data. */
	typedef struct		typedef struct
	tagCOMPLEX8TimeSeries		tagCOMPLEX8TimeSeries
	{		{
			SWIGLAL_STRUCT(COMPLEX8TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time series in seconds. */		REAL8 deltaT; /**< The time step between samples of the time series in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity be ing sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity be ing sampled. */
	COMPLEX8Sequence *data; /**< The sequence of sampled data. */		COMPLEX8Sequence *data; /**< The sequence of sampled data. */
	}		}
	COMPLEX8TimeSeries;		COMPLEX8TimeSeries;
	/** Time series of COMPLEX16 data. */		/** Time series of COMPLEX16 data. */
	typedef struct		typedef struct
	tagCOMPLEX16TimeSeries		tagCOMPLEX16TimeSeries
	{		{
			SWIGLAL_STRUCT(COMPLEX16TimeSeries);
	CHAR name[LALNameLength]; /**< The name of the time series. */		CHAR name[LALNameLength]; /**< The name of the time series. */
	LIGOTimeGPS epoch; /**< The start time of the time series. */		LIGOTimeGPS epoch; /**< The start time of the time series. */
	REAL8 deltaT; /**< The time step between samples of the time series in seconds. */		REAL8 deltaT; /**< The time step between samples of the time series in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity b eing sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity b eing sampled. */
	COMPLEX16Sequence *data; /**< The sequence of sampled data. */		COMPLEX16Sequence *data; /**< The sequence of sampled data. */
	}		}
	COMPLEX16TimeSeries;		COMPLEX16TimeSeries;
	/* <lalLaTeX>		/* <lalLaTeX>
	skipping to change at line 1189		skipping to change at line 1278
	\item[\texttt{<datatype>VectorSequence *data}] The sequence of sampled		\item[\texttt{<datatype>VectorSequence *data}] The sequence of sampled
	data.		data.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	/** Time series of INT2 vectors. */		/** Time series of INT2 vectors. */
	typedef struct		typedef struct
	tagINT2TimeVectorSeries		tagINT2TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(INT2TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	INT2VectorSequence *data; /**< The sequence of sampled data vectors. */		INT2VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	INT2TimeVectorSeries;		INT2TimeVectorSeries;
	/** Time series of UINT2 vectors. */		/** Time series of UINT2 vectors. */
	typedef struct		typedef struct
	tagUINT2TimeVectorSeries		tagUINT2TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(UINT2TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	UINT2VectorSequence *data; /**< The sequence of sampled data vectors. */		UINT2VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	UINT2TimeVectorSeries;		UINT2TimeVectorSeries;
	/** Time series of INT4 vectors. */		/** Time series of INT4 vectors. */
	typedef struct		typedef struct
	tagINT4TimeVectorSeries		tagINT4TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(INT4TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	INT4VectorSequence *data; /**< The sequence of sampled data vectors. */		INT4VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	INT4TimeVectorSeries;		INT4TimeVectorSeries;
	/** Time series of UINT4 vectors. */		/** Time series of UINT4 vectors. */
	typedef struct		typedef struct
	tagUINT4TimeVectorSeries		tagUINT4TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(UINT4TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	UINT4VectorSequence *data; /**< The sequence of sampled data vectors. */		UINT4VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	UINT4TimeVectorSeries;		UINT4TimeVectorSeries;
	/** Time series of INT8 vectors. */		/** Time series of INT8 vectors. */
	typedef struct		typedef struct
	tagINT8TimeVectorSeries		tagINT8TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(INT8TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	INT8VectorSequence *data; /**< The sequence of sampled data vectors. */		INT8VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	INT8TimeVectorSeries;		INT8TimeVectorSeries;
	/** Time series of UINT8 vectors. */		/** Time series of UINT8 vectors. */
	typedef struct		typedef struct
	tagUINT8TimeVectorSeries		tagUINT8TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(UINT8TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	UINT8VectorSequence *data; /**< The sequence of sampled data vectors. */		UINT8VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	UINT8TimeVectorSeries;		UINT8TimeVectorSeries;
	/** Time series of REAL4 vectors. */		/** Time series of REAL4 vectors. */
	typedef struct		typedef struct
	tagREAL4TimeVectorSeries		tagREAL4TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(REAL4TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	REAL4VectorSequence *data; /**< The sequence of sampled data vectors. */		REAL4VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	REAL4TimeVectorSeries;		REAL4TimeVectorSeries;
	/** Time series of REAL8 vectors. */		/** Time series of REAL8 vectors. */
	typedef struct		typedef struct
	tagREAL8TimeVectorSeries		tagREAL8TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(REAL8TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */		CHAR name[LALNameLength]; /**< The name of the time serie s of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vec tors. */
	REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of the ti me series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quantity being sampled. */
	REAL8VectorSequence *data; /**< The sequence of sampled data vectors. */		REAL8VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	REAL8TimeVectorSeries;		REAL8TimeVectorSeries;
	/** Time series of COMPLEX8 vectors. */		/** Time series of COMPLEX8 vectors. */
	typedef struct		typedef struct
	tagCOMPLEX8TimeVectorSeries		tagCOMPLEX8TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(COMPLEX8TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time s eries of vectors. */		CHAR name[LALNameLength]; /**< The name of the time s eries of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series of vectors. */		LIGOTimeGPS epoch; /**< The start time of the time series of vectors. */
	REAL8 deltaT; /**< The time step between samples of th e time series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of th e time series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz (z ero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz (z ero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the quan tity being sampled. */		LALUnit sampleUnits; /**< The physical units of the quan tity being sampled. */
	COMPLEX8VectorSequence *data; /**< The sequence of sampled data vectors. */		COMPLEX8VectorSequence *data; /**< The sequence of sampled data vectors. */
	}		}
	COMPLEX8TimeVectorSeries;		COMPLEX8TimeVectorSeries;
	/** Time series of COMPLEX16 vectors. */		/** Time series of COMPLEX16 vectors. */
	typedef struct		typedef struct
	tagCOMPLEX16TimeVectorSeries		tagCOMPLEX16TimeVectorSeries
	{		{
			SWIGLAL_STRUCT(COMPLEX16TimeVectorSeries);
	CHAR name[LALNameLength]; /**< The name of the time series of vectors. */		CHAR name[LALNameLength]; /**< The name of the time series of vectors. */
	LIGOTimeGPS epoch; /**< The start time of the time series o f vectors. */		LIGOTimeGPS epoch; /**< The start time of the time series o f vectors. */
	REAL8 deltaT; /**< The time step between samples of t he time series of vectors in seconds. */		REAL8 deltaT; /**< The time step between samples of t he time series of vectors in seconds. */
	REAL8 f0; /**< The heterodyning frequency, in Hertz ( zero if not heterodyned). */		REAL8 f0; /**< The heterodyning frequency, in Hertz ( zero if not heterodyned). */
	LALUnit sampleUnits; /**< The physical units of the qua ntity being sampled. */		LALUnit sampleUnits; /**< The physical units of the qua ntity being sampled. */
	COMPLEX16VectorSequence *data; /**< The sequence of sampled data vectors . */		COMPLEX16VectorSequence *data; /**< The sequence of sampled data vectors . */
	}		}
	COMPLEX16TimeVectorSeries;		COMPLEX16TimeVectorSeries;
	/* <lalLaTeX>		/* <lalLaTeX>
	skipping to change at line 1341		skipping to change at line 1440
	quantity being sampled.		quantity being sampled.
	\item[\texttt{<datatype>ArraySequence *data}] The sequence of sampled		\item[\texttt{<datatype>ArraySequence *data}] The sequence of sampled
	data.		data.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	typedef struct		typedef struct
	tagINT2TimeArraySeries		tagINT2TimeArraySeries
	{		{
			SWIGLAL_STRUCT(INT2TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	INT2ArraySequence *data;		INT2ArraySequence *data;
	}		}
	INT2TimeArraySeries;		INT2TimeArraySeries;
	typedef struct		typedef struct
	tagUINT2TimeArraySeries		tagUINT2TimeArraySeries
	{		{
			SWIGLAL_STRUCT(UINT2TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	UINT2ArraySequence *data;		UINT2ArraySequence *data;
	}		}
	UINT2TimeArraySeries;		UINT2TimeArraySeries;
	typedef struct		typedef struct
	tagINT4TimeArraySeries		tagINT4TimeArraySeries
	{		{
			SWIGLAL_STRUCT(INT4TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	INT4ArraySequence *data;		INT4ArraySequence *data;
	}		}
	INT4TimeArraySeries;		INT4TimeArraySeries;
	typedef struct		typedef struct
	tagUINT4TimeArraySeries		tagUINT4TimeArraySeries
	{		{
			SWIGLAL_STRUCT(UINT4TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	UINT4ArraySequence *data;		UINT4ArraySequence *data;
	}		}
	UINT4TimeArraySeries;		UINT4TimeArraySeries;
	typedef struct		typedef struct
	tagINT8TimeArraySeries		tagINT8TimeArraySeries
	{		{
			SWIGLAL_STRUCT(INT8TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	INT8ArraySequence *data;		INT8ArraySequence *data;
	}		}
	INT8TimeArraySeries;		INT8TimeArraySeries;
	typedef struct		typedef struct
	tagUINT8TimeArraySeries		tagUINT8TimeArraySeries
	{		{
			SWIGLAL_STRUCT(UINT8TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	UINT8ArraySequence *data;		UINT8ArraySequence *data;
	}		}
	UINT8TimeArraySeries;		UINT8TimeArraySeries;
	typedef struct		typedef struct
	tagREAL4TimeArraySeries		tagREAL4TimeArraySeries
	{		{
			SWIGLAL_STRUCT(REAL4TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	REAL4ArraySequence *data;		REAL4ArraySequence *data;
	}		}
	REAL4TimeArraySeries;		REAL4TimeArraySeries;
	typedef struct		typedef struct
	tagREAL8TimeArraySeries		tagREAL8TimeArraySeries
	{		{
			SWIGLAL_STRUCT(REAL8TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	REAL8ArraySequence *data;		REAL8ArraySequence *data;
	}		}
	REAL8TimeArraySeries;		REAL8TimeArraySeries;
	typedef struct		typedef struct
	tagCOMPLEX8TimeArraySeries		tagCOMPLEX8TimeArraySeries
	{		{
			SWIGLAL_STRUCT(COMPLEX8TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	COMPLEX8ArraySequence *data;		COMPLEX8ArraySequence *data;
	}		}
	COMPLEX8TimeArraySeries;		COMPLEX8TimeArraySeries;
	typedef struct		typedef struct
	tagCOMPLEX16TimeArraySeries		tagCOMPLEX16TimeArraySeries
	{		{
			SWIGLAL_STRUCT(COMPLEX16TimeArraySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 deltaT;		REAL8 deltaT;
	REAL8 f0;		REAL8 f0;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	COMPLEX16ArraySequence *data;		COMPLEX16ArraySequence *data;
	}		}
	COMPLEX16TimeArraySeries;		COMPLEX16TimeArraySeries;
	/* <lalLaTeX>		/* <lalLaTeX>
	skipping to change at line 1490		skipping to change at line 1599
	\item[\texttt{LALUnit sampleUnits}] The physical units of the		\item[\texttt{LALUnit sampleUnits}] The physical units of the
	quantity being sampled.		quantity being sampled.
	\item[\texttt{<datatype>Sequence *data}] The sequence of sampled data.		\item[\texttt{<datatype>Sequence *data}] The sequence of sampled data.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	typedef struct		typedef struct
	tagINT2FrequencySeries		tagINT2FrequencySeries
	{		{
			SWIGLAL_STRUCT(INT2FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	INT2Sequence *data;		INT2Sequence *data;
	}		}
	INT2FrequencySeries;		INT2FrequencySeries;
	typedef struct		typedef struct
	tagUINT2FrequencySeries		tagUINT2FrequencySeries
	{		{
			SWIGLAL_STRUCT(UINT2FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	UINT2Sequence *data;		UINT2Sequence *data;
	}		}
	UINT2FrequencySeries;		UINT2FrequencySeries;
	typedef struct		typedef struct
	tagINT4FrequencySeries		tagINT4FrequencySeries
	{		{
			SWIGLAL_STRUCT(INT4FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	INT4Sequence *data;		INT4Sequence *data;
	}		}
	INT4FrequencySeries;		INT4FrequencySeries;
	typedef struct		typedef struct
	tagUINT4FrequencySeries		tagUINT4FrequencySeries
	{		{
			SWIGLAL_STRUCT(UINT4FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	UINT4Sequence *data;		UINT4Sequence *data;
	}		}
	UINT4FrequencySeries;		UINT4FrequencySeries;
	typedef struct		typedef struct
	tagINT8FrequencySeries		tagINT8FrequencySeries
	{		{
			SWIGLAL_STRUCT(INT8FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	INT8Sequence *data;		INT8Sequence *data;
	}		}
	INT8FrequencySeries;		INT8FrequencySeries;
	typedef struct		typedef struct
	tagUINT8FrequencySeries		tagUINT8FrequencySeries
	{		{
			SWIGLAL_STRUCT(UINT8FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	UINT8Sequence *data;		UINT8Sequence *data;
	}		}
	UINT8FrequencySeries;		UINT8FrequencySeries;
	typedef struct		typedef struct
	tagREAL4FrequencySeries		tagREAL4FrequencySeries
	{		{
			SWIGLAL_STRUCT(REAL4FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	REAL4Sequence *data;		REAL4Sequence *data;
	}		}
	REAL4FrequencySeries;		REAL4FrequencySeries;
	typedef struct		typedef struct
	tagREAL8FrequencySeries		tagREAL8FrequencySeries
	{		{
			SWIGLAL_STRUCT(REAL8FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	REAL8Sequence *data;		REAL8Sequence *data;
	}		}
	REAL8FrequencySeries;		REAL8FrequencySeries;
	typedef struct		typedef struct
	tagCOMPLEX8FrequencySeries		tagCOMPLEX8FrequencySeries
	{		{
			SWIGLAL_STRUCT(COMPLEX8FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	COMPLEX8Sequence *data;		COMPLEX8Sequence *data;
	}		}
	COMPLEX8FrequencySeries;		COMPLEX8FrequencySeries;
	typedef struct		typedef struct
	tagCOMPLEX16FrequencySeries		tagCOMPLEX16FrequencySeries
	{		{
			SWIGLAL_STRUCT(COMPLEX16FrequencySeries);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	LIGOTimeGPS epoch;		LIGOTimeGPS epoch;
	REAL8 f0;		REAL8 f0;
	REAL8 deltaF;		REAL8 deltaF;
	LALUnit sampleUnits;		LALUnit sampleUnits;
	COMPLEX16Sequence *data;		COMPLEX16Sequence *data;
	}		}
	COMPLEX16FrequencySeries;		COMPLEX16FrequencySeries;
	/* <lalLaTeX>		/* <lalLaTeX>
	skipping to change at line 1649		skipping to change at line 1768
	\item[\texttt{<datatype>Vector *poles}] Pointer to a vector storing		\item[\texttt{<datatype>Vector *poles}] Pointer to a vector storing
	the poles $p_k$ of the filter.		the poles $p_k$ of the filter.
	\item[\texttt{<datatype> gain}] The gain $g$ of the filter.		\item[\texttt{<datatype> gain}] The gain $g$ of the filter.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
	typedef struct		typedef struct
	tagCOMPLEX8ZPGFilter		tagCOMPLEX8ZPGFilter
	{		{
			SWIGLAL_STRUCT(COMPLEX8ZPGFilter);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	REAL8 deltaT;		REAL8 deltaT;
	COMPLEX8Vector *zeros;		COMPLEX8Vector *zeros;
	COMPLEX8Vector *poles;		COMPLEX8Vector *poles;
	COMPLEX8 gain;		COMPLEX8 gain;
	}		}
	COMPLEX8ZPGFilter;		COMPLEX8ZPGFilter;
	typedef struct		typedef struct
	tagCOMPLEX16ZPGFilter		tagCOMPLEX16ZPGFilter
	{		{
			SWIGLAL_STRUCT(COMPLEX16ZPGFilter);
	CHAR name[LALNameLength];		CHAR name[LALNameLength];
	REAL8 deltaT;		REAL8 deltaT;
	COMPLEX16Vector *zeros;		COMPLEX16Vector *zeros;
	COMPLEX16Vector *poles;		COMPLEX16Vector *poles;
	COMPLEX16 gain;		COMPLEX16 gain;
	}		}
	COMPLEX16ZPGFilter;		COMPLEX16ZPGFilter;
	/*@}*/		/*@}*/
	/* <lalLaTeX>		/* <lalLaTeX>
	skipping to change at line 1710		skipping to change at line 1831
	current \verb@statusCode@ was set.		current \verb@statusCode@ was set.
	\item[\texttt{LALStatus *statusPtr}] Pointer to the next node in the		\item[\texttt{LALStatus *statusPtr}] Pointer to the next node in the
	list; \verb@NULL@ if this function is not reporting a subroutine		list; \verb@NULL@ if this function is not reporting a subroutine
	error.		error.
	\item[\texttt{INT4 level}] The current level in the nested calling		\item[\texttt{INT4 level}] The current level in the nested calling
	sequence.		sequence.
	\end{description}		\end{description}
	</lalLaTeX> */		</lalLaTeX> */
			#ifndef SWIG /* exclude from SWIG interface */
	typedef struct		typedef struct
	tagLALStatus		tagLALStatus
	{		{
	INT4 statusCode;		INT4 statusCode;
	const CHAR *statusDescription;		const CHAR *statusDescription;
	volatile const CHAR *Id;		volatile const CHAR *Id;
	const CHAR *function;		const CHAR *function;
	const CHAR *file;		const CHAR *file;
	INT4 line;		INT4 line;
	struct tagLALStatus *statusPtr;		struct tagLALStatus *statusPtr;
	INT4 level;		INT4 level;
	}		}
	LALStatus;		LALStatus;
			#endif /* SWIG */
	/* <lalLaTeX>		/* <lalLaTeX>
	\vfill{\footnotesize\input{LALDatatypesHV}}		\vfill{\footnotesize\input{LALDatatypesHV}}
	</lalLaTeX> */		</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALDATATYPES_H */		#endif /* _LALDATATYPES_H */
End of changes. 91 change blocks.
	2 lines changed or deleted		125 lines changed or added

	LALDetectors.h		LALDetectors.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
	*/		*/
	/********************************* <lalVerbatim file="LALDetectorsHV">		#ifndef _LALDETECTORS_H
	Author: J. T. Whelan <john.whelan@ligo.org>		#define _LALDETECTORS_H
	$Id$
	********************************** </lalVerbatim> */
	/********************************* <lalLaTeX>		/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	\section{Header \texttt{LALDetectors.h}}		#include <lal/LALDatatypes.h>
	\label{tools:s:LALDetectors.h}
	This header defines structures to hold the basic data describing		#ifdef __cplusplus
	a gravitational wave detector.		extern "C" {
			#endif
	\subsection*{Synopsis}		NRCSID( LALDETECTORSH, "$Id$" );
	\begin{verbatim}
			/**
			\author J. T. Whelan and J. D. E. Creighton
			\addtogroup LALDetectors_h
			\brief This header defines structures to hold the basic data describing
			a gravitational wave detector.
			\heading{Synopsis}
			\code
	#include <lal/LALDetectors.h>		#include <lal/LALDetectors.h>
	\end{verbatim}		\endcode
	According to the common frame format specification		According to the common frame format specification
	\cite{tools:LIGOVIRGO:2000} the geometry of an interferometric		[\ref LIGOVIRGO_2000] the geometry of an interferometric
	detector will be stored in a \texttt{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\"{o}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 \textit{response tensor} $d^{ab}$, 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'' $h$ measured by the detector in		same frame, which defines the "strain" \f$h\f$ measured by the detector in
	terms of the metric perturbation $h_{ab}$ as		terms of the metric perturbation \f$h_{ab}\f$ as
	\begin{equation}		\f{equation}{
	h = h_{ab} \, d^{ab}		h = h_{ab} \, d^{ab}
	\ .		\ .
	\end{equation}		\f}
	This header defines a \texttt{LALFrDetector} structure which contains		This header defines a \c ::LALFrDetector structure which contains
	essentially the same information as the \texttt{FrDetector} structure,		essentially the same information as the \c ::FrDetector structure,
	as well as a \texttt{LALDetector} structure which contains the		as well as a \c LALDetector structure which contains the
	Cartesian co\"{o}rdinates of the detector along with the components of		Cartesian coördinates of the detector along with the components of
	the response tensor $d^{ab}$ in the same co\"{o}rdinate system.		the response tensor \f$d^{ab}\f$ in the same coördinate system.
	\subsubsection*{The Geodetic Co\"{o}rdinate System}		\heading{The Geodetic Coördinate System}
	Geodetic co\"{o}rdinates are spheroidal co\"{o}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 $a=6.378137\times		oblate spheroid with equatorial radius \f$a=6.378137\times
	10^6\,\textrm{m}$ and polar radius $b=6.356752314\times		10^6\,\textrm{m}\f$ and polar radius \f$b=6.356752314\times
	10^6\,\textrm{m}$. Any point in space can be located according to its		10^6\,\textrm{m}\f$. Any point in space can be located according to its
	longitude, latitude, and elevation. The \textit{longitude} $\lambda$		longitude, latitude, and elevation. The \e longitude \f$\lambda\f$
	is the angle between the half-plane bounded by the symmetry axis of		is the angle between the half-plane bounded by the symmetry axis of
	the reference ellipsoid containing the point in question and the		the reference ellipsoid containing the point in question and the
	half-plane plane containing the Prime Meridian; it is measured in		half-plane plane containing the Prime Meridian; it is measured in
	radians, increases to the East, and ranges from		radians, increases to the East, and ranges from
	$-\pi$ to $\pi$. The \textit{latitude} $\beta$ is the		\f$-\pi\f$ to \f$\pi\f$. The \e latitude \f$\beta\f$ is the
	angle between the ray which is normal to the ellipsoid and passes		angle between the ray which is normal to the ellipsoid and passes
	through the point in question and the equatorial plane; it is measured		through the point in question and the equatorial plane; it is measured
	in radians, increases to the North, and ranges		in radians, increases to the North, and ranges
	from $-\pi/2$ to $\pi/2$. The \textit{elevation} $h$ is the		from \f$-\pi/2\f$ to \f$\pi/2\f$. The \e elevation \f$h\f$ is the
	signed distance along this ray from the reference ellipsoid to the		signed distance along this ray from the reference ellipsoid to the
	point in question. This co\"{o}rdinate system is described in more		point in question. This coördinate system is described in more
	detail in \cite{tools:Althouse:1999}.		detail in [\ref Althouse_1999].
	\subsubsection*{Altitude and Azimuth Angles}		\heading{Altitude and Azimuth Angles}
	The \texttt{LALFrDetector} structure stores the directions along the		The \c LALFrDetector structure stores the directions along the
	two arms of an interferometer in an altitude/azimuth representation		two arms of an interferometer in an altitude/azimuth representation
	with respect to the local tangent plane to the reference ellipsoid,		with respect to the local tangent plane to the reference ellipsoid,
	known as the local horizontal. The altitude ${\mathcal{A}}$ is the angle t		known as the local horizontal. The altitude \f${\mathcal{A}}\f$ is the ang
	he		le the
	direction vector makes with the horizontal, ${\mathcal{A}} > 0$ meaning abo		direction vector makes with the horizontal, \f${\mathcal{A}} > 0\f$ meaning
	ve		above
	horizontal, ${\mathcal{A}} < 0$ below. The azimuth angle $\zeta$ is found		horizontal, \f${\mathcal{A}} < 0\f$ below. The azimuth angle \f$\zeta\f$ i
	by		s found by
	projecting the direction onto the local horizontal plane, then		projecting the direction onto the local horizontal plane, then
	measuring the angle clockwise from North to this projected direction.		measuring the angle clockwise from North to this projected direction.
	\subsubsection*{The Cartesian Co\"{o}rdinate System}		\heading{The Cartesian Coördinate System}
	The position vector and response tensor contained in the		The position vector and response tensor contained in the
	\texttt{LALDetector} structure are defined in		\c LALDetector structure are defined in
	a simple orthonormal co\"{o}rdinate system with its origin at		a simple orthonormal coördinate system with its origin at
	the center of the earth, an $x^1$ axis which pierces the Earth's		the center of the earth, an \f$x^1\f$ axis which pierces the Earth's
	surface at the intersection of the equator and the prime meridian, an		surface at the intersection of the equator and the prime meridian, an
	$x^2$ axis which pierces the earth's surface at $\pi/2$ radians East		\f$x^2\f$ axis which pierces the earth's surface at \f$\pi/2\f$ radians Eas
	longitude on the equator, and an $x^3$ axis which pierces the Earth's		t
	surface at the North Pole. The co\"{o}rdinates $x^1$, $x^2$, $x^3$		longitude on the equator, and an \f$x^3\f$ axis which pierces the Earth's
	correspond to the Earth-fixed co\"{o}rdinates $X_E$, $Y_E$, $Z_E$		surface at the North Pole. The coördinates \f$x^1\f$, \f$x^2\f$, \f$x^3\f$
	defined in \cite{tools:Althouse:1999}, respectively.		correspond to the Earth-fixed coördinates \f$X_E\f$, \f$Y_E\f$, \f$Z_E\f$
			defined in [\ref Althouse_1999], respectively.
	The relationship between geodetic and Cartesian co\"{o}rdinates is		The relationship between geodetic and Cartesian coördinates is
	given by		given by
	\begin{eqnarray}		\anchor tools_e_cart1
	\label{tools:e:cart1}		\anchor tools_e_cart2
	x^1&=&\left(		\anchor tools_e_cart3
			\f{align}{
			x^1 &=\left(
	\frac{a^2}{\sqrt{a^2\cos^2\beta+b^2\sin^2\beta}}		\frac{a^2}{\sqrt{a^2\cos^2\beta+b^2\sin^2\beta}}
	+ h		+ h
	\right) \cos\beta\cos\lambda \\		\right) \cos\beta\cos\lambda \label{tools_e_cart1}\\
	\label{tools:e:cart2}		x^2 &=\left(
	x^2&=&\left(
	\frac{a^2}{\sqrt{a^2\cos^2\beta+b^2\sin^2\beta}}		\frac{a^2}{\sqrt{a^2\cos^2\beta+b^2\sin^2\beta}}
	+ h		+ h
	\right) \cos\beta\sin\lambda \\		\right) \cos\beta\sin\lambda \label{tools_e_cart2}\\
	\label{tools:e:cart3}		x^3 &=\left(
	x^3&=&\left(
	\frac{b^2}{\sqrt{a^2\cos^2\beta+b^2\sin^2\beta}}		\frac{b^2}{\sqrt{a^2\cos^2\beta+b^2\sin^2\beta}}
	+ h		+ h
	\right) \sin\beta		\right) \sin\beta \label{tools_e_cart3} \\
	\end{eqnarray}		\f}
	\subsection*{Error conditions}
	\input{LALDetectorsHE}
	********************************** </lalLaTeX> */
	/**************************************** <lalLaTeX file="LALDetectorsHB">
	\bibitem{tools:LIGOVIRGO:2000}
	LIGO Data Group and VIRGO Data Acquisition Group, ``Specification of a
	Common Data Frame Format for Interferometric Gravitational Wave
	Detectors (IGWD)'', LIGO Technical Note
	\href{http://www.ligo.caltech.edu/docs/T/T970130-D.pdf}{LIGO-T970130}
	\bibitem{tools:Althouse:1999}
	William Althouse, Larry Jones, and Albert Lazzarini, ``Determination
	of Global and Local Coordinate Axes for the LIGO Sites'', LIGO
	Technical Note
	\href{http://www.ligo.caltech.edu/docs/T/T980044-10.pdf}{LIGO-T980044}
	% \bibitem{tools:Lazzarini:1995}
	% Albert Lazzarini, ``Derivation
	% of Global and Local Coordinate Axes for the LIGO Sites'', LIGO
	% Technical Note LIGO-T950004
	******************************************************* </lalLaTeX> */
	#ifndef _LALDETECTORS_H
	#define _LALDETECTORS_H
	#include <lal/LALDatatypes.h>
	#ifdef __cplusplus
	extern "C" {
	#endif
	NRCSID( LALDETECTORSH, "$Id$" );
	/** \file		* \heading{Cached Detectors}
	* \ingroup tools
	* \author J. T. Whelan and J. D. E. Creighton
	* \date $Id$
	* \brief Provides constants describing various gravitational wave detector
	s
	*
	* This header defines numerical constants that describe the location and
	* geometry of several operating gravitational wave detectors.
	* These detectors are both resonant mass (bar) detectors and interferometr
	ic
	* detectors. Data for the resonant mass detectors is taken from:
	*
	* http://igec.lnl.infn.it/cgi-bin/browser.pl?Level=0,3,1
	*
	* and
	*
	* L. S. Finn and A. Lazzarini, Phys. Rev. D 64, 082002 (2001)
	*
	* Data for LIGO detectors is taken from:
	*
	* William Althouse, Larry Jones, Albert Lazzarini (1999)
	* "Determination of Global and Local Coordinate Axes for the LIGO Sit
	es"
	* LIGO-T980044-08-E
	*
	* Data for the VIRGO detector is provided by Benoit Mours.
	*
	* Data for the GEO detector is taken from:
	*
	* http://www.geo600.uni-hannover.de/geo600/project/location.html
	*
	* Data for the TAMA detector is provided by Masa-Katsu Fujimoto
	*
	* Data for the Caltech detector is taken from:
	*
	* B. Allen, "Gravitational Wave Detector Sites," gr-qc/9607075 (1996)
	.
	*
	* See the technical document
	*		*
	* Warren Anderson, Patrick Brady, David Chin, Jolien Creighton,		* In practice, we will often be
	* Keith Riles, and John Whelan		* working with fixed unchanging site geometry, e.g., for the LIGO
	* "Beam Pattern Response Functions and Times of Arrival		* interferometers; to avoid constantly reconstructing the corresponding
	* for Earthbound Interferometer"		* \c LALDetectors, we should define some constant
	* LIGO-T010110-00-Z		* \c LALDetectors describing them. Those are stored in a constant
	* http://www.lsc-group.phys.uwm.edu/daswg/docs/technical/T010110.pdf		* array of \c LALDetector structures known as
			* \c lalCachedDetectors, which is declared \c extern in this
			* header and defined in \ref CreateDetector_c.
	*		*
	* for details.		* The <tt>LALCreateDetector()</tt> routine will first look through the
			* \c lalCachedDetectors array for a \c LALDetector structure
			* 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.
	*		*
	* Data in this file (e.g., angle conventions etc.) is intended		* For example, the \c LALDetector representing LIGO Hanford 4km (H1) in
	* to conform to the conventions of the Frame format specification:		* differential mode is <tt>lalCachedDetectors[LAL_LHO_4K_DETECTOR]</tt>.
	*		*
	* LIGO Data and Computing Group and Virgo Data Acquisition Group
	* Specification of a Common Data Frame Format for
	* Interferometric Gravitational Wave Detectors
	* (IGWD)
	* LIGO-T970130-F-E and VIRGO-SPE-LAP-5400-102 (Version 6)
	* http://www.ligo.caltech.edu/docs/T/T970130-F.pdf
	*		*
	*/		*/
			/** @{ */
	/******************************** <lalErrTable file="LALDetectorsHE"> */		/** \name Error Codes */ /*@{*/
			#define LALDETECTORSH_ENULLP 1 /**< Null pointer */
	#define LALDETECTORSH_ENULLP 1		#define LALDETECTORSH_ETYPE 2 /**< Unsupported detector type */
	#define LALDETECTORSH_ETYPE 2		/*@}*/
			/** \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"
	/************************************ </lalErrTable> */
	#define LALDETECTORSH_PRINTF 0		#define LALDETECTORSH_PRINTF 0
			/** \endcond */
	/********************************* <lalLaTeX>
	\subsubsection*{The \texttt{LALDetectorType} enumeration}
	\idx[Type]{LALDetectorType}
	\idx[Constant]{LALDETECTORTYPE\_ABSENT}
	\idx[Constant]{LALDETECTORTYPE\_IFODIFF}
	\idx[Constant]{LALDETECTORTYPE\_IFOXARM}
	\idx[Constant]{LALDETECTORTYPE\_IFOYARM}
	\idx[Constant]{LALDETECTORTYPE\_IFOCOMM}
	\idx[Constant]{LALDETECTORTYPE\_CYLBAR}
	Since data from bars as well as interferometers can be written to
	frames, we need an additional piece of information to interpret the
	site geometry data specified in the \texttt{LALFrDetector}
	structure; for instance, is the x arm really the x arm or is it the
	long axis of a bar? The \texttt{LALDetectorType} enumeration
	provides a way to keep track of that.
	The possible values are (each value is prefaced by
	\texttt{LALDETECTORTYPE\_}):
	\begin{description}
	\item[\texttt{LALDETECTORTYPE\_ABSENT}] No \texttt{FrDetector}
	associated with the structure
	\item[\texttt{LALDETECTORTYPE\_IFODIFF}] Interferometer
	in differential mode
	\item[\texttt{LALDETECTORTYPE\_IFOXARM}] Interferometer
	in one-armed mode (X arm)
	\item[\texttt{LALDETECTORTYPE\_IFOYARM}] Interferometer
	in one-armed mode (Y arm)
	\item[\texttt{LALDETECTORTYPE\_IFOCOMM}] Interferometer in common mode
	\item[\texttt{LALDETECTORTYPE\_CYLBAR}] Cylindrical bar
	\end{description}
	\subsubsection*{Cached Detectors}
	\idx[Variable]{lalCachedDetectors[]} In practice, we will often be
	working with fixed unchanging site geometry, e.g., for the LIGO
	interferometers; to avoid constantly reconstructing the corresponding
	\texttt{LALDetector}s, we should define some constant
	\texttt{LALDetector}s describing them. Those are stored in a constant
	array of \texttt{LALDetector} structures known as
	\texttt{lalCachedDetectors}, which is declared \texttt{extern} in this
	header and defined in \texttt{CreateDetector.c} (see
	Sec.~\ref{tools:ss:CreateDetector.c}).
	The \texttt{LALCreateDetector()} routine will first look through the
	\texttt{lalCachedDetectors} array for a \texttt{LALDetector} structure
	with matching \texttt{type} and \texttt{frDetector.name} fields; if it
	finds one, it returns a copy of that; if not, it creates one.
	The header \texttt{LALDetectors.h} also defines an enumeration of the
	indices of the known detectors:
	\idx[Constant]{LAL\_TAMA\_300\_DETECTOR}
	\idx[Constant]{LAL\_VIRGO\_DETECTOR}
	\idx[Constant]{LAL\_GEO\_600\_DETECTOR}
	\idx[Constant]{LAL\_LHO\_2K\_DETECTOR}
	\idx[Constant]{LAL\_LHO\_4K\_DETECTOR}
	\idx[Constant]{LAL\_LLO\_4K\_DETECTOR}
	\idx[Constant]{LAL\_CIT\_40\_DETECTOR}
	\idx[Constant]{LAL\_ALLEGRO\_DETECTOR}
	\idx[Constant]{LAL\_AURIGA\_DETECTOR}
	\idx[Constant]{LAL\_EXPLORER\_DETECTOR}
	\idx[Constant]{LAL\_NIOBE\_DETECTOR}
	\idx[Constant]{LAL\_NAUTILUS\_DETECTOR}
	\idx[Constant]{LAL\_NUM\_DETECTORS}
	********************************** </lalLaTeX> */
	/********************************* <lalLaTeX>
	For example, the \texttt{LALDetector} representing LIGO Hanford 4km (H1) in
	differential mode is
	\texttt{lalCachedDetectors[LAL\_LHO\_4K\_DETECTOR]}.
	\subsection*{Structures}
	********************************** </lalLaTeX> */
	/********************************* <lalLaTeX>
	\subsubsection*{Structure \texttt{LALFrDetector}}
	\idx[Type]{LALFrDetector}
	The \texttt{LALFrDetector} structure holds site geometry information
	in the same format as the \texttt{FrDetector} structure defined in the
	frames spec. \cite{tools:LIGOVIRGO:2000} The fields are:
	\begin{description}
	\item[\texttt{CHAR name[LALNameLength]}] A unique identifying string.
	\item[\texttt{CHAR prefix[3]}] Two-letter prefix for detector names.
	\item[\texttt{REAL8 vertexLongitudeRadians}] The geodetic longitude
	$\lambda$ of the vertex, in radians.
	\item[\texttt{REAL8 vertexLatitudeRadians}] The geodetic latitude
	$\beta$ of the vertex, in radians.
	\item[\texttt{REAL4 vertexElevation}] The height of the vertex above
	the reference ellipsoid, in meters.
	\item[\texttt{REAL4 xArmAltitudeRadians}] The angle ${\mathcal{A}}_X$ up
	from the
	local tangent plane of the reference ellipsoid to the X arm, in radians.
	\item[\texttt{REAL4 xArmAzimuthRadians}] The angle $\zeta_X$ clockwise
	from North to the projection of the X arm into the local tangent plane of
	the reference ellipsoid, in radians.
	\item[\texttt{REAL4 yArmAltitudeRadians}] The angle ${\mathcal{A}}_Y$ up
	from the
	local tangent plane of the reference ellipsoid to the Y arm, in radians.
	\item[\texttt{REAL4 yArmAzimuthRadians}] The angle $\zeta_Y$ clockwise
	from North to the projection of the Y arm into the local tangent plane of
	the reference ellipsoid, in radians.
	\item[\texttt{REAL4 xArmMidpoint}] The distance to the midpoint of the X
	arm in meters (unused for bars: set it to zero).
	\item[\texttt{REAL4 yArmMidpoint}] The distance to the midpoint of the Y
	arm in meters (unused for bars: set it to zero).
	\end{description}
	\subsubsection*{Structure \texttt{LALDetector}}
	\idx[Type]{LALDetector}
	The \texttt{LALDetector} structure is intended to be the way that detector
	geometry information is passed to LAL routines.
	This structure describes a detector geometry in a way independent of
	the type of detector. The fields are:
	\begin{description}
	\item[\texttt{REAL8 location[3]}] The three components, in an
	Earth-fixed Cartesian co\"{o}rdinate system, of the
	position vector from the center of the Earth to the detector,
	in meters.
	\item[\texttt{REAL4 response[3][3]}] The Earth-fixed Cartesian components
	of the detector's response tensor $d^{ab}$.
	\item[\texttt{LALDetectorType type}] The type of detector (e.g., IFO in
	differential mode, cylindrical bar, etc.)
	\item[\texttt{LALFrDetector frDetector}] The original
	\texttt{LALFrDetector} structure from which this was created.
	\end{description}
	\vfill{\footnotesize\input{LALDetectorsHV}}
	\newpage\input{CreateDetectorC}
	\newpage\input{DetectorSiteTestC}
	********************************** </lalLaTeX> */
	/** Enumeration of Detectors: follows order of DQ bit assignments */		/** Enumeration of Detectors: follows order of DQ bit assignments */
	enum {		enum {
	LAL_TAMA_300_DETECTOR = 0,		LAL_TAMA_300_DETECTOR = 0,
	LAL_VIRGO_DETECTOR = 1,		LAL_VIRGO_DETECTOR = 1,
	LAL_GEO_600_DETECTOR = 2,		LAL_GEO_600_DETECTOR = 2,
	LAL_LHO_2K_DETECTOR = 3,		LAL_LHO_2K_DETECTOR = 3,
	LAL_LHO_4K_DETECTOR = 4,		LAL_LHO_4K_DETECTOR = 4,
	LAL_LLO_4K_DETECTOR = 5,		LAL_LLO_4K_DETECTOR = 5,
	LAL_CIT_40_DETECTOR = 6,		LAL_CIT_40_DETECTOR = 6,
	skipping to change at line 400		skipping to change at line 205
	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 ,
	LAL_NIOBE_DETECTOR_BIT = 1 << 2 * LAL_NIOBE_DETECTOR,		LAL_NIOBE_DETECTOR_BIT = 1 << 2 * LAL_NIOBE_DETECTOR,
	LAL_NAUTILUS_DETECTOR_BIT = 1 << 2 * LAL_NAUTILUS_DETECT OR		LAL_NAUTILUS_DETECTOR_BIT = 1 << 2 * LAL_NAUTILUS_DETECT OR
	};		};
	/** Detector type		/** Detector type, which determines how the detector response is determined
			.
			*
			* Since data from bars as well as interferometers can be written to
			* frames, we need an additional piece of information to interpret the
			* site geometry data specified in the \c LALFrDetector
			* structure; for instance, is the x arm really the x arm or is it the
			* long axis of a bar? The \c LALDetectorType enumeration
			* provides a way to keep track of that.
	*		*
	* The type of detector. This determines how the detector response
	* is determined.
	*/		*/
	typedef enum {		typedef enum {
	LALDETECTORTYPE_ABSENT, /**< No FrDetector associated with this dete ctor */		LALDETECTORTYPE_ABSENT, /**< No FrDetector associated with t his detector */
	LALDETECTORTYPE_IFODIFF, /**< IFO in differential mode */		LALDETECTORTYPE_IFODIFF, /**< IFO in differential mode */
	LALDETECTORTYPE_IFOXARM, /**< IFO in one-armed mode (X arm) * /		LALDETECTORTYPE_IFOXARM, /**< IFO in one-armed mode (X arm) * /
	LALDETECTORTYPE_IFOYARM, /**< IFO in one-armed mode (Y arm) * /		LALDETECTORTYPE_IFOYARM, /**< IFO in one-armed mode (Y arm) * /
	LALDETECTORTYPE_IFOCOMM, /**< IFO in common mode */		LALDETECTORTYPE_IFOCOMM, /**< IFO in common mode */
	LALDETECTORTYPE_CYLBAR /**< Cylindrical bar */		LALDETECTORTYPE_CYLBAR /**< Cylindrical bar */
	}		}
	LALDetectorType;		LALDetectorType;
	/** Detector frame data structure		/** Detector frame data structure
	*		*
	* Structure to contain the data that appears in a FrDetector structure		* Structure to contain the data that appears in a FrDetector structure
	* in frame data.		* in frame data.
	*/		*/
	typedef struct tagLALFrDetector		typedef struct tagLALFrDetector
	{		{
	CHAR name[LALNameLength]; /**< A unique identifying string. */		SWIGLAL_STRUCT(LALFrDetector);
	CHAR prefix[3]; /**< Two-letter prefix for detector'		CHAR name[LALNameLength]; /**< A unique identifying string */
	s channel names. */		CHAR prefix[3]; /**< Two-letter prefix for detector'
	REAL8 vertexLongitudeRadians; /**< The geodetic longitude \f$\lamb		s channel names */
	da\f$ of the vertex in radians. */		REAL8 vertexLongitudeRadians; /**< The geodetic longitude \f$\lamb
	REAL8 vertexLatitudeRadians; /**< The geodetic latitude \f$\beta\		da\f$ of the vertex in radians */
	f$ of the vertex in radians. */		REAL8 vertexLatitudeRadians; /**< The geodetic latitude \f$\beta\
	REAL4 vertexElevation; /**< The height of the vertex above		f$ of the vertex in radians */
	the reference ellipsoid in meters. */		REAL4 vertexElevation; /**< The height of the vertex above
	REAL4 xArmAltitudeRadians; /**< The angle \f${\mathcal{A}}_X\f$		the reference ellipsoid in meters */
	up from the local tangent plane of the reference ellipsoid to the X arm (o		REAL4 xArmAltitudeRadians; /**< The angle \f${\mathcal{A}}_X\f$
	r bar's cylidrical axis) in radians. */		up from the local tangent plane of the reference ellipsoid to the X arm (o
	REAL4 xArmAzimuthRadians; /**< The angle \f$\zeta_X\f$ clockwi		r bar's cylidrical axis) in radians */
	se from North to the projection of the X arm (or bar's cylidrical axis) int		REAL4 xArmAzimuthRadians; /**< The angle \f$\zeta_X\f$ clockwi
	o the local tangent plane of the reference ellipsoid in radians. */		se from North to the projection of the X arm (or bar's cylidrical axis) int
	REAL4 yArmAltitudeRadians; /**< The angle \f${\mathcal{A}}_Y\f$		o the local tangent plane of the reference ellipsoid in radians */
	up from the local tangent plane of the reference ellipsoid to the Y arm in		REAL4 yArmAltitudeRadians; /**< The angle \f${\mathcal{A}}_Y\f$
	radians (unused for bars: set it to zero). */		up from the local tangent plane of the reference ellipsoid to the Y arm in
	REAL4 yArmAzimuthRadians; /**< The angle \f$\zeta_Y\f$ clockwi		radians (unused for bars: set it to zero) */
	se from North to the projection of the Y arm into the local tangent plane o		REAL4 yArmAzimuthRadians; /**< The angle \f$\zeta_Y\f$ clockwi
	f the reference ellipsoid in radians (unused for bars: set it to zero). */		se from North to the projection of the Y arm into the local tangent plane o
	REAL4 xArmMidpoint; /**< The distance to the midpoint of the X a		f the reference ellipsoid in radians (unused for bars: set it to zero) */
	rm in meters (unused for bars: set it to zero). */		REAL4 xArmMidpoint; /**< The distance to the midpoint of
	REAL4 yArmMidpoint; /**< The distance to the midpoint of the Y a		the X arm in meters (unused for bars: set it to zero) */
	rm in meters (unused for bars: set it to zero). */		REAL4 yArmMidpoint; /**< The distance to the midpoint of
			the Y arm in meters (unused for bars: set it to zero) */
	}		}
	LALFrDetector;		LALFrDetector;
	/** Detector structure		/** Detector structure
	*		*
	* Structure to contain detector data in the format most easily used		* Structure to contain detector data in the format most easily used
	* by the LAL routines.		* by the LAL routines.
	*/		*/
	typedef struct tagLALDetector		typedef struct tagLALDetector
	{		{
	REAL8 location[3]; /**< The three components, in an Ear		SWIGLAL_STRUCT(LALDetector);
	th-fixed Cartesian coordinate system, of the position vector from the cente		REAL8 location[3]; /**< The three components, in an Ear
	r of the Earth to the detector in meters. */		th-fixed Cartesian coordinate system, of the position vector from the cente
	REAL4 response[3][3]; /**< The Earth-fixed Cartesian compo		r of the Earth to the detector in meters */
	nents of the detector's response tensor \f$d^{ab}\f$. */		REAL4 response[3][3]; /**< The Earth-fixed Cartesian compo
	LALDetectorType type; /**< The type of the detector (e.g.,		nents of the detector's response tensor \f$d^{ab}\f$ */
	IFO in differential mode, cylindrical bar, etc.). */		LALDetectorType type; /**< The type of the detector (e.g.,
	LALFrDetector frDetector; /**< The original LALFrDetector stru		IFO in differential mode, cylindrical bar, etc.) */
	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 */
			SWIGLAL_GLOBAL_CONST_FIXED_1DARRAY_ELEM(LALDetector, lalCachedDetectors);
			#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
			* \ingroup LALDetectors_h
			* \brief Constants describing various gravitational wave detectors
			*
			* The \ref LALDetectors_h also defines numerical constants that describe t
			he location and
			* geometry of several operating gravitational wave detectors.
			* These detectors are both resonant mass (bar) detectors and interferometr
			ic
			* detectors.
			* <ul>
			* <li> Data for the resonant mass detectors is taken from:
			* http://igec.lnl.infn.it/cgi-bin/browser.pl?Level=0,3,1
			* and [\ref FinnLazzarini_2001]
			*
			* <li> Data for LIGO detectors is taken from [\ref Althouse_1999]
			*
			* <li> Data for the VIRGO detector is provided by Benoit Mours.
			*
			* <li> Data for the GEO detector is taken from:
			*
			* http://www.geo600.uni-hannover.de/geo600/project/location.html
			*
			* <li> Data for the TAMA detector is provided by Masa-Katsu Fujimoto
			*
			* <li> Data for the Caltech detector is taken from [\ref Allen_1996]
			* </ul>
			*
			* See the technical document [\ref ABCCRW_2001] for details.
			*
			* 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]
			*
			* @{
			*/
	/** \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) */
	#define LAL_TAMA_300_DETECTOR_ARM_X_AZIMUTH_RAD 4.71238898038 /**< TAMA_300 x arm azimuth (rad) */		#define LAL_TAMA_300_DETECTOR_ARM_X_AZIMUTH_RAD 4.71238898038 /**< TAMA_300 x arm azimuth (rad) */
	skipping to change at line 752		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 */
			/** @} */
			/** @} */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALDETECTORS_H */		#endif /* _LALDETECTORS_H */
End of changes. 49 change blocks.
	339 lines changed or deleted		191 lines changed or added

	LALError.h		LALError.h
	skipping to change at line 79		skipping to change at line 79
	LALMEMDBG = 16384 /* convenience: don't combine with other bits */		LALMEMDBG = 16384 /* convenience: don't combine with other bits */
	};		};
	/* composite lalDebugLevels: */		/* composite lalDebugLevels: */
	enum { LALMSGLVL1 = LALERROR };		enum { LALMSGLVL1 = LALERROR };
	enum { LALMSGLVL2 = LALERROR | LALWARNING };		enum { LALMSGLVL2 = LALERROR | LALWARNING };
	enum { LALMSGLVL3 = LALERROR | LALWARNING | LALINFO };		enum { LALMSGLVL3 = LALERROR | LALWARNING | LALINFO };
	enum { LALMEMTRACE = LALTRACE | LALMEMINFO };		enum { LALMEMTRACE = LALTRACE | LALMEMINFO };
	enum { LALALLDBG = ~( LALNMEMDBG | LALNMEMPAD | LALNMEMTRK ) };		enum { LALALLDBG = ~( LALNMEMDBG | LALNMEMPAD | LALNMEMTRK ) };
			#ifndef SWIG /* exclude from SWIG interface */
	extern int ( *lalRaiseHook )( int, const char *, ... );		extern int ( *lalRaiseHook )( int, const char *, ... );
	extern void ( *lalAbortHook )( const char *, ... );		extern void ( *lalAbortHook )( const char *, ... );
			#endif /* SWIG */
	int		int
	LALPrintError( const char *fmt, ... );		LALPrintError( const char *fmt, ... );
	int		int
	LALRaise( int sig, const char *fmt, ... );		LALRaise( int sig, const char *fmt, ... );
	void		void
	LALAbort( const char *fmt, ... );		LALAbort( const char *fmt, ... );
End of changes. 2 change blocks.
	0 lines changed or deleted		2 lines changed or added

	LALGSL.h		LALGSL.h
	skipping to change at line 142		skipping to change at line 142
	#include <lal/XLALGSL.h>		#include <lal/XLALGSL.h>
	#include <gsl/gsl_errno.h>		#include <gsl/gsl_errno.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( LALGSLH, "$Id$" );		NRCSID( LALGSLH, "$Id$" );
			#ifndef SWIG /* exclude from SWIG interface */
	extern LALStatus * lalGSLGlobalStatusPtr;		extern LALStatus * lalGSLGlobalStatusPtr;
			#endif /* SWIG */
	void		void
	LALGSLErrorHandler(		LALGSLErrorHandler(
	const char *reason,		const char *reason,
	const char *file,		const char *file,
	int line,		int line,
	int errnum		int errnum
	);		);
	#ifdef LAL_PTHREAD_LOCK		#ifdef LAL_PTHREAD_LOCK
	#include <pthread.h>		#include <pthread.h>
End of changes. 2 change blocks.
	0 lines changed or deleted		2 lines changed or added

	LALMalloc.h		LALMalloc.h
	skipping to change at line 95		skipping to change at line 95
	#define LALCheckMemoryLeaks()		#define LALCheckMemoryLeaks()
	#else		#else
	#define LALMalloc( n ) LALMallocLong( n, __FILE__, __LINE__ )		#define LALMalloc( n ) LALMallocLong( n, __FILE__, __LINE__ )
	#define LALCalloc( m, n ) LALCallocLong( m, n, __FILE__, __LINE__ )		#define LALCalloc( m, n ) LALCallocLong( m, n, __FILE__, __LINE__ )
	#define LALRealloc( p, n ) LALReallocLong( p, n, __FILE__, __LINE__ )		#define LALRealloc( p, n ) LALReallocLong( p, n, __FILE__, __LINE__ )
	/* global variables to assist in memory debugging */		/* global variables to assist in memory debugging */
	/* watch the value of these variables to find a particular alloc/free */		/* watch the value of these variables to find a particular alloc/free */
			#ifndef SWIG /* exclude from SWIG interface */
	extern char *lalMemDbgArgPtr; /* set to ptr arg in free or realloc */		extern char *lalMemDbgArgPtr; /* set to ptr arg in free or realloc */
	extern char *lalMemDbgRetPtr; /* set to ptr returned in alloc functions */		extern char *lalMemDbgRetPtr; /* set to ptr returned in alloc functions */
	extern char *lalMemDbgPtr; /* set in both cases */		extern char *lalMemDbgPtr; /* set in both cases */
	extern char *lalMemDbgUsrPtr; /* avaliable global memory pointer for use r */		extern char *lalMemDbgUsrPtr; /* avaliable global memory pointer for use r */
	extern void **lalMemDbgUsrHndl; /* avaliable global memory handle for user */		extern void **lalMemDbgUsrHndl; /* avaliable global memory handle for user */
	extern int lalIsMemDbgArgPtr; /* ( lalMemDbgUsrPtr == lalMemDbgArgPtr ) */		extern int lalIsMemDbgArgPtr; /* ( lalMemDbgUsrPtr == lalMemDbgArgPtr ) */
	extern int lalIsMemDbgRetPtr; /* ( lalMemDbgUsrPtr == lalMemDbgRetPtr ) */		extern int lalIsMemDbgRetPtr; /* ( lalMemDbgUsrPtr == lalMemDbgRetPtr ) */
	extern int lalIsMemDbgPtr; /* ( lalMemDbgUsrPtr == lalMemDbgPtr ) */		extern int lalIsMemDbgPtr; /* ( lalMemDbgUsrPtr == lalMemDbgPtr ) */
			#endif /* SWIG */
	void *		void *
	LALMallocShort( size_t n );		LALMallocShort( size_t n );
	void *		void *
	LALMallocLong( size_t n, const char *file, int line );		LALMallocLong( size_t n, const char *file, int line );
	void		void
	LALFree( void *p );		LALFree( void *p );
End of changes. 2 change blocks.
	0 lines changed or deleted		2 lines changed or added

	LALMathematica.h		LALMathematica.h
	skipping to change at line 151		skipping to change at line 151
	*		*
	* \newpage\input{LALMath3DPlotC}		* \newpage\input{LALMath3DPlotC}
	* \newpage\input{LALMathNDPlotC}		* \newpage\input{LALMathNDPlotC}
	* \newpage\input{LALMath3DPlotTestC}		* \newpage\input{LALMath3DPlotTestC}
	* \newpage\input{LALMathNDPlotTestC}		* \newpage\input{LALMathNDPlotTestC}
	* </lalLaTeX> */		* </lalLaTeX> */
	#ifndef _LALMATHEMATICA_H		#ifndef _LALMATHEMATICA_H
	#define _LALMATHEMATICA_H		#define _LALMATHEMATICA_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <math.h>		#include <math.h>
	#include <stdio.h>		#include <stdio.h>
	#include <stdlib.h>		#include <stdlib.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
			#if defined(__cplusplus)
			extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
	/* <lalErrTable file="LALMathematicaHE"> */		/* <lalErrTable file="LALMathematicaHE"> */
	#define LALMATHEMATICAH_ENULL 1		#define LALMATHEMATICAH_ENULL 1
	#define LALMATHEMATICAH_MSGENULL "NULL pointer to a LALMathematica.h input structure"		#define LALMATHEMATICAH_MSGENULL "NULL pointer to a LALMathematica.h input structure"
	#define LALMATHEMATICAH_EFILE 2		#define LALMATHEMATICAH_EFILE 2
	#define LALMATHEMATICAH_MSGEFILE "Could not open file to write a Mathematic a Notebook"		#define LALMATHEMATICAH_MSGEFILE "Could not open file to write a Mathematic a Notebook"
	#define LALMATHEMATICAH_EVAL 3		#define LALMATHEMATICAH_EVAL 3
	#define LALMATHEMATICAH_MSGEVAL "Invalid parameter value"		#define LALMATHEMATICAH_MSGEVAL "Invalid parameter value"
	/* </lalErrTable> */		/* </lalErrTable> */
	/* <lalVerbatim file="LALMathematicaHM"> */		/* <lalVerbatim file="LALMathematicaHM"> */
	skipping to change at line 188		skipping to change at line 199
	#define END_INPUTCELL fprintf(nb, "\\)], \"Input\"],\n")		#define END_INPUTCELL fprintf(nb, "\\)], \"Input\"],\n")
	#define END_INPUTCELL_ fprintf(nb, "\\)], \"Input\"]\n")		#define END_INPUTCELL_ fprintf(nb, "\\)], \"Input\"]\n")
	#define BEG_TEXTCELL fprintf(nb, "Cell[\"\\<")		#define BEG_TEXTCELL fprintf(nb, "Cell[\"\\<")
	#define END_TEXTCELL fprintf(nb, "\\>\", \"Text\"],\n")		#define END_TEXTCELL fprintf(nb, "\\>\", \"Text\"],\n")
	#define END_TEXTCELL_ fprintf(nb, "\\>\", \"Text\"]\n")		#define END_TEXTCELL_ fprintf(nb, "\\>\", \"Text\"]\n")
	/* </lalVerbatim> */		/* </lalVerbatim> */
	NRCSID (LALMATHEMATICAH, "$Id$");		NRCSID (LALMATHEMATICAH, "$Id$");
	/* <lalVerbatim file="LALMathematicaHT"> */		/* <lalVerbatim file="LALMathematicaHT"> */
	typedef struct Math3DPointList{		typedef struct tagMath3DPointList{
	struct Math3DPointList *next;		SWIGLAL_STRUCT(Math3DPointList);
			struct tagMath3DPointList *next;
	REAL4 x;		REAL4 x;
	REAL4 y;		REAL4 y;
	REAL4 z;		REAL4 z;
	REAL4 grayLevel;		REAL4 grayLevel;
	}Math3DPointList;		}Math3DPointList;
	typedef struct MathNDPointList{		typedef struct tagMathNDPointList{
	struct MathNDPointList *next;		SWIGLAL_STRUCT(MathNDPointList);
			struct tagMathNDPointList *next;
	REAL4Vector *coordinates;		REAL4Vector *coordinates;
	INT4 dimension;		INT4 dimension;
	REAL4 grayLevel;		REAL4 grayLevel;
	} MathNDPointList;		} MathNDPointList;
	/* </lalVerbatim> */		/* </lalVerbatim> */
	void		void
	LALMath3DPlot( LALStatus *status,		LALMath3DPlot( LALStatus *status,
	Math3DPointList *first,		Math3DPointList *first,
	INT4 *ntiles,		INT4 *ntiles,
	REAL4 *pointSize);		REAL4 *pointSize);
	void		void
	LALMathNDPlot( LALStatus *status,		LALMathNDPlot( LALStatus *status,
	MathNDPointList *first,		MathNDPointList *first,
	INT4 *ntiles,		INT4 *ntiles,
	REAL4 *pointSize );		REAL4 *pointSize );
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
			}
			#endif
	#endif /* _LALMATHEMATICA_H */		#endif /* _LALMATHEMATICA_H */
End of changes. 5 change blocks.
	4 lines changed or deleted		23 lines changed or added

	LALMoment.h		LALMoment.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
	*/		*/
	/* <lalVerbatim file="LALMomentHV">
	Author: Tibbits, M. M.
	$Id$
	</lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{LALMoment.h}}
	\label{s:LALMoment.h}
	\begin{verbatim}
	The LALDMoment() and LALSMoment() associated header file.
	(S - single precision )
	(D - double precision )
	\end{verbatim}
	\subsection*{Synopsis}
	\begin{verbatim}
	#include <lal/LALMoment.h>
	\end{verbatim}
	\noindent This header provides the prototype for the LALDMoment() and LALSM
	oment() function.
	</lalLaTeX> */
	/* Double Include Protection */		/* Double Include Protection */
	#ifndef _LALMOMENT_H		#ifndef _LALMOMENT_H
	#define _LALMOMENT_H		#define _LALMOMENT_H
	#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
	NRCSID( LALMOMENTH, "$Id$");		NRCSID( LALMOMENTH, "$Id$");
	/* <lalLaTeX>		/**
			\author Tibbits, M. M.
			\addtogroup LALMoment_h
	\subsection*{Error codes}		\brief This header provides the prototype for the LALDMoment() and LALSMome
	\input{LALMomentHE}		nt() function.
	\vfill{\footnotesize\input{LALMomentHV}}		\code
	</lalLaTeX> */		(S - single precision )
			(D - double precision )
			\endcode
	/* <lalErrTable file="LALMomentHE"> */		\heading{Synopsis}
			\code
			#include <lal/LALMoment.h>
			\endcode
	#define LALMOMENTH_ENULL 1		*/
	#define LALMOMENTH_ENNUL 2		/** @{ */
	#define LALMOMENTH_ELNTH 3		/**\name Error Codes */ /*@{*/
	#define LALMOMENTH_ESEGZ 4		#define LALMOMENTH_ENULL 1 /**< NULL pointer */
	#define LALMOMENTH_ENUMZ 5		#define LALMOMENTH_ENNUL 2 /**< Non-NULL pointer */
	#define LALMOMENTH_EALOC 6		#define LALMOMENTH_ELNTH 3 /**< Must have more than one data point */
			#define LALMOMENTH_ESEGZ 4 /**< Invalid number of segments */
			#define LALMOMENTH_ENUMZ 5 /**< Invalid number of points in segment */
			#define LALMOMENTH_EALOC 6 /**< Memory Allocation Error */
			/*@}*/
			/** \cond DONT_DOXYGEN */
	#define LALMOMENTH_MSGENULL "NULL pointer."		#define LALMOMENTH_MSGENULL "NULL pointer."
	#define LALMOMENTH_MSGENNUL "Non-NULL pointer."		#define LALMOMENTH_MSGENNUL "Non-NULL pointer."
	#define LALMOMENTH_MSGELNTH "Must have more than one data point."		#define LALMOMENTH_MSGELNTH "Must have more than one data point."
	#define LALMOMENTH_MSGESEGZ "Invalid number of segments"		#define LALMOMENTH_MSGESEGZ "Invalid number of segments"
	#define LALMOMENTH_MSGENUMZ "Invalid number of points in segment"		#define LALMOMENTH_MSGENUMZ "Invalid number of points in segment"
	#define LALMOMENTH_MSGEALOC "Memory Allocation Error"		#define LALMOMENTH_MSGEALOC "Memory Allocation Error"
			/** \endcond */
	/* </lalErrTable> */
	/* Function prototypes */		/* Function prototypes */
	/* <lalLaTeX>		/** Determine specific moment of a set of REAL4 data.
	\newpage\input{LALMomentC}		*/
	</lalLaTeX> */
	void LALSMoment		void LALSMoment
	(		(
	LALStatus *status,		LALStatus *status,
	REAL4 *result,		REAL4 *result,
	REAL4Sequence *data,		REAL4Sequence *data,
	INT4 whichMoment		INT4 whichMoment
	);		);
			/** 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
	);		);
	/* <lalLaTeX>		/** @} */
	\newpage\input{LALMomentTestC}
	</lalLaTeX> */
	#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. 11 change blocks.
	49 lines changed or deleted		30 lines changed or added

	LALNoiseModels.h		LALNoiseModels.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
	*/		*/
	/* <lalVerbatim file="LALNoiseModelsHV">
	Author: Sathyaprakash, B.S.
	$Id$
	</lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{LALNoiseModels.h}}
	\label{s:LALNoiseModels.h}
	Header file for model noise generation codes.
	\subsection*{Synopsis}
	\begin{verbatim}
	#include <lal/LALNoiseModels.h>
	\end{verbatim}
	\noindent This header file covers routines that are used in
	synthetic background noise expected in various
	detectors and signals with random parameters in background noise.
	</lalLaTeX> */
	#ifndef _LALNOISEMODELS_H		#ifndef _LALNOISEMODELS_H
	#define _LALNOISEMODELS_H		#define _LALNOISEMODELS_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <math.h>		#include <math.h>
	#include <stdio.h>		#include <stdio.h>
	#include <stdlib.h>		#include <stdlib.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/LALConstants.h>		#include <lal/LALConstants.h>
	#include <lal/RealFFT.h>		#include <lal/RealFFT.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( LALNOISEMODELSH, "$Id$" );		NRCSID( LALNOISEMODELSH, "$Id$" );
	/* <lalLaTeX>		/**
	\subsection*{Error codes}		\addtogroup LALNoiseModels_h
			\author Sathyaprakash, B.S.
	</lalLaTeX> */		\brief Header file for model noise generation codes.
	/* <lalErrTable> */		\heading{Synopsis}
			\code
			#include <lal/LALNoiseModels.h>
			\endcode
	#define LALNOISEMODELSH_ENULL 1		This header file covers routines that are used in
	#define LALNOISEMODELSH_EMEM 2		synthetic background noise expected in various
	#define LALNOISEMODELSH_ECHOICE 4		detectors and signals with random parameters in background noise.
	#define LALNOISEMODELSH_EDIV0 8
	#define LALNOISEMODELSH_ESIZE 16		*/
			/* @{ */
			/**\name Error Codes */ /*@{*/
			#define LALNOISEMODELSH_ENULL 1 /**< Arguments contained an unexpect
			ed null pointer */
			#define LALNOISEMODELSH_EMEM 2 /**< Memory allocation error */
			#define LALNOISEMODELSH_ECHOICE 4 /**< Invalid choice for an input par
			ameter */
			#define LALNOISEMODELSH_EDIV0 8 /**< Division by zero */
			#define LALNOISEMODELSH_ESIZE 16 /**< Invalid input size */
			/*@} */
			/** \cond DONT_DOXYGEN */
	#define LALNOISEMODELSH_MSGENULL "Arguments contained an unexpected null po inter"		#define LALNOISEMODELSH_MSGENULL "Arguments contained an unexpected null po inter"
	#define LALNOISEMODELSH_MSGEMEM "Memory allocation error"		#define LALNOISEMODELSH_MSGEMEM "Memory allocation error"
	#define LALNOISEMODELSH_MSGECHOICE "Invalid choice for an input parameter"		#define LALNOISEMODELSH_MSGECHOICE "Invalid choice for an input parameter"
	#define LALNOISEMODELSH_MSGEDIV0 "Division by zero"		#define LALNOISEMODELSH_MSGEDIV0 "Division by zero"
	#define LALNOISEMODELSH_MSGESIZE "Invalid input size"		#define LALNOISEMODELSH_MSGESIZE "Invalid input size"
			/** \endcond */
	/* </lalErrTable> */
	/* <lalLaTeX>
	\section*{Structures}
	\input{LALNoiseModelsHS}
	</lalLaTeX> */
	/* <lalVerbatim file="LALNoiseModelsHS"> */
	typedef enum		typedef enum
	{		{
	geo,		geo,
	ligo,		ligo,
	tama,		tama,
	virgo		virgo
	}		}
	Detector;		Detector;
	/* </lalVerbatim> */
	/* <lalLaTeX>
	\idx[Type]{Detector}
	</lalLaTeX> */
	/* <lalVerbatim file="LALNoiseModelsHS"> */
	typedef struct		typedef struct
	tagAddVectorsIn		tagAddVectorsIn
	{		{
			SWIGLAL_STRUCT(AddVectorsIn);
	REAL4Vector *v1;		REAL4Vector *v1;
	REAL4Vector *v2;		REAL4Vector *v2;
	REAL8 a1;		REAL8 a1;
	REAL8 a2;		REAL8 a2;
	}		}
	AddVectorsIn;		AddVectorsIn;
	/* </lalVerbatim> */
	/* <lalLaTeX>
	\idx[Type]{AddVectorsIn}
	</lalLaTeX> */
	/* <lalVerbatim file="LALNoiseModelsHS"> */
	typedef struct		typedef struct
	tagStatsREAL4VectorOut		tagStatsREAL4VectorOut
	{		{
			SWIGLAL_STRUCT(StatsREAL4VectorOut);
	REAL8 mean;		REAL8 mean;
	REAL8 var;		REAL8 var;
	REAL8 stddev;		REAL8 stddev;
	REAL8 min;		REAL8 min;
	REAL8 max;		REAL8 max;
	}		}
	StatsREAL4VectorOut;		StatsREAL4VectorOut;
	/* </lalVerbatim> */
	/* <lalLaTeX>
	\vfill{\footnotesize\input{LALNoiseModelsHV}}
	</lalLaTeX> */
	/* Function prototypes */		/* Function prototypes */
	/* <lalLaTeX>
	\newpage\input{LALNoiseSpectralDensityC}
	</lalLaTeX> */
	void		void
	LALNoiseSpectralDensity		LALNoiseSpectralDensity
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8Vector *psd,		REAL8Vector *psd,
	void (*NoisePsd)(LALStatus *status, REAL8 *shf, REAL8 f ),		void (*NoisePsd)(LALStatus *status, REAL8 *shf, REAL8 f ),
	REAL8 f		REAL8 f
	);		);
	/* <lalLaTeX>
	\newpage\input{LALEGOPsdC}
	</lalLaTeX> */
	void		void
	LALEGOPsd		LALEGOPsd
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8 *shf,		REAL8 *shf,
	REAL8 x		REAL8 x
	);		);
	/* <lalLaTeX>
	\newpage\input{LALGEOPsdC}
	</lalLaTeX> */
	void		void
	LALGEOPsd		LALGEOPsd
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8 *shf,		REAL8 *shf,
	REAL8 x		REAL8 x
	);		);
	/* <lalLaTeX>
	\newpage\input{LALAdvLIGOPsdC}
	</lalLaTeX> */
	void		void
	LALAdvLIGOPsd		LALAdvLIGOPsd
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8 *shf,		REAL8 *shf,
	REAL8 x		REAL8 x
	);		);
	REAL8		REAL8
	XLALLIGOIPsd		XLALLIGOIPsd
	skipping to change at line 203		skipping to change at line 156
	);		);
	void		void
	LALLIGOIPsd		LALLIGOIPsd
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8 *shf,		REAL8 *shf,
	REAL8 x		REAL8 x
	);		);
	/* <lalLaTeX>
	\newpage\input{LALTAMAPsdC}
	</lalLaTeX> */
	void		void
	LALTAMAPsd		LALTAMAPsd
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8 *shf,		REAL8 *shf,
	REAL8 x		REAL8 x
	);		);
	/* <lalLaTeX>
	\newpage\input{LALVIRGOPsdC}
	</lalLaTeX> */
	void		void
	LALVIRGOPsd		LALVIRGOPsd
	(		(
	LALStatus *status,		LALStatus *status,
	REAL8 *shf,		REAL8 *shf,
	REAL8 x		REAL8 x
	);		);
	/* <lalLaTeX>
	\newpage\input{LALColoredNoiseC}
	</lalLaTeX> */
	void		void
	LALColoredNoise		LALColoredNoise
	(		(
	LALStatus *status,		LALStatus *status,
	REAL4Vector *noisy,		REAL4Vector *noisy,
	REAL8Vector psd		REAL8Vector psd
	);		);
	/* <lalLaTeX>
	\newpage\input{LALAddVectorsC}
	</lalLaTeX> */
	void		void
	LALAddVectors		LALAddVectors
	(		(
	LALStatus *status,		LALStatus *status,
	REAL4Vector *vector,		REAL4Vector *vector,
	AddVectorsIn in);		AddVectorsIn in);
	/* <lalLaTeX>
	\newpage\input{LALStatsREAL4VectorC}
	</lalLaTeX> */
	void		void
	LALStatsREAL4Vector		LALStatsREAL4Vector
	(		(
	LALStatus *status,		LALStatus *status,
	StatsREAL4VectorOut *out,		StatsREAL4VectorOut *out,
	REAL4Vector *vector		REAL4Vector *vector
	);		);
	/* <lalLaTeX>
	\newpage\input{NoisePSDTestC}
	</lalLaTeX> */
	REAL8 XLALETBPsd( REAL8 f );		REAL8 XLALETBPsd( REAL8 f );
			/*@}*/
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALNOISEMODELS_H */		#endif /* _LALNOISEMODELS_H */
End of changes. 26 change blocks.
	103 lines changed or deleted		36 lines changed or added

	LALRCSID.h		LALRCSID.h
	skipping to change at line 99		skipping to change at line 99
	</lalLaTeX> */		</lalLaTeX> */
	#ifndef _LALRCSID_H		#ifndef _LALRCSID_H
	#define _LALRCSID_H		#define _LALRCSID_H
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
			#ifdef SWIG
			/* exclude from SWIG interface */
			#define RCSID(id)
			#define NRCSID(name,id)
			#else /* !SWIG */
	#if !defined(lint)		#if !defined(lint)
	# ifndef __GNUC__		# ifndef __GNUC__
	# define RCSID(id) static volatile const char *rcsid = (id)		# define RCSID(id) static volatile const char *rcsid = (id)
	# define NRCSID(name,id) static volatile const char *name = (id)		# define NRCSID(name,id) static volatile const char *name = (id)
	# else		# else
	# define RCSID(id) \		# define RCSID(id) \
	static volatile const char __attribute__ ((unused)) *rcsid = (id)		static volatile const char __attribute__ ((unused)) *rcsid = (id)
	# define NRCSID(name,id) \		# define NRCSID(name,id) \
	static volatile const char __attribute__ ((unused)) *name = (id)		static volatile const char __attribute__ ((unused)) *name = (id)
	# endif /* !__GNUC__ */		# endif /* !__GNUC__ */
	#else		#else
	# define RCSID(id) typedef void useless		# define RCSID(id) typedef void useless
	# define NRCSID(name,id) typedef void useless		# define NRCSID(name,id) typedef void useless
	#endif /* !lint */		#endif /* !lint */
			#endif /* SWIG */
	NRCSID (LALRCSIDH, "$Id$");		NRCSID (LALRCSIDH, "$Id$");
	/* <lalLaTeX>		/* <lalLaTeX>
	\vfill{\footnotesize\input{LALRCSIDHV}}		\vfill{\footnotesize\input{LALRCSIDHV}}
	</lalLaTeX> */		</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
End of changes. 2 change blocks.
	0 lines changed or deleted		10 lines changed or added

	LALRunningMedian.h		LALRunningMedian.h
	skipping to change at line 45		skipping to change at line 45
	\end{verbatim}		\end{verbatim}
	\noindent This header covers routines to efficiently calculate the		\noindent This header covers routines to efficiently calculate the
	running median of REAL4 and REAL8 sequences		running median of REAL4 and REAL8 sequences
	</lalLaTeX> */		</lalLaTeX> */
	#ifndef _LALRUNNINGMEDIAN_H		#ifndef _LALRUNNINGMEDIAN_H
	#define _LALRUNNINGMEDIAN_H		#define _LALRUNNINGMEDIAN_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (LALRUNNINGMEDIANH, "$Id$");		NRCSID (LALRUNNINGMEDIANH, "$Id$");
	/* <lalLaTeX>		/* <lalLaTeX>
	skipping to change at line 111		skipping to change at line 116
	typedef struct tagLALRunningMedianPar		typedef struct tagLALRunningMedianPar
	{		{
	UINT4 blocksize;		UINT4 blocksize;
	}		}
	LALRunningMedianPar;		LALRunningMedianPar;
	\end{verbatim}		\end{verbatim}
	</lalLaTeX> */		</lalLaTeX> */
	typedef struct tagLALRunningMedianPar		typedef struct tagLALRunningMedianPar
	{		{
			SWIGLAL_STRUCT(LALRunningMedianPar);
	UINT4 blocksize;		UINT4 blocksize;
	}		}
	LALRunningMedianPar;		LALRunningMedianPar;
	/* Function prototypes. */		/* Function prototypes. */
	void		void
	LALDRunningMedian( LALStatus *status,		LALDRunningMedian( LALStatus *status,
	REAL8Sequence *medians,		REAL8Sequence *medians,
	const REAL8Sequence *input,		const REAL8Sequence *input,
End of changes. 2 change blocks.
	0 lines changed or deleted		6 lines changed or added

	LALStdlib.h		LALStdlib.h
	skipping to change at line 147		skipping to change at line 147
	\vfill{\footnotesize\input{LALStdlibHV}}		\vfill{\footnotesize\input{LALStdlibHV}}
	</lalLaTeX> */		</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (LALSTDLIBH, "$Id$");		NRCSID (LALSTDLIBH, "$Id$");
	/* These are non-ANSI standard routines that will be allowed in LAL */		/* These are non-ANSI standard routines that will be allowed in LAL */
			#ifndef SWIG /* exclude from SWIG interface */
	int getopt( int, char * const *, const char * );		int getopt( int, char * const *, const char * );
	FILE *popen( const char *, const char * );		FILE *popen( const char *, const char * );
	int pclose( FILE * );		int pclose( FILE * );
			#endif /* SWIG */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALSTDLIB_H */		#endif /* _LALSTDLIB_H */
End of changes. 2 change blocks.
	0 lines changed or deleted		2 lines changed or added

	LALVCSInfo.h		LALVCSInfo.h
	skipping to change at line 25		skipping to change at line 25
	* 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
	*		*
	* Copyright (C) 2009,2010 Adam Mercer		* Copyright (C) 2009,2010 Adam Mercer
	*/		*/
	#ifndef _LALVCSINFO_H		#ifndef _LALVCSINFO_H
	#define _LALVCSINFO_H		#define _LALVCSINFO_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#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 "326f3ba0f848ba2e31e93262a1360c62aaf6baf4"		#define LAL_VCS_ID "0bcd95daf135161d117d52234e6272297a12894a"
	#define LAL_VCS_DATE "2011-01-05 22:07:42 +0000"		#define LAL_VCS_DATE "2011-12-13 18:43:36 +0000"
	#define LAL_VCS_BRANCH "None"		#define LAL_VCS_BRANCH "None"
	#define LAL_VCS_TAG "lal_6_5_0_release"		#define LAL_VCS_TAG "lal-v6.6.0"
	#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: 326f3ba0f848ba2e31e93262a1360c62aaf6ba		#define LAL_VCS_IDENT_ID "$" "LALId: 0bcd95daf135161d117d52234e6272297a1289
	f4 " "$"		4a " "$"
	#define LAL_VCS_IDENT_DATE "$" "LALDate: 2011-01-05 22:07:42 +0000 " "$"		#define LAL_VCS_IDENT_DATE "$" "LALDate: 2011-12-13 18:43:36 +0000 " "$"
	#define LAL_VCS_IDENT_BRANCH "$" "LALBranch: None " "$"		#define LAL_VCS_IDENT_BRANCH "$" "LALBranch: None " "$"
	#define LAL_VCS_IDENT_TAG "$" "LALTag: lal_6_5_0_release " "$"		#define LAL_VCS_IDENT_TAG "$" "LALTag: lal-v6.6.0 " "$"
	#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 *lalVCSVersion;		extern const char *const lalVCSVersion;
	extern const char *lalVCSId;		extern const char *const lalVCSId;
	extern const char *lalVCSDate;		extern const char *const lalVCSDate;
	extern const char *lalVCSBranch;		extern const char *const lalVCSBranch;
	extern const char *lalVCSTag;		extern const char *const lalVCSTag;
	extern const char *lalVCSAuthor;		extern const char *const lalVCSAuthor;
	extern const char *lalVCSCommitter;		extern const char *const lalVCSCommitter;
	extern const char *lalVCSStatus;		extern const char *const lalVCSStatus;
	/* define vcs information structure */		/* define vcs information structure */
			#ifdef SWIG /* SWIG interface directives */
			%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagLALVCSInfo;
			#endif /* SWIG */
	typedef struct tagLALVCSInfo		typedef struct tagLALVCSInfo
	{		{
			SWIGLAL_STRUCT(LALVCSInfo);
	const char *name;		const char *name;
	const char *version;		const char *version;
	const char *vcsId;		const char *vcsId;
	const char *vcsDate;		const char *vcsDate;
	const char *vcsBranch;		const char *vcsBranch;
	const char *vcsTag;		const char *vcsTag;
	const char *vcsAuthor;		const char *vcsAuthor;
	const char *vcsCommitter;		const char *vcsCommitter;
	const char *vcsStatus;		const char *vcsStatus;
	} LALVCSInfo;		} LALVCSInfo;
End of changes. 8 change blocks.
	15 lines changed or deleted		24 lines changed or added

	LALVersion.h		LALVersion.h
	skipping to change at line 92		skipping to change at line 92
	#define LALVERSIONH_ESPRN 4		#define LALVERSIONH_ESPRN 4
	#define LALVERSIONH_ESHRT 8		#define LALVERSIONH_ESHRT 8
	#define LALVERSIONH_MSGENULL "Null string pointer."		#define LALVERSIONH_MSGENULL "Null string pointer."
	#define LALVERSIONH_MSGESIZE "Zero string size."		#define LALVERSIONH_MSGESIZE "Zero string size."
	#define LALVERSIONH_MSGESPRN "Error in snprintf."		#define LALVERSIONH_MSGESPRN "Error in snprintf."
	#define LALVERSIONH_MSGESHRT "String too short."		#define LALVERSIONH_MSGESHRT "String too short."
	/* </lalErrTable> */		/* </lalErrTable> */
	extern const char *lalVersion;		extern const char *const lalVersion;
	extern const int lalVersionMajor;		extern const int lalVersionMajor;
	extern const int lalVersionMinor;		extern const int lalVersionMinor;
	extern const int lalVersionMicro;		extern const int lalVersionMicro;
	extern const int lalVersionDevel;		extern const int lalVersionDevel;
	extern const char *lalBuildDate;		extern const char *const lalBuildDate;
	extern const char *lalConfigureArgs;		extern const char *const lalConfigureArgs;
	extern const char *lalConfigureDate;		extern const char *const lalConfigureDate;
	void		void
	LALVersion( LALStatus *status, CHAR *message, UINT4 size, INT4 verbose );		LALVersion( LALStatus *status, CHAR *message, UINT4 size, INT4 verbose );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _LALVERSION_H */		#endif /* _LALVERSION_H */
End of changes. 1 change blocks.
	8 lines changed or deleted		8 lines changed or added

	LogPrintf.h		LogPrintf.h
	skipping to change at line 41		skipping to change at line 41
	*/		*/
	#ifndef _LOGPRINTF_H /* Double-include protection. */		#ifndef _LOGPRINTF_H /* Double-include protection. */
	#define _LOGPRINTF_H		#define _LOGPRINTF_H
	/* C++ protection. */		/* C++ protection. */
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
			#include <lal/LALDatatypes.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	NRCSID( LOGPRINTFH, "$Id$" );		NRCSID( LOGPRINTFH, "$Id$" );
	/*---------- INCLUDES ----------*/		/*---------- INCLUDES ----------*/
	#include <stdarg.h>		#include <stdarg.h>
	#include <gsl/gsl_matrix.h>		#include <gsl/gsl_matrix.h>
	/*---------- DEFINES ----------*/		/*---------- DEFINES ----------*/
	/*---------- TYPES ----------*/		/*---------- TYPES ----------*/
	skipping to change at line 75		skipping to change at line 76
	void LogSetFile(FILE* file);		void LogSetFile(FILE* file);
	void LogSetLevel(LogLevel_t level);		void LogSetLevel(LogLevel_t level);
	void LogPrintf (LogLevel_t, const char* format, ...);		void LogPrintf (LogLevel_t, const char* format, ...);
	void LogPrintfVerbatim (LogLevel_t, const char* format, ...);		void LogPrintfVerbatim (LogLevel_t, const char* format, ...);
	int XLALfprintfGSLmatrix ( FILE *fp, const char *fmt, const gsl_matrix *gij );		int XLALfprintfGSLmatrix ( FILE *fp, const char *fmt, const gsl_matrix *gij );
	int XLALfprintfGSLvector ( FILE *fp, const char *fmt, const gsl_vector *vec t );		int XLALfprintfGSLvector ( FILE *fp, const char *fmt, const gsl_vector *vec t );
	int XLALfprintfGSLvector_int ( FILE *fp, const char *fmt, const gsl_vector_ int *vect );		int XLALfprintfGSLvector_int ( FILE *fp, const char *fmt, const gsl_vector_ int *vect );
			REAL8 XLALGetTimeOfDay(void);
	char * XLALClearLinebreaks ( const char *str );		char * XLALClearLinebreaks ( const char *str );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	/* C++ protection. */		/* C++ protection. */
	#endif /* Double-include protection. */		#endif /* Double-include protection. */
End of changes. 2 change blocks.
	0 lines changed or deleted		3 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
	*/		*/
	/******** <lalVerbatim file="MatrixHV"> ********		/**
	Author: Matthew M. Tibbits		* \author Matthew M. Tibbits
	$Id$		* \addtogroup Matrix_h
	********* </lalVerbatim> ********/
	/* <lalLaTeX>
	*
	* \section{Header \texttt{Matrix.h}}
	*		*
	* Matlab Routines to handle Matrices \& Vectors.		* \brief Matlab Routines to handle Matrices \& Vectors.
	*		*
	* \subsection*{Synopsis}		* \heading{Synopsis}
	* \begin{verbatim}		* \code
	* #include <lal/Matrix.h>		* #include <lal/Matrix.h>
	* \end{verbatim}		* \endcode
	*
	* \subsection*{Error conditions}
	* \input{MatrixHE}
	*		*
	* \vfill{\footnotesize\input{MatrixHV}}		* @{
	* \newpage\input{MatrixMultiplyC}		* \defgroup MatrixMultiply_c Module MatrixMultiply.c
	* \newpage\input{MatrixDivideC}		* \defgroup MatrixDivide_c Module MatrixDivide.c
	* \newpage\input{MatrixPowerC}		* \defgroup MatrixPower_c Module MatrixPower.c
	* \newpage\input{MiscMatlabC}		* \defgroup MiscMatlab_c Module MiscMatlab.c
	*		*
	* </lalLaTeX> */		*/
	#include <math.h>		#include <math.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/SeqFactories.h>		#include <lal/SeqFactories.h>
	#include <lal/AVFactories.h>		#include <lal/AVFactories.h>
	#ifndef __MATLAB_MATRIX_H__		#ifndef __MATLAB_MATRIX_H__
	#define __MATLAB_MATRIX_H__		#define __MATLAB_MATRIX_H__
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( MATLABMATRIXH, "$Id$");		/**\name Error Codes */ /*@{*/
			#define MATLABMATRIXH_EARG 1 /**< Error parsing command-line argu
			ments */
			#define MATLABMATRIXH_ECHK 2 /**< Error checking failed to catch
			bad data */
			#define MATLABMATRIXH_EFLS 3 /**< Incorrect answer for valid data
			*/
			#define MATLABMATRIXH_EUSE 4 /**< Bad user-entered data */
			#define MATLABMATRIXH_ENULL 5 /**< Null Pointer */
			#define MATLABMATRIXH_EALOC 6 /**< Memory Allocation Error */
			#define MATLABMATRIXH_EFPMS 7 /**< Filter Parameter Structure Erro
			r */
			#define MATLABMATRIXH_ENUMZ 8 /**< Incorrect number of command line argume
			nts */
			#define MATLABMATRIXH_ELNTH 9 /**< Vector/Array of Improper Length
			*/
			#define MATLABMATRIXH_ENNUL 10 /**< Non-Null Pointer that should be NULL */
			/** @} */
			/** @} */
	/**************************** <lalErrTable file="MatrixHE"> */
	#define MATLABMATRIXH_EARG 1
	#define MATLABMATRIXH_ECHK 2
	#define MATLABMATRIXH_EFLS 3
	#define MATLABMATRIXH_EUSE 4
	#define MATLABMATRIXH_ENULL 5
	#define MATLABMATRIXH_EALOC 6
	#define MATLABMATRIXH_EFPMS 7
	#define MATLABMATRIXH_ENUMZ 8
	#define MATLABMATRIXH_ELNTH 9
	#define MATLABMATRIXH_ENNUL 10
	#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"
	/***************************** </lalErrTable> */
	/* Multiply */		NRCSID( MATLABMATRIXH, "$Id$");
			/* Multiply */
			/** \addtogroup MatrixMultiply_c
			* @{
			*/
	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 508		skipping to change at line 504
	INT8Array *B		INT8Array *B
	);		);
	void LALI8ArrayDotStarI8Array (		void LALI8ArrayDotStarI8Array (
	LALStatus *status,		LALStatus *status,
	INT8Array **result,		INT8Array **result,
	INT8Array *A,		INT8Array *A,
	INT8Array *B		INT8Array *B
	);		);
			/** @} */
	/* Matrix Division */		/* Matrix Division */
			/** \addtogroup MatrixDivide_c
			* @{
			*/
	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,
	skipping to change at line 1140		skipping to change at line 1141
	INT8 B		INT8 B
	);		);
	void LALI8ArrayDotSlashI8Array (		void LALI8ArrayDotSlashI8Array (
	LALStatus *status,		LALStatus *status,
	INT8Array **result,		INT8Array **result,
	INT8Array *A,		INT8Array *A,
	INT8Array *B		INT8Array *B
	);		);
	/* Matrix Power */		/** @} */
			/* Matrix Power */
			/** \addtogroup MatrixPower_c
			* @{
			*/
	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 1771		skipping to change at line 1776
	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
	);		);
			/** @} */
	/* Miscellaneous Routines */		/* Miscellaneous Routines */
			/** \addtogroup MiscMatlab_c
			* @{
			*/
	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 1899		skipping to change at line 1907
	INT8Vector *data,		INT8Vector *data,
	INT4 *myindex		INT4 *myindex
	);		);
	void LALI8FlipVector (		void LALI8FlipVector (
	LALStatus *status,		LALStatus *status,
	INT8Vector **result,		INT8Vector **result,
	INT8Vector *data		INT8Vector *data
	);		);
			/** @} */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif /* C++ protection */		#endif /* C++ protection */
	#endif		#endif
End of changes. 18 change blocks.
	37 lines changed or deleted		53 lines changed or added

	MatrixUtils.h		MatrixUtils.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
	*/		*/
	/********************************** <lalVerbatim file="MatrixUtilsHV">		/**
	Author: Creighton, T. D.		\author Creighton, T. D.
	$Id$		\file
	**************************************************** </lalVerbatim> */
	/********************************************************** <lalLaTeX>
	\providecommand{\bd}{\mbox{\boldmath$\delta$\unboldmath}}
	\section{Header \texttt{MatrixUtils.h}}
	\label{s:MatrixUtils.h}
	Provides routines to solve linear systems.		\brief Provides routines to solve linear systems.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/MatrixUtils.h>		#include <lal/MatrixUtils.h>
	\end{verbatim}		\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
	Numerical Recipes~\cite{ptvf:1992}. The only routines at present are		Numerical Recipes~[\ref ptvf1992]. The only routines at present are
	for computing eigenvalues and eigenvectors of real symmetric matrices.		for computing eigenvalues and eigenvectors of real symmetric matrices.
	Routines for inverting or computing the determinant of arbitrary		Routines for inverting or computing the determinant of arbitrary
	square matrices will likely follow.		square matrices will likely follow.
	\subsubsection*{Notation}		\section TODOref Notation
	A \emph{matrix} is represented in LAL by a \verb@<datatype>Array@		A \e matrix is represented in LAL by a <tt>\<datatype\>Array</tt>
	structure with a \verb@dimLength->length@ field of 2; the		structure with a <tt>dimLength->length</tt> field of 2; the
	\verb@dimLength->data@ field gives the dimensions $[M,N]$ of the		<tt>dimLength->data</tt> field gives the dimensions \f$[M,N]\f$ of the
	matrix. Using the place-index notation common in tensor calculus, a		matrix. Using the place-index notation common in tensor calculus, a
	matrix is a two-index tensor:		matrix is a two-index tensor:
	\begin{equation}		\f{equation}{
	\mathsf{A}^a{}_b = \left[\begin{array}{cccc}		\mathsf{A}^a{}_b = \left[\begin{array}{cccc}
	A^1{}_1 & A^1{}_2 & \cdots & A^1{}_N \\		A^1{}_1 & A^1{}_2 & \cdots & A^1{}_N \\
	A^2{}_1 & A^2{}_2 & \cdots & A^2{}_N \\		A^2{}_1 & A^2{}_2 & \cdots & A^2{}_N \\
	\vdots & \vdots & \ddots & \vdots \\		\vdots & \vdots & \ddots & \vdots \\
	A^M{}_1 & A^M{}_2 & \cdots & A^M{}_N		A^M{}_1 & A^M{}_2 & \cdots & A^M{}_N
	\end{array}\right] \;,		\end{array}\right] \;,
	\end{equation}		\f}
	that is, the first (raised) index represents the row number and the		that is, the first (raised) index represents the row number and the
	second (lowered) index the column number. The standard C array		second (lowered) index the column number. The standard C array
	structure declares this object as, say, \verb@float a[M][N]@, where		structure declares this object as, say, <tt>float a[M][N]</tt>, where
	the element $A^i{}_j$ is stored in \verb@a[i][j]@. The LAL array		the element \f$A^i{}_j\f$ is stored in <tt>a[i][j]</tt>. The LAL array
	structure \verb@REAL4Array a@ stores data in a flattened block of		structure <tt>REAL4Array a</tt> stores data in a flattened block of
	memory, where the element $A^i{}_j$ is stored in \verb@a.data[i*M+j]@.		memory, where the element \f$A^i{}_j\f$ is stored in <tt>a.data[i*M+j]</tt>
			.
	A \emph{row vector} is a matrix with only one row ($M=1$). In the		A <em>row vector</em> is a matrix with only one row (\f$M=1\f$). In the
	above place-index notation, it is represented with a single lowered		above place-index notation, it is represented with a single lowered
	index:		index:
	\begin{equation}		\f{equation}{
	\mathsf{r}_a = \left[\begin{array}{cccc} r_1 & r_2 & \cdots & r_N		\mathsf{r}_a = \left[\begin{array}{cccc} r_1 & r_2 & \cdots & r_N
	\end{array}\right] \;.		\end{array}\right] \;.
	\end{equation}		\f}
	A \emph{column vector} is a matrix with only one column ($N=1$). In		A <em>column vector</em> is a matrix with only one column (\f$N=1\f$). In
	the above place-index notation, it is represented with a single raised		the above place-index notation, it is represented with a single raised
	index:		index:
	\begin{equation}		\f{equation}{
	\mathsf{c}^a = \left[\begin{array}{c} c^1 \\ c^2 \\ \vdots \\ c^M		\mathsf{c}^a = \left[\begin{array}{c} c^1 \\ c^2 \\ \vdots \\ c^M
	\end{array}\right] \;.		\end{array}\right] \;.
	\end{equation}		\f}
	In LAL, both of these objects are conventionally represented as a LAL		In LAL, both of these objects are conventionally represented as a LAL
	vector structure. Whether the object is to be used as a row or column		vector structure. Whether the object is to be used as a row or column
	vector must be determined from context; it is not specified by the		vector must be determined from context; it is not specified by the
	datatype.		datatype.
	\subsubsection*{Properties}		\section TODOref 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
	\emph{square} matrices:		\e square matrices:
	\textit{Inversion:} The inverse $(\mathsf{A}^{-1}){}^a{}_b$ of a		\e Inversion: The inverse \f$(\mathsf{A}^{-1}){}^a{}_b\f$ of a
	matrix $\mathsf{A}^a{}_b$ 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 $\bd^a{}_b$ (whose elements $\delta^i{}_j$ are just		identity matrix \f$\bd^a{}_b\f$ (whose elements \f$\delta^i{}_j\f$ are just
	the Kr\"onecker delta function).		the Kr\"onecker delta function).
	\textit{Transposition:} The transpose $(\mathsf{A}^T){}^a{}_b$ of a		\e Transposition: The transpose \f$(\mathsf{A}^T){}^a{}_b\f$ of a
	matrix $\mathsf{A}^a{}_b$ is given by interchanging the indecies on		matrix \f$\mathsf{A}^a{}_b\f$ is given by interchanging the indecies on
	each component: $(A^T){}^i{}_j=A^j{}_i$.		each component: \f$(A^T){}^i{}_j=A^j{}_i\f$.
	\textit{Conjugation:} The Hermitian conjugate (adjoint)		\e Conjugation: The Hermitian conjugate (adjoint)
	$(\mathsf{A}^\dag){}^a{}_b$ of a matrix $\mathsf{A}^a{}_b$ 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: $(A^\dag){}^i{}_j={A^j{}_i}^*$.		component: \f$(A^\dag){}^i{}_j={A^j{}_i}^*\f$.
	A matrix that is identical to its own transpose is called		A matrix that is identical to its own transpose is called
	\emph{symmetric}. A matrix whose transpose is identical to the		\e symmetric. A matrix whose transpose is identical to the
	original matrix's inverse is called \emph{orthogonal}. A matrix that		original matrix's inverse is called \e orthogonal. A matrix that
	is identical to its own Hermitian conjugate is called \emph{Hermitian}		is identical to its own Hermitian conjugate is called \e Hermitian
	(or \emph{self-adjoint}. 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 \emph{unitary}.		identical to the original matrix's inverse is called \e unitary.
	At present, the routines under this header only deal with \emph{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.
	%"		%"
	******************************************************* </lalLaTeX> */		*/
	#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
	NRCSID( MATRIXUTILSH, "$Id$" );		NRCSID( MATRIXUTILSH, "$Id$" );
	/********************************************************** <lalLaTeX>		/** \name Error Codes */ /*@{*/
	\subsection*{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */
	#define MATRIXUTILSH_ENUL 1		#define MATRIXUTILSH_ENUL 1
	#define MATRIXUTILSH_EDIM 2		#define MATRIXUTILSH_EDIM 2
	#define MATRIXUTILSH_EITER 3		#define MATRIXUTILSH_EITER 3
	#define MATRIXUTILSH_ESING 4		#define MATRIXUTILSH_ESING 4
	#define MATRIXUTILSH_EMEM 5		#define MATRIXUTILSH_EMEM 5
	#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"
	/*************************************************** </lalErrTable> */		/*@}*/
	/* <lalLaTeX>
	\vfill{\footnotesize\input{MatrixUtilsHV}}
	</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{MatrixOpsC}
	</lalLaTeX> */
	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 229		skipping to change at line 211
	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 );
	/* <lalLaTeX>
	\newpage\input{DetInverseC}
	</lalLaTeX> */
	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 );
	void		void
	LALDMatrixDeterminant( LALStatus *, REAL8 *det, REAL8Array *matrix );		LALDMatrixDeterminant( LALStatus *, REAL8 *det, REAL8Array *matrix );
	void		void
	LALDMatrixInverse( LALStatus *, REAL8 *det, REAL8Array *matrix, REAL8Array *inverse );		LALDMatrixInverse( LALStatus *, REAL8 *det, REAL8Array *matrix, REAL8Array *inverse );
	void		void
	LALDMatrixDeterminantErr( LALStatus *, REAL8 det[2], REAL8Array *matrix, RE AL8Array *matrixErr );		LALDMatrixDeterminantErr( LALStatus *, REAL8 det[2], REAL8Array *matrix, RE AL8Array *matrixErr );
	/* <lalLaTeX>
	\newpage\input{DetInverseInternalC}
	</lalLaTeX> */
	void		void
	LALSLUDecomp( LALStatus *,		LALSLUDecomp( LALStatus *,
	INT2 *sgn,		INT2 *sgn,
	REAL4Array *matrix,		REAL4Array *matrix,
	UINT4Vector *indx );		UINT4Vector *indx );
	void		void
	LALSLUBackSub( LALStatus *,		LALSLUBackSub( LALStatus *,
	REAL4Vector *vector,		REAL4Vector *vector,
	REAL4Array *matrix,		REAL4Array *matrix,
	skipping to change at line 277		skipping to change at line 253
	INT2 *sgn,		INT2 *sgn,
	REAL8Array *matrix,		REAL8Array *matrix,
	UINT4Vector *indx );		UINT4Vector *indx );
	void		void
	LALDLUBackSub( LALStatus *,		LALDLUBackSub( LALStatus *,
	REAL8Vector *vector,		REAL8Vector *vector,
	REAL8Array *matrix,		REAL8Array *matrix,
	UINT4Vector *indx );		UINT4Vector *indx );
	/* <lalLaTeX>
	\newpage\input{DetInverseTestC}
	</lalLaTeX> */
	/* <lalLaTeX>
	\newpage\input{EigenC}
	</lalLaTeX> */
	void		void
	LALSSymmetricEigenVectors( LALStatus *, REAL4Vector *values, REAL4Array *ma trix );		LALSSymmetricEigenVectors( LALStatus *, REAL4Vector *values, REAL4Array *ma trix );
	void		void
	LALSSymmetricEigenValues( LALStatus *, REAL4Vector *values, REAL4Array *mat rix );		LALSSymmetricEigenValues( LALStatus *, REAL4Vector *values, REAL4Array *mat rix );
	void		void
	LALDSymmetricEigenVectors( LALStatus *, REAL8Vector *values, REAL8Array *ma trix );		LALDSymmetricEigenVectors( LALStatus *, REAL8Vector *values, REAL8Array *ma trix );
	void		void
	LALDSymmetricEigenValues( LALStatus *, REAL8Vector *values, REAL8Array *mat rix );		LALDSymmetricEigenValues( LALStatus *, REAL8Vector *values, REAL8Array *mat rix );
	/* <lalLaTeX>
	\newpage\input{EigenInternalC}
	</lalLaTeX> */
	void		void
	LALSSymmetricToTriDiagonal( LALStatus *,		LALSSymmetricToTriDiagonal( LALStatus *,
	REAL4Vector *diag,		REAL4Vector *diag,
	REAL4Array *matrix,		REAL4Array *matrix,
	REAL4Vector *offDiag );		REAL4Vector *offDiag );
	void		void
	LALSSymmetricToTriDiagonal2( LALStatus *,		LALSSymmetricToTriDiagonal2( LALStatus *,
	REAL4Vector *diag,		REAL4Vector *diag,
	REAL4Array *matrix,		REAL4Array *matrix,
	skipping to change at line 347		skipping to change at line 313
	REAL8Vector *diag,		REAL8Vector *diag,
	REAL8Array *matrix,		REAL8Array *matrix,
	REAL8Vector *offDiag );		REAL8Vector *offDiag );
	void		void
	LALDTriDiagonalToDiagonal2( LALStatus *,		LALDTriDiagonalToDiagonal2( LALStatus *,
	REAL8Vector *diag,		REAL8Vector *diag,
	REAL8Array *matrix,		REAL8Array *matrix,
	REAL8Vector *offDiag );		REAL8Vector *offDiag );
	/* <lalLaTeX>
	\newpage\input{EigenTestC}
	</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _MATRIXUTILS_H */		#endif /* _MATRIXUTILS_H */
End of changes. 32 change blocks.
	82 lines changed or deleted		46 lines changed or added

	ODE.h		ODE.h
	skipping to change at line 47		skipping to change at line 47
	* \begin{displaymath}		* \begin{displaymath}
	* \dot{\mathbf{x}} = {\mathbf{f}}({\mathbf{x}},t,\ldots)		* \dot{\mathbf{x}} = {\mathbf{f}}({\mathbf{x}},t,\ldots)
	* \end{displaymath}		* \end{displaymath}
	* where $\mathbf{f}$ is a specified vector-valued function.		* where $\mathbf{f}$ is a specified vector-valued function.
	*		*
	**** </lalLaTeX> */		**** </lalLaTeX> */
	#ifndef _ODE_H		#ifndef _ODE_H
	#define _ODE_H		#define _ODE_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID( ODEH, "$Id$" );		NRCSID( ODEH, "$Id$" );
	/**** <lalLaTeX>		/**** <lalLaTeX>
	*		*
	* \subsection*{Error conditions}		* \subsection*{Error conditions}
	*		*
	**** </lalLaTeX> */		**** </lalLaTeX> */
	/**** <lalErrTable> */		/**** <lalErrTable> */
	skipping to change at line 85		skipping to change at line 91
	*		*
	* \subsection*{Structures}		* \subsection*{Structures}
	* \idx[Type]{REAL4ODEIndep}		* \idx[Type]{REAL4ODEIndep}
	* \idx[Type]{REAL4ODEParams}		* \idx[Type]{REAL4ODEParams}
	*		*
	**** </lalLaTeX> */		**** </lalLaTeX> */
	/**** <lalVerbatim> */		/**** <lalVerbatim> */
	typedef struct		typedef struct
	tagREAL4ODEIndep		tagREAL4ODEIndep
	{		{
			SWIGLAL_STRUCT(REAL4ODEIndep);
	REAL4 t;		REAL4 t;
	void *aux;		void *aux;
	}		}
	REAL4ODEIndep;		REAL4ODEIndep;
	/**** </lalVerbatim> */		/**** </lalVerbatim> */
	/**** <lalLaTeX>		/**** <lalLaTeX>
	*		*
	* The independent variables of the ODE (parameters to the ODE function).		* The independent variables of the ODE (parameters to the ODE function).
	* The fields are:		* The fields are:
	* \begin{description}		* \begin{description}
	* \item[\texttt{t}] The independent parameter (e.g., time) that is evolved .		* \item[\texttt{t}] The independent parameter (e.g., time) that is evolved .
	* \item[\texttt{aux}] Storage for auxiliary variables used internally in t he		* \item[\texttt{aux}] Storage for auxiliary variables used internally in t he
	* ODE routine.		* ODE routine.
	* \end{description}		* \end{description}
	*		*
	**** </lalLaTeX> */		**** </lalLaTeX> */
	/**** <lalVerbatim> */		/**** <lalVerbatim> */
	typedef struct		typedef struct
	tagREAL4ODEParams		tagREAL4ODEParams
	{		{
			SWIGLAL_STRUCT(REAL4ODEParams);
	void ( *ode )( LALStatus *, REAL4Vector *, REAL4Vector *, REAL4ODEIndep * );		void ( *ode )( LALStatus *, REAL4Vector *, REAL4Vector *, REAL4ODEIndep * );
	REAL4ODEIndep *indep;		REAL4ODEIndep *indep;
	REAL4 tstep;		REAL4 tstep;
	REAL4Vector *xdot;		REAL4Vector *xdot;
	REAL4Vector *xerr;		REAL4Vector *xerr;
	REAL4 eps;		REAL4 eps;
	REAL4VectorSequence *dx;		REAL4VectorSequence *dx;
	}		}
	REAL4ODEParams;		REAL4ODEParams;
	/**** </lalVerbatim> */		/**** </lalVerbatim> */
	skipping to change at line 157		skipping to change at line 165
	REAL4ODEParams *params		REAL4ODEParams *params
	);		);
	void LALSRungeKutta5Adapt(		void LALSRungeKutta5Adapt(
	LALStatus *status,		LALStatus *status,
	REAL4Vector *output,		REAL4Vector *output,
	REAL4Vector *input,		REAL4Vector *input,
	REAL4ODEParams *params		REAL4ODEParams *params
	);		);
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _ODE_H */		#endif /* _ODE_H */
End of changes. 6 change blocks.
	4 lines changed or deleted		13 lines changed or added

	PrintFTSeries.h		PrintFTSeries.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
	*/		*/
	/************************************ <lalVerbatim file="PrintFTSeriesHV">		/**
	Author: J. T. Whelan <jtwhelan@loyno.edu>		\author J. T. Whelan <jtwhelan@loyno.edu>
	$Id$		\file
	************************************* </lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{PrintFTSeries.h}}		\heading{Header \ref PrintFTSeries.h}
	\label{s:PrintFTSeries.h}		\latexonly\label{s_PrintFTSeries_h}\endlatexonly
	This is a simple utility to print time and frequency series into a		This is a simple utility to print time and frequency series into a
	file.		file.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/PrintFTSeries.h>		#include <lal/PrintFTSeries.h>
	\end{verbatim}		\endcode
	\noindent Provides prototype information for the routines in
	\verb+PrintTimeSeries.c+ and \verb+PrintFrequencySeries.c+.
	\vfill{\footnotesize\input{PrintFTSeriesHV}}		Provides prototype information for the routines in
	\newpage\input{PrintTimeSeriesC}		\ref PrintTimeSeries.c and \ref PrintFrequencySeries.c.
	\newpage\input{PrintFTSeriesTestC}
	\newpage\input{PrintFrequencySeriesC}
	</lalLaTeX> */		*/
	#ifndef _PRINTFTSERIES_H		#ifndef _PRINTFTSERIES_H
	#define _PRINTFTSERIES_H		#define _PRINTFTSERIES_H
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
End of changes. 6 change blocks.
	19 lines changed or deleted		11 lines changed or added

	PrintVector.h		PrintVector.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
	*/		*/
	/************************************ <lalVerbatim file="PrintVectorHV">		/**
	Author: Allen, B.; generalized by J. T. Whelan <jtwhelan@loyno.edu>		\author Allen, B.; generalized by J. T. Whelan <jtwhelan@loyno.edu>
	$Id$		\file
	************************************* </lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{PrintVector.h}}		\heading{Header \ref PrintVector.h}
	\label{s:PrintVector.h}		\latexonly\label{s_PrintVector_h}\endlatexonly
	This is a simple utility to print vectors into a file.		This is a simple utility to print vectors into a file.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/PrintVector.h>		#include <lal/PrintVector.h>
	\end{verbatim}		\endcode
	\noindent Contains the prototypes for the
	LAL$\langle\mbox{DT}\rangle$PrintVector functions
	\vfill{\footnotesize\input{PrintVectorHV}}		Contains the prototypes for the
	\newpage\input{PrintVectorC}		LAL\f$\langle\mbox{DT}\rangle\f$PrintVector functions
	\newpage\input{PrintVectorTestC}
	</lalLaTeX> */		*/
	#ifndef _PRINTVECTOR_H		#ifndef _PRINTVECTOR_H
	#define _PRINTVECTOR_H		#define _PRINTVECTOR_H
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#ifndef _LALSTDLIB_H		#ifndef _LALSTDLIB_H
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifndef _LALSTDLIB_H		#ifndef _LALSTDLIB_H
	#define _LALSTDLIB_H		#define _LALSTDLIB_H
End of changes. 6 change blocks.
	18 lines changed or deleted		11 lines changed or added

	Random.h		Random.h
	skipping to change at line 44		skipping to change at line 44
	* #include <lal/Random.h>		* #include <lal/Random.h>
	* \end{verbatim}		* \end{verbatim}
	*		*
	* \noindent This header covers the routines for generating random numbers.		* \noindent This header covers the routines for generating random numbers.
	*		*
	**** </lalLaTeX> */		**** </lalLaTeX> */
	#ifndef _RANDOM_H		#ifndef _RANDOM_H
	#define _RANDOM_H		#define _RANDOM_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#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
	NRCSID (RANDOMH, "$Id$");		NRCSID (RANDOMH, "$Id$");
	/**** <lalLaTeX>		/**** <lalLaTeX>
	skipping to change at line 109		skipping to change at line 114
	*		*
	* This structure contains the parameters necessary for generating the curr ent		* This structure contains the parameters necessary for generating the curr ent
	* sequence of Mersenne twiser random numbers (based on the initial seed). The		* sequence of Mersenne twiser random numbers (based on the initial seed). The
	* contents should not be manually adjusted.		* contents should not be manually adjusted.
	*		*
	**** </lalLaTeX> */		**** </lalLaTeX> */
	typedef struct		typedef struct
	tagRandomParams		tagRandomParams
	{		{
			SWIGLAL_STRUCT(RandomParams);
	INT4 i;		INT4 i;
	INT4 y;		INT4 y;
	INT4 v[32];		INT4 v[32];
	}		}
	RandomParams;		RandomParams;
	typedef struct tagMTRandomParams MTRandomParams;		typedef struct tagMTRandomParams MTRandomParams;
	/**** <lalLaTeX>		/**** <lalLaTeX>
	*		*
End of changes. 2 change blocks.
	0 lines changed or deleted		6 lines changed or added

	ReadFTSeries.h		ReadFTSeries.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
	*/		*/
	/************************************ <lalVerbatim file="ReadFTSeriesHV">		/**
	Author: Torres, C. W.		\author Torres, C. W.
	$Id$		\file
	************************************* </lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{ReadFTSeries.h}}		\heading{Header \ref ReadFTSeries.h}
	\label{s:ReadFTSeries.h}		\latexonly\label{s_ReadFTSeries_h}\endlatexonly
	This is a simple utility to Read time and frequency series into a		This is a simple utility to Read time and frequency series into a
	file.		file.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/ReadFTSeries.h>		#include <lal/ReadFTSeries.h>
	\end{verbatim}		\endcode
	\noindent Provides prototype information for the routines in
	\verb+ReadTimeSeries.c+ and \verb+ReadFrequencySeries.c+.
	\vfill{\footnotesize\input{ReadFTSeriesHV}}		Provides prototype information for the routines in
	\newpage\input{ReadFrequencySeriesC}		\ref ReadTimeSeries.c and \ref ReadFrequencySeries.c.
	\newpage\input{ReadTimeSeriesC}
	\newpage\input{ReadFTSeriesTestC}
	</lalLaTeX> */		*/
	#ifndef _READFTSERIES_H		#ifndef _READFTSERIES_H
	#define _READFTSERIES_H		#define _READFTSERIES_H
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	enum { LALSupportUnitTextSize = sizeof("10^-32768 m^-32768/32767 "		#ifndef SWIG /* exclude from SWIG interface */
	"kg^-32768/32767 "		enum enumLALSupportUnitTextSize {
	"s^-32768/32767 A^-32768/32767 "		LALSupportUnitTextSize = sizeof("10^-32768 m^-32768/32767 "
	"K^-32768/32767 strain^-32768/32767 "		"kg^-32768/32767 "
	"count^-32768/32767") };		"s^-32768/32767 A^-32768/32767 "
			"K^-32768/32767 strain^-32768/32767 "
	enum { MaxLineLength = LALSupportUnitTextSize + sizeof("Units are ()\n") };		"count^-32768/32767")
			};
			enum enumMaxLineLength {
			MaxLineLength = LALSupportUnitTextSize + sizeof("Units are ()\n")
			};
			#endif /* SWIG */
	NRCSID( READFTSERIESH, "$Id$" );		NRCSID( READFTSERIESH, "$Id$" );
	void LALReadTimeSeries(LALStatus* status, REAL4TimeSeries *series , const CHAR *filename );		void LALReadTimeSeries(LALStatus* status, REAL4TimeSeries *series , const CHAR *filename );
	void LALSReadTimeSeries(LALStatus* status, REAL4TimeSeries *series , const CHAR *filename );		void LALSReadTimeSeries(LALStatus* status, REAL4TimeSeries *series , const CHAR *filename );
	void LALDReadTimeSeries(LALStatus* status, REAL8TimeSeries *series , const CHAR *filename );		void LALDReadTimeSeries(LALStatus* status, REAL8TimeSeries *series , const CHAR *filename );
	void LALCReadTimeSeries(LALStatus* status, COMPLEX8TimeSeries *series , co nst CHAR *filename );		void LALCReadTimeSeries(LALStatus* status, COMPLEX8TimeSeries *series , co nst CHAR *filename );
	void LALZReadTimeSeries(LALStatus* status, COMPLEX16TimeSeries *series , c onst CHAR *filename );		void LALZReadTimeSeries(LALStatus* status, COMPLEX16TimeSeries *series , c onst CHAR *filename );
	void LALReadFrequencySeries(LALStatus* status, REAL4FrequencySeries *serie s , const CHAR *filename );		void LALReadFrequencySeries(LALStatus* status, REAL4FrequencySeries *serie s , const CHAR *filename );
	skipping to change at line 86		skipping to change at line 83
	void LALDReadFrequencySeries(LALStatus* status, REAL8FrequencySeries *seri es , const CHAR *filename );		void LALDReadFrequencySeries(LALStatus* status, REAL8FrequencySeries *seri es , const CHAR *filename );
	void LALCReadFrequencySeries(LALStatus* status, COMPLEX8FrequencySeries *se ries , const CHAR *filename );		void LALCReadFrequencySeries(LALStatus* status, COMPLEX8FrequencySeries *se ries , const CHAR *filename );
	void LALZReadFrequencySeries(LALStatus* status, COMPLEX16FrequencySeries * series , const CHAR *filename );		void LALZReadFrequencySeries(LALStatus* status, COMPLEX16FrequencySeries * series , const CHAR *filename );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _READSERIES_H */		#endif /* _READSERIES_H */
	/****************************** <lalErrTable file="ReadFTSeriesHE"> */		/**\name Error Codes */ /*@{*/
	#define READFTSERIESH_EFILENOTFOUND 1		#define READFTSERIESH_EFILENOTFOUND 1
	#define READFTSERIESH_EPARSE 2		#define READFTSERIESH_EPARSE 2
	#define READFTSERIESH_MSGEFILENOTFOUND "Invalid Filename or File Not Fo und"		#define READFTSERIESH_MSGEFILENOTFOUND "Invalid Filename or File Not Fo und"
	#define READFTSERIESH_MSGEPARSE "Error Parsing File"		#define READFTSERIESH_MSGEPARSE "Error Parsing File"
	/****************************** </lalErrTable> */		/*@}*/
End of changes. 9 change blocks.
	27 lines changed or deleted		24 lines changed or added

	ReadNoiseSpectrum.h		ReadNoiseSpectrum.h
	skipping to change at line 31		skipping to change at line 31
	*		*
	* File Name: ReadNoiseSpectrum.h		* File Name: ReadNoiseSpectrum.h
	*		*
	* Author: Brady, P. R.		* Author: Brady, P. R.
	*		*
	* Revision: $Id$		* Revision: $Id$
	*		*
	*-----------------------------------------------------------------------		*-----------------------------------------------------------------------
	*/		*/
	#if 0		/* <lalVerbatim file="ReadNoiseSpectrumHV">
	<lalVerbatim file="ReadNoiseSpectrumHV">
	Author: Brady, P. R.		Author: Brady, P. R.
	$Id$		$Id$
	</lalVerbatim>		</lalVerbatim>
	<lalLaTeX>		<lalLaTeX>
	\section{Header \texttt{ReadNoiseSpectrum.h}}		\section{Header \texttt{ReadNoiseSpectrum.h}}
	\label{s:ReadNoiseSpectrum.h}		\label{s:ReadNoiseSpectrum.h}
	Provides function to read in a file containing a possibly unequally sampled		Provides function to read in a file containing a possibly unequally sampled
	noise amplitude spectrum ($\textrm{strain}/\sqrt(\textrm{Hz})$) and return as		noise amplitude spectrum ($\textrm{strain}/\sqrt(\textrm{Hz})$) and return as
	a frequency series.		a frequency series.
	\subsection*{Synopsis}		\subsection*{Synopsis}
	\begin{verbatim}		\begin{verbatim}
	#include <lal/ReadNoiseSpectrum.h>		#include <lal/ReadNoiseSpectrum.h>
	\end{verbatim}		\end{verbatim}
	</lalLaTeX>		</lalLaTeX> */
	#endif
	#ifndef _READNOISESPECTRUMH_H		#ifndef _READNOISESPECTRUMH_H
	#define _READNOISESPECTRUMH_H		#define _READNOISESPECTRUMH_H
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/Date.h>		#include <lal/Date.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID (READNOISESPECTRUMH, "$Id$");		NRCSID (READNOISESPECTRUMH, "$Id$");
	/* <lalLaTeX>		/* <lalLaTeX>
	\newpage\subsection*{Error codes}		\newpage\subsection*{Error codes}
	</lalLaTeX> */		</lalLaTeX> */
	/* <lalErrTable> */		/* <lalErrTable> */
	#define LALREADNOISESPECTRUMH_ENULL 1		#define LALREADNOISESPECTRUMH_ENULL 1
	#define LALREADNOISESPECTRUMH_ENNUL 2		#define LALREADNOISESPECTRUMH_ENNUL 2
	skipping to change at line 92		skipping to change at line 91
	/* </lalErrTable> */		/* </lalErrTable> */
	#define LALREADNOISESPECTRUM_MAXLINELENGTH 2048		#define LALREADNOISESPECTRUM_MAXLINELENGTH 2048
	void LALReadNoiseSpectrum(		void LALReadNoiseSpectrum(
	LALStatus *status,		LALStatus *status,
	REAL4FrequencySeries *spectrum,		REAL4FrequencySeries *spectrum,
	CHAR *fname		CHAR *fname
	);		);
	#if 0		/* <lalLaTeX>
	<lalLaTeX>
	\vfill{\footnotesize\input{ReadNoiseSpectrumHV}}		\vfill{\footnotesize\input{ReadNoiseSpectrumHV}}
	\newpage\input{ReadNoiseSpectrumC}		\newpage\input{ReadNoiseSpectrumC}
	</lalLaTeX> */		</lalLaTeX> */
	#endif
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _READNOISESPECTRUMH_H */		#endif /* _READNOISESPECTRUMH_H */
End of changes. 7 change blocks.
	11 lines changed or deleted		9 lines changed or added

	RealFFT.h		RealFFT.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
	*/		*/
	/**** <lalVerbatim file="RealFFTHV">
	* $Id$
	**** </lalVerbatim> */
	/**** <lalLaTeX>
	*
	* \section{Header \texttt{RealFFT.h}}
	* \label{s:RealFFT.h}
	*
	* Performs real-to-complex and complex-to-real FFTs.
	*
	* \subsection*{Synopsis}
	* \begin{verbatim}
	* #include <lal/RealFFT.h>
	* \end{verbatim}
	*
	* \noindent Perform real-to-complex and complex-to-real fast Fourier
	* transforms of vectors, and sequences of vectors using the package
	* FFTW~\cite{fj:1998}.
	*
	**** </lalLaTeX> */
	#ifndef _REALFFT_H		#ifndef _REALFFT_H
	#define _REALFFT_H		#define _REALFFT_H
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID( REALFFTH, "$Id$" );		#ifdef __cplusplus
			#ifdef __GNUC__
	/**** <lalLaTeX>		#define RESTRICT __restrict__
	* \subsection*{Error conditions}		#else
	**** </lalLaTeX> */		#define RESTRICT
	/**** <lalErrTable> */		#endif
			#else
	#define REALFFTH_ENULL 1		#define RESTRICT restrict
	#define REALFFTH_ENNUL 2		#endif
	#define REALFFTH_ESIZE 4
	#define REALFFTH_ESZMM 8
	#define REALFFTH_ESLEN 16
	#define REALFFTH_ESAME 32
	#define REALFFTH_ESIGN 64
	#define REALFFTH_EDATA 128
	#define REALFFTH_EALOC 256
	#define REALFFTH_EFFTW 512
	#define REALFFTH_ESNGL 1024
	#define REALFFTH_EINTL 2048
	#define REALFFTH_MSGENULL "Null pointer"		NRCSID( REALFFTH, "$Id$" );
	#define REALFFTH_MSGENNUL "Non-null pointer"
	#define REALFFTH_MSGESIZE "Invalid input size"
	#define REALFFTH_MSGESZMM "Size mismatch"
	#define REALFFTH_MSGESLEN "Invalid/mismatched sequence lengths"
	#define REALFFTH_MSGESAME "Input/Output data vectors are the same"
	#define REALFFTH_MSGESIGN "Incorrect plan sign"
	#define REALFFTH_MSGEDATA "Bad input data: DC/Nyquist should be real"
	#define REALFFTH_MSGEALOC "Memory allocation failed"
	#define REALFFTH_MSGEFFTW "Error in FFTW"
	#define REALFFTH_MSGESNGL "FFTW library is not single-precision"
	#define REALFFTH_MSGEINTL "Error in Intel FFT library"
	/**** </lalErrTable> */
	/**** <lalLaTeX>
	*
	* \subsection*{Structures}
	*
	**** </lalLaTeX> */
	/**** <lalVerbatim> */
	/** Plan to perform FFT of REAL4 data */		/** Plan to perform FFT of REAL4 data */
	typedef struct tagREAL4FFTPlan REAL4FFTPlan;		typedef struct tagREAL4FFTPlan REAL4FFTPlan;
	/** Plan to perform FFT of REAL8 data */		/** Plan to perform FFT of REAL8 data */
	typedef struct tagREAL8FFTPlan REAL8FFTPlan;		typedef struct tagREAL8FFTPlan REAL8FFTPlan;
	#define tagRealFFTPlan tagREAL4FFTPlan		#define tagRealFFTPlan tagREAL4FFTPlan
	#define RealFFTPlan REAL4FFTPlan		#define RealFFTPlan REAL4FFTPlan
	/**** </lalVerbatim> */
	/**** <lalLaTeX>		/**
	*		*
	* This structure contains the parameters necessary for performing an FFT o		* \addtogroup RealFFT_h
	f a		* \brief Performs real-to-complex and complex-to-real FFTs.
	* given size and direction. The contents should not be manually adjusted.
	*		*
	* \newpage\input{RealFFTC}		* \heading{Synopsis}
			* \code
			* #include <lal/RealFFT.h>
			* \endcode
	*		*
	* \newpage\subsection{XLAL Functions}		* Perform real-to-complex and complex-to-real fast Fourier
			* transforms of vectors, and sequences of vectors using the package
			* FFTW [\ref fj_1998].
	*		*
	* \subsubsection*{Synopsis}		*
	* \begin{verbatim}		* \section sec_RealFFT_XLAL XLAL Functions
			*
			* \heading{Synopsis}
			* \code
	* #include <lal/RealFFT.h>		* #include <lal/RealFFT.h>
	*		*
	* REAL4FFTPlan * XLALCreateREAL4FFTPlan( UINT4 size, int fwdflg, int measu relvl );		* REAL4FFTPlan * XLALCreateREAL4FFTPlan( UINT4 size, int fwdflg, int measu relvl );
	* REAL4FFTPlan * XLALCreateForwardREAL4FFTPlan( UINT4 size, int measurelvl );		* REAL4FFTPlan * XLALCreateForwardREAL4FFTPlan( UINT4 size, int measurelvl );
	* REAL4FFTPlan * XLALCreateReverseREAL4FFTPlan( UINT4 size, int measurelvl );		* REAL4FFTPlan * XLALCreateReverseREAL4FFTPlan( UINT4 size, int measurelvl );
	* void XLALDestroyREAL4FFTPlan( REAL4FFTPlan *plan );		* void XLALDestroyREAL4FFTPlan( REAL4FFTPlan *plan );
	*		*
	* int XLALREAL4ForwardFFT( COMPLEX8Vector *output, REAL4Vector *input,		* int XLALREAL4ForwardFFT( COMPLEX8Vector *output, REAL4Vector *input, REA
	* REAL4FFTPlan *plan );		L4FFTPlan *plan );
	* int XLALREAL4ReverseFFT( REAL4Vector *output, COMPLEX8Vector *input,		* int XLALREAL4ReverseFFT( REAL4Vector *output, COMPLEX8Vector *input, REA
	* REAL4FFTPlan *plan );		L4FFTPlan *plan );
	* int XLALREAL4VectorFFT( REAL4Vector *output, REAL4Vector *input,		* int XLALREAL4VectorFFT( REAL4Vector *output, REAL4Vector *input, REAL4FF
	* REAL4FFTPlan *plan );		TPlan *plan );
	* int XLALREAL4PowerSpectrum( REAL4Vector *spec, REAL4Vector *data,		* int XLALREAL4PowerSpectrum( REAL4Vector *spec, REAL4Vector *data, REAL4F
	* REAL4FFTPlan *plan );		FTPlan *plan );
	*		*
	* REAL8FFTPlan * XLALCreateREAL8FFTPlan( UINT4 size, int fwdflg, int measu relvl );		* REAL8FFTPlan * XLALCreateREAL8FFTPlan( UINT4 size, int fwdflg, int measu relvl );
	* REAL8FFTPlan * XLALCreateForwardREAL8FFTPlan( UINT4 size, int measurelvl );		* REAL8FFTPlan * XLALCreateForwardREAL8FFTPlan( UINT4 size, int measurelvl );
	* REAL8FFTPlan * XLALCreateReverseREAL8FFTPlan( UINT4 size, int measurelvl );		* REAL8FFTPlan * XLALCreateReverseREAL8FFTPlan( UINT4 size, int measurelvl );
	* void XLALDestroyREAL8FFTPlan( REAL8FFTPlan *plan );		* void XLALDestroyREAL8FFTPlan( REAL8FFTPlan *plan );
	*		*
	* int XLALREAL8ForwardFFT( COMPLEX16Vector *output, REAL8Vector *input,		* int XLALREAL8ForwardFFT( COMPLEX16Vector *output, REAL8Vector *input, RE
	* REAL8FFTPlan *plan );		AL8FFTPlan *plan );
	* int XLALREAL8ReverseFFT( REAL8Vector *output, COMPLEX16Vector *input,		* int XLALREAL8ReverseFFT( REAL8Vector *output, COMPLEX16Vector *input, RE
	* REAL8FFTPlan *plan );		AL8FFTPlan *plan );
	* int XLALREAL8VectorFFT( REAL8Vector *output, REAL8Vector *input,		* int XLALREAL8VectorFFT( REAL8Vector *output, REAL8Vector *input, REAL8FF
	* REAL8FFTPlan *plan );		TPlan *plan );
	* int XLALREAL8PowerSpectrum( REAL8Vector *spec, REAL8Vector *data,		* int XLALREAL8PowerSpectrum( REAL8Vector *spec, REAL8Vector *data, REAL8F
	* REAL8FFTPlan *plan );		FTPlan *plan );
	* \end{verbatim}		* \endcode
	* \idx{XLALCreateREAL4FFTPlan}
	* \idx{XLALCreateForwardREAL4FFTPlan}
	* \idx{XLALCreateReverseREAL4FFTPlan}
	* \idx{XLALDestroyREAL4FFTPlan}
	* \idx{XLALREAL4ForwardFFT}
	* \idx{XLALREAL4ReverseFFT}
	* \idx{XLALREAL4VectorFFT}
	* \idx{XLALREAL4PowerSpectrum}
	* \idx{XLALCreateREAL8FFTPlan}
	* \idx{XLALCreateForwardREAL8FFTPlan}
	* \idx{XLALCreateReverseREAL8FFTPlan}
	* \idx{XLALDestroyREAL8FFTPlan}
	* \idx{XLALREAL8ForwardFFT}
	* \idx{XLALREAL8ReverseFFT}
	* \idx{XLALREAL8VectorFFT}
	* \idx{XLALREAL8PowerSpectrum}
	*		*
	* \subsubsection*{Description}		* \heading{Description}
	*		*
	* The \verb+REAL4+ routines are described below. These use single-precisi		* The \c REAL4 routines are described below. These use single-precision
	on		* FFTs, i.e., they convert \c REAL4Vectors into \c COMPLEX8Vectors
	* FFTs, i.e., they convert \verb+REAL4Vector+s into \verb+COMPLEX8Vector+s		* and vice-versa. The \c REAL8 versions of the routines are the same
	* and vice-versa. The \verb+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
	* \verb+REAL8Vector+s into \verb+COMPLEX16Vector+s.		* \c REAL8Vectors into \c COMPLEX16Vectors.
	*		*
	* The routine \verb+XLALCreateREAL4FFTPlan+ creates a \verb+REAL4FFTPlan+		* The routine XLALCreateREAL4FFTPlan() creates a ::REAL4FFTPlan
	* structure to perform FFTs of vectors of length \verb+size+. If		* structure to perform FFTs of vectors of length \c size. If
	* \verb+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 \verb+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 \verb+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.
	*		*
	* \verb+XLALCreateForwardREAL4FFTPlan+ is equivalent to		* XLALCreateForwardREAL4FFTPlan() is equivalent to
	* \verb+XLALCreateREAL4FFTPlan+ with \verb+fwdflg+ set to 1.		* XLALCreateREAL4FFTPlan() with \c fwdflg set to 1.
	* \verb+XLALCreateReverseREAL4FFTPlan+ is equivalent to		* XLALCreateReverseREAL4FFTPlan() is equivalent to
	* \verb+XLALCreateREAL4FFTPlan+ with \verb+fwdflg+ set to 0.		* XLALCreateREAL4FFTPlan() with \c fwdflg set to 0.
	*		*
	* \verb+XLALDestroyREAL4FFTPlan+ is used to destroy the plan, freeing all		* XLALDestroyREAL4FFTPlan() is used to destroy the plan, freeing all
	* memory that was allocated in the structure as well as the structure		* memory that was allocated in the structure as well as the structure
	* itself. It can be used on either forward or reverse plans.		* itself. It can be used on either forward or reverse plans.
	*		*
	* \verb+XLALREAL4ForwardFFT+ and		* XLALREAL4ForwardFFT() and
	* \verb+XLALREAL4ReverseFFT+ perform forward (real to complex) and		* XLALREAL4ReverseFFT() perform forward (real to complex) and
	* reverse (complex to real) transforms respectively. The plan supplied		* reverse (complex to real) transforms respectively. The plan supplied
	* to these routines must be correctly generated for the direction of the		* to these routines must be correctly generated for the direction of the
	* transform. I.e., \verb+XLALREAL4ForwardFFT+ cannot be supplied with		* transform. I.e., XLALREAL4ForwardFFT() cannot be supplied with
	* a plan generated by \verb+XLALCreateReverseREAL4FFTPlan+.		* a plan generated by XLALCreateReverseREAL4FFTPlan().
	*		*
	* \verb+XLALREAL4VectorFFT+ is a low-level routine that transforms		* XLALREAL4VectorFFT() is a low-level routine that transforms
	* a real vector to a half-complex real vector (with a forward plan) or		* a real vector to a half-complex real vector (with a forward plan) or
	* a half-complex real vector to a real vector (with a reverse plan).		* a half-complex real vector to a real vector (with a reverse plan).
	* If you're not sure what this means, don't use this routine.		* If you're not sure what this means, don't use this routine.
	* The input and output vectors (and their data) must be distinct pointers.		* The input and output vectors (and their data) must be distinct pointers.
	*		*
	* \verb+XLALREAL4PowerSpectrum+ computes a real power spectrum of the		* XLALREAL4PowerSpectrum() computes a real power spectrum of the
	* input real vector and a forward FFT plan.		* input real vector and a forward FFT plan.
	*		*
	* \subsubsection*{Return Values}		* \heading{Return Values}
	*		*
	* Upon success,		* Upon success,
	* \verb+XLALCreateREAL4FFTPlan+,		* XLALCreateREAL4FFTPlan(),
	* \verb+XLALCreateForwardREAL4FFTPlan+, and		* XLALCreateForwardREAL4FFTPlan(), and
	* \verb+XLALCreateReverseREAL4FFTPlan+ return a pointer to a newly-allocat		* XLALCreateReverseREAL4FFTPlan() return a pointer to a newly-allocated
	ed		* FFT plan. Upon failure, they return a \c NULL pointer and set
	* FFT plan. Upon failure, they return a \verb+NULL+ pointer and set		* \c xlalErrno to one of the following values:
	* \verb+xlalErrno+ to one of the following values:		* #XLAL_EBADLEN if \c size is not greater than zero,
	* \verb+XLAL_EBADLEN+ if \verb+size+ is not greater than zero,		* #XLAL_ENOMEM if a memory allocation failed, or
	* \verb+XLAL_ENOMEM+ if a memory allocation failed, or		* #XLAL_EFAILED if the FFTW plan creation routine failed.
	* \verb+XLAL_EFAILED+ if the FFTW plan creation routine failed.
	*		*
	* \verb+XLALDestroyREAL4FFTPlan+ does not return any value but, upon		* XLALDestroyREAL4FFTPlan() does not return any value but, upon
	* failure, it will set \verb+xlalErrno+ to one of the following values:		* failure, it will set \c xlalErrno to one of the following values:
	* \verb+XLAL_EFAULT+ if the routine is provided a \verb+NULL+ pointer, or		* #XLAL_EFAULT if the routine is provided a \c NULL pointer, or
	* \verb+XLAL_EINVAL+ if the contents of the plan are invalid (e.g., if the		* #XLAL_EINVAL if the contents of the plan are invalid (e.g., if the
	* routine is provided a plan that had been previously destroyed).		* routine is provided a plan that had been previously destroyed).
	*		*
	* \verb+XLALREAL4ForwardFFT+,		* XLALREAL4ForwardFFT(),
	* \verb+XLALREAL4ReverseFFT+,		* XLALREAL4ReverseFFT(),
	* \verb+XLALREAL4VectorFFT+, and		* XLALREAL4VectorFFT(), and
	* \verb+XLALREAL4PowerSpectrum+ return the value 0 upon succes; upon		* XLALREAL4PowerSpectrum() return the value 0 upon succes; upon
	* failure they return \verb+XLAL_FAILURE+ and set \verb+xlalErrno+ to		* failure they return #XLAL_FAILURE and set xlalErrno to
	* one of the following values:		* one of the following values:
	* \verb+XLAL_EFAULT+ if one of the input pointers is \verb+NULL+,		* #XLAL_EFAULT if one of the input pointers is \c NULL,
	* \verb+XLAL_EINVAL+ if the input, output, or plan structures appears		* #XLAL_EINVAL if the input, output, or plan structures appears
	* invalid or if the routine is passed a plan for the wrong transform		* invalid or if the routine is passed a plan for the wrong transform
	* directions or if the input and output data pointers are not distinct		* directions or if the input and output data pointers are not distinct
	* for \verb+XLALREAL4VectorFFT+,		* for XLALREAL4VectorFFT(),
	* \verb+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,
	* \verb+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 \verb+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.
	*		*
	* \newpage\input{RealFFTTestC}		*/
	**** </lalLaTeX> */		/*@{ */
			/** \name Error Codes */ /*@{*/
			#define REALFFTH_ENULL 1 /**< Null pointer */
			#define REALFFTH_ENNUL 2 /**< Non-null pointer */
			#define REALFFTH_ESIZE 4 /**< Invalid input size */
			#define REALFFTH_ESZMM 8 /**< Size mismatch */
			#define REALFFTH_ESLEN 16 /**< Invalid/mismatched sequence lengths */
			#define REALFFTH_ESAME 32 /**< Input/Output data vectors are the same
			*/
			#define REALFFTH_ESIGN 64 /**< Incorrect plan sign */
			#define REALFFTH_EDATA 128 /**< Bad input data: DC/Nyquist should be re
			al */
			#define REALFFTH_EALOC 256 /**< Memory allocation failed */
			#define REALFFTH_EFFTW 512 /**< Error in FFTW */
			#define REALFFTH_ESNGL 1024 /**< FFTW library is not single-precision */
			#define REALFFTH_EINTL 2048 /**< Error in Intel FFT library */
			/*@}*/
			/*@}*/
			#define REALFFTH_MSGENULL "Null pointer"
			#define REALFFTH_MSGENNUL "Non-null pointer"
			#define REALFFTH_MSGESIZE "Invalid input size"
			#define REALFFTH_MSGESZMM "Size mismatch"
			#define REALFFTH_MSGESLEN "Invalid/mismatched sequence lengths"
			#define REALFFTH_MSGESAME "Input/Output data vectors are the same"
			#define REALFFTH_MSGESIGN "Incorrect plan sign"
			#define REALFFTH_MSGEDATA "Bad input data: DC/Nyquist should be real"
			#define REALFFTH_MSGEALOC "Memory allocation failed"
			#define REALFFTH_MSGEFFTW "Error in FFTW"
			#define REALFFTH_MSGESNGL "FFTW library is not single-precision"
			#define REALFFTH_MSGEINTL "Error in Intel FFT library"
			/** \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 439		skipping to change at line 405
	* @par Errors:		* @par Errors:
	* The \c XLALREAL4VectorFFT() function shall fail if:		* The \c XLALREAL4VectorFFT() 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
	* reverse transform.		* reverse transform.
	* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are		* - [\c XLAL_EBADLEN] The input vector, output vector, and plan size are
	* incompatible.		* incompatible.
	* - [\c XLAL_ENOMEM] Insufficient storage space is available.		* - [\c XLAL_ENOMEM] Insufficient storage space is available.
	* .		* .
	*/		*/
	int XLALREAL4VectorFFT( REAL4Vector * restrict output, const REAL4Vector * restrict input,		int XLALREAL4VectorFFT( REAL4Vector * RESTRICT output, const REAL4Vector * RESTRICT input,
	const REAL4FFTPlan *plan );		const REAL4FFTPlan *plan );
	/** Computes the power spectrum of REAL4 data		/** Computes the power spectrum of REAL4 data
	*		*
	* This routine computes		* This routine computes
	* \f[P[k]=\left\{\begin{array}{ll}|z[0]|^2&k=0\\2|z[k]|^2&1\leq \lfloor (N +1)/2\rfloor\\|z[N/2]|^2&k=N/2,\;\mbox{$N$ even}\end{array}\right.\f]		* \f[P[k]=\left\{\begin{array}{ll}|z[0]|^2&k=0\\2|z[k]|^2&1\leq \lfloor (N +1)/2\rfloor\\|z[N/2]|^2&k=N/2,\;\mbox{$N$ even}\end{array}\right.\f]
	* where \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j],\f]		* where \f[z[k] = \sum_{j=0}^{N-1} e^{-2\pi ijk/N}\,x[j],\f]
	* and N is the length of the input vector x.		* and N is the length of the input vector x.
	*		*
	* @param[out] spec The real power spectrum P of length [N/2] + 1 of the da ta x		* @param[out] spec The real power spectrum P of length [N/2] + 1 of the da ta x
	skipping to change at line 697		skipping to change at line 663
	int XLALREAL8PowerSpectrum( REAL8Vector *spec, REAL8Vector *data,		int XLALREAL8PowerSpectrum( REAL8Vector *spec, REAL8Vector *data,
	const REAL8FFTPlan *plan );		const REAL8FFTPlan *plan );
	/*		/*
	*		*
	* LAL REAL4 functions		* LAL REAL4 functions
	*		*
	*/		*/
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateForwardREAL4FFTPlan instead.		* @deprecated Use XLALCreateForwardREAL4FFTPlan() instead.
	* @see XLALCreateForwardREAL4FFTPlan
	*/		*/
	void		void
	LALCreateForwardREAL4FFTPlan(		LALCreateForwardREAL4FFTPlan(
	LALStatus *status,		LALStatus *status,
	REAL4FFTPlan **plan,		REAL4FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateForwardREAL4FFTPlan instead.		* @deprecated Use XLALCreateForwardREAL4FFTPlan() instead.
	* @see XLALCreateForwardREAL4FFTPlan
	*/		*/
	#define LALCreateForwardRealFFTPlan LALCreateForwardREAL4FFTPlan		#define LALCreateForwardRealFFTPlan LALCreateForwardREAL4FFTPlan
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateReverseREAL4FFTPlan instead.		* @deprecated Use XLALCreateReverseREAL4FFTPlan() instead.
	* @see XLALCreateReverseREAL4FFTPlan
	*/		*/
	void		void
	LALCreateReverseREAL4FFTPlan(		LALCreateReverseREAL4FFTPlan(
	LALStatus *status,		LALStatus *status,
	REAL4FFTPlan **plan,		REAL4FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateReverseREAL4FFTPlan instead.		* @deprecated Use XLALCreateReverseREAL4FFTPlan() instead.
	* @see XLALCreateReverseREAL4FFTPlan
	*/		*/
	#define LALCreateReverseRealFFTPlan LALCreateReverseREAL4FFTPlan		#define LALCreateReverseRealFFTPlan LALCreateReverseREAL4FFTPlan
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALDestroyREAL4FFTPlan instead.		* @deprecated Use XLALDestroyREAL4FFTPlan() instead.
	* @see XLALDestroyREAL4FFTPlan
	*/		*/
	void		void
	LALDestroyREAL4FFTPlan(		LALDestroyREAL4FFTPlan(
	LALStatus *status,		LALStatus *status,
	REAL4FFTPlan **plan		REAL4FFTPlan **plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALDestroyREAL4FFTPlan instead.		* @deprecated Use XLALDestroyREAL4FFTPlan() instead.
	* @see XLALDestroyREAL4FFTPlan
	*/		*/
	#define LALDestroyRealFFTPlan LALDestroyREAL4FFTPlan		#define LALDestroyRealFFTPlan LALDestroyREAL4FFTPlan
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4ForwardFFT instead.		* @deprecated Use XLALREAL4ForwardFFT() instead.
	* @see XLALREAL4ForwardFFT
	*/		*/
	void		void
	LALForwardREAL4FFT(		LALForwardREAL4FFT(
	LALStatus *status,		LALStatus *status,
	COMPLEX8Vector *output,		COMPLEX8Vector *output,
	REAL4Vector *input,		REAL4Vector *input,
	REAL4FFTPlan *plan		REAL4FFTPlan *plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4ForwardFFT instead.		* @deprecated Use XLALREAL4ForwardFFT() instead.
	* @see XLALREAL4ForwardFFT
	*/		*/
	#define LALForwardRealFFT LALForwardREAL4FFT		#define LALForwardRealFFT LALForwardREAL4FFT
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4ReverseFFT instead.		* @deprecated Use XLALREAL4ReverseFFT() instead.
	* @see XLALREAL4ReverseFFT
	*/		*/
	void		void
	LALReverseREAL4FFT(		LALReverseREAL4FFT(
	LALStatus *status,		LALStatus *status,
	REAL4Vector *output,		REAL4Vector *output,
	COMPLEX8Vector *input,		COMPLEX8Vector *input,
	REAL4FFTPlan *plan		REAL4FFTPlan *plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4ReverseFFT instead.		* @deprecated Use XLALREAL4ReverseFFT() instead.
	* @see XLALREAL4ReverseFFT
	*/		*/
	#define LALReverseRealFFT LALReverseREAL4FFT		#define LALReverseRealFFT LALReverseREAL4FFT
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4PowerSpectrum instead.		* @deprecated Use XLALREAL4PowerSpectrum() instead.
	* @see XLALREAL4PowerSpectrum
	*/		*/
	void		void
	LALREAL4PowerSpectrum (		LALREAL4PowerSpectrum (
	LALStatus *status,		LALStatus *status,
	REAL4Vector *spec,		REAL4Vector *spec,
	REAL4Vector *data,		REAL4Vector *data,
	REAL4FFTPlan *plan		REAL4FFTPlan *plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4PowerSpectrum instead.		* @deprecated Use XLALREAL4PowerSpectrum() instead.
	* @see XLALREAL4PowerSpectrum
	*/		*/
	#define LALRealPowerSpectrum LALREAL4PowerSpectrum		#define LALRealPowerSpectrum LALREAL4PowerSpectrum
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL4VectorFFT instead.		* @deprecated Use XLALREAL4VectorFFT() instead.
	* @see XLALREAL4VectorFFT
	*/		*/
	void		void
	LALREAL4VectorFFT(		LALREAL4VectorFFT(
	LALStatus *status,		LALStatus *status,
	REAL4Vector *output,		REAL4Vector *output,
	REAL4Vector *input,		REAL4Vector *input,
	REAL4FFTPlan *plan		REAL4FFTPlan *plan
	);		);
	/*		/*
	*		*
	* LAL REAL8 functions		* LAL REAL8 functions
	*		*
	*/		*/
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateForwardREAL8FFTPlan instead.		* @deprecated Use XLALCreateForwardREAL8FFTPlan() instead.
	* @see XLALCreateForwardREAL8FFTPlan
	*/		*/
	void		void
	LALCreateForwardREAL8FFTPlan(		LALCreateForwardREAL8FFTPlan(
	LALStatus *status,		LALStatus *status,
	REAL8FFTPlan **plan,		REAL8FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALCreateReverseREAL8FFTPlan instead.		* @deprecated Use XLALCreateReverseREAL8FFTPlan() instead.
	* @see XLALCreateReverseREAL8FFTPlan
	*/		*/
	void		void
	LALCreateReverseREAL8FFTPlan(		LALCreateReverseREAL8FFTPlan(
	LALStatus *status,		LALStatus *status,
	REAL8FFTPlan **plan,		REAL8FFTPlan **plan,
	UINT4 size,		UINT4 size,
	INT4 measure		INT4 measure
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALDestroyREAL8FFTPlan instead.		* @deprecated Use XLALDestroyREAL8FFTPlan() instead.
	* @see XLALDestroyREAL8FFTPlan
	*/		*/
	void		void
	LALDestroyREAL8FFTPlan(		LALDestroyREAL8FFTPlan(
	LALStatus *status,		LALStatus *status,
	REAL8FFTPlan **plan		REAL8FFTPlan **plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL8ForwardFFT instead.		* @deprecated Use XLALREAL8ForwardFFT() instead.
	* @see XLALREAL8ForwardFFT
	*/		*/
	void		void
	LALForwardREAL8FFT(		LALForwardREAL8FFT(
	LALStatus *status,		LALStatus *status,
	COMPLEX16Vector *output,		COMPLEX16Vector *output,
	REAL8Vector *input,		REAL8Vector *input,
	REAL8FFTPlan *plan		REAL8FFTPlan *plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL8ReverseFFT instead.		* @deprecated Use XLALREAL8ReverseFFT() instead.
	* @see XLALREAL8ReverseFFT
	*/		*/
	void		void
	LALReverseREAL8FFT(		LALReverseREAL8FFT(
	LALStatus *status,		LALStatus *status,
	REAL8Vector *output,		REAL8Vector *output,
	COMPLEX16Vector *input,		COMPLEX16Vector *input,
	REAL8FFTPlan *plan		REAL8FFTPlan *plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL8PowerSpectrum instead.		* @deprecated Use XLALREAL8PowerSpectrum() instead.
	* @see XLALREAL8PowerSpectrum
	*/		*/
	void		void
	LALREAL8PowerSpectrum (		LALREAL8PowerSpectrum (
	LALStatus *status,		LALStatus *status,
	REAL8Vector *spec,		REAL8Vector *spec,
	REAL8Vector *data,		REAL8Vector *data,
	REAL8FFTPlan *plan		REAL8FFTPlan *plan
	);		);
	/** \b DEPRECATED		/** \b DEPRECATED
	* @deprecated Use XLALREAL8VectorFFT instead.		* @deprecated Use XLALREAL8VectorFFT() instead.
	* @see XLALREAL8VectorFFT
	*/		*/
	void		void
	LALREAL8VectorFFT(		LALREAL8VectorFFT(
	LALStatus *status,		LALStatus *status,
	REAL8Vector *output,		REAL8Vector *output,
	REAL8Vector *input,		REAL8Vector *input,
	REAL8FFTPlan *plan		REAL8FFTPlan *plan
	);		);
	#ifdef __cplusplus		/*@}*/
	#pragma {
			#undef RESTRICT
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _REALFFT_H */		#endif /* _REALFFT_H */
End of changes. 56 change blocks.
	196 lines changed or deleted		154 lines changed or added

	ResampleTimeSeries.h		ResampleTimeSeries.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
	*/		*/
	/**** <lalVerbatim file="ResampleTimeSeriesHV">
	* Author: Brown, D. A.
	* $Id$
	**** </lalVerbatim> */
	/**** <lalLaTeX>
	*
	* \section{Header \texttt{ResampleTimeSeries.h}}
	*
	* Provides routines to resample a time series. At present only integer
	* downsampling or \verb|REAL4TimeSeries| by a power of two is supported.
	*
	* \subsection*{Synopsis}
	* \begin{verbatim}
	* #include <lal/ResampleTimeSeries.h>
	* \end{verbatim}
	*
	* \noindent This header covers routines that resample time series by apply
	ing
	* a low pass filter and decimating the resulting time series. Further
	* documentation is given in the individual routines' modules.
	*
	**** </lalLaTeX> */
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/BandPassTimeSeries.h>		#include <lal/BandPassTimeSeries.h>
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#ifndef _RESAMPLETIMESERIES_H		#ifndef _RESAMPLETIMESERIES_H
	#define _RESAMPLETIMESERIES_H		#define _RESAMPLETIMESERIES_H
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID( RESAMPLETIMESERIESH, "$Id$" );		NRCSID( RESAMPLETIMESERIESH, "$Id$" );
	/**** <lalLaTeX>		/**
			* \author Brown, D. A.
			* \addtogroup ResampleTimeSeries_h Header ResampleTimeSeries.h
	*		*
	* \subsection*{Error conditions}		* \brief Provides routines to resample a time series.
	*		*
	**** </lalLaTeX> */		* At present only integer downsampling of ::REAL4TimeSeries by a power of
	/**** <lalErrTable> */		two is supported.
	#define RESAMPLETIMESERIESH_ENULL 1		*
	#define RESAMPLETIMESERIESH_ENNUL 2		* \heading{Synopsis}
	#define RESAMPLETIMESERIESH_EZERO 3		* \code
	#define RESAMPLETIMESERIESH_ERATE 4		* #include <lal/ResampleTimeSeries.h>
	#define RESAMPLETIMESERIESH_EUPSM 5		* \endcode
	#define RESAMPLETIMESERIESH_EHIGH 6		*
	#define RESAMPLETIMESERIESH_ELOG2 7		* This header covers routines that resample time series by applying
	#define RESAMPLETIMESERIESH_EFILT 8		* a low pass filter and decimating the resulting time series. Further
	#define RESAMPLETIMESERIESH_EINVD 9		* documentation is given in the individual routines' modules.
	#define RESAMPLETIMESERIESH_ELDAS 10		*
			*/
			/** @{ */
			/**\name Error Codes */ /*@{*/
			#define RESAMPLETIMESERIESH_ENULL 1 /**< Null pointer */
			#define RESAMPLETIMESERIESH_ENNUL 2 /**< Non-null pointer */
			#define RESAMPLETIMESERIESH_EZERO 3 /**< Length of input time series is
			zero */
			#define RESAMPLETIMESERIESH_ERATE 4 /**< Sample rate is zero */
			#define RESAMPLETIMESERIESH_EUPSM 5 /**< Cannot upsample */
			#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_EFILT 8 /**< Unknown filter type */
			#define RESAMPLETIMESERIESH_EINVD 9 /**< Invalid or non-integer resample
			factor */
			#define RESAMPLETIMESERIESH_ELDAS 10 /**< Input resample factor with LDAS
			FIR */
			/** @} */
			/** \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"
	#define RESAMPLETIMESERIESH_MSGEINVD "Invalid or non-integer resample facto r"		#define RESAMPLETIMESERIESH_MSGEINVD "Invalid or non-integer resample facto r"
	#define RESAMPLETIMESERIESH_MSGELDAS "Input resample factor with LDAS FIR"		#define RESAMPLETIMESERIESH_MSGELDAS "Input resample factor with LDAS FIR"
	/**** </lalErrTable> */		/** \endcond */
	/************************************************************* <lalLaTeX>
	\subsection*{Types}
	\idx[Type]{ResampleTSFilter}
	\idx[Type]{ResampleTSFilterParams}
	\idx[Type]{ResampleTSParams}
	\subsubsection*{Enum \texttt{ResampleTSFilter}}
	This enum type contains the different low pass filters available to
	prevent power above the new Nyquist frequency entering the resampled
	time series due to aliasing. The options are:
	\begin{description}
	\item[\texttt{defaultButterworth}] An IIR butterwoth filter of order 20
	with attenuation 0.1 at the new Nyquist frequency. See the package tdfilter
	s
	for documentation of butterworth filters in LAL.
	\item[\texttt{LDASfirLP}] For downsampling by a factor of 2, 4 or 8 an
	implementation of the FIR filter used by the LDAS datacondAPI resample().
	This is provided for testing the result of standalone codes and codes
	running under LDAS. The LDAS filter provided here has filter order paramete
	r
	10, so the order of the filter is $2 \times 10 \times q$ where $q$ is the
	resampling ratio.
	\end{description}
	\subsubsection*{Union \texttt{ResampleTSFilterParams}}
	This union is provided so that the code can store the parameters of the
	filter in a place accessible by the user for user designed low pass filters
	.
	This is not presently implemented and this structure may be ignored.
	\begin{description}
	\item[\texttt{butterworth}] A structure of type \verb|PassBandParamStruc| u
	sed
	to store the parameters of the butterworth filter used to perform low pass
	filtering.
	\item[\texttt{iirfilter}] A structure of type \verb|REAL8IIRFilter| used
	to store the parameters of the IIR or FIR filter used to perform low pass
	filtering.
	\end{description}
	\subsubsection*{Structure \texttt{tagResampleTimeSeriesParams}}
	This structure controls the behaviour of the resampling function.
	\begin{description}
	\item[\texttt{deltaT}] The sample interval desired in the down sampled time
	series.
	\item[\texttt{filterType}] The type of filter with which to perform the low
	pass filtering.
	\item[\texttt{filterParams}] Filter parameters for the low pass filter.
	Presently ignored.
	\end{description}
	************************************************************* </lalLaTeX> *
	/
			/** This enum type contains the different low pass filters available to
			* prevent power above the new Nyquist frequency entering the resampled
			* time series due to aliasing.
			*/
	typedef enum		typedef enum
	{		{
	defaultButterworth,		defaultButterworth, /**< An IIR butterwoth filter of order 20 with atten
	LDASfirLP		uation 0.1 at the new Nyquist frequency.
			* See the package tdfilters for documentation of b
			utterworth filters in LAL.
			*/
			LDASfirLP /**< For downsampling by a factor of 2, 4 or 8 an
			* implementation of the FIR filter used by the LDA
			S datacondAPI resample().
			* This is provided for testing the result of stand
			alone codes and codes
			* running under LDAS. The LDAS filter provided her
			e has filter order parameter
			* 10, so the order of the filter is \f$2 \times 10
			\times q\f$ where \f$q\f$ is the
			* resampling ratio.
			*/
	}		}
	ResampleTSFilter;		ResampleTSFilter;
			/** This union is provided so that the code can store the parameters of the
			* filter in a place accessible by the user for user designed low pass filt
			ers.
			* This is not presently implemented and this structure may be ignored.
			*/
	typedef union		typedef union
	tagResampleTimeSeriesFilterPars		tagResampleTSFilterParams
	{		{
	PassBandParamStruc butterworth;		PassBandParamStruc butterworth; /**< A structure of type \c PassBand
	REAL8IIRFilter iirfilter;		ParamStruc used to store the parameters
			* of the butterworth filter used t
			o perform low pass filtering
			*/
			REAL8IIRFilter iirfilter; /**< A structure of type \c REAL8IIR
			Filter used to store the parameters of
			* the IIR or FIR filter used to pe
			rform low pass filtering
			*/
	}		}
	ResampleTSFilterParams;		ResampleTSFilterParams;
			/** This structure controls the behaviour of the resampling function.
			*/
	typedef struct		typedef struct
	tagResampleTimeSeriesParams		tagResampleTSParams
	{		{
	REAL8 deltaT;		SWIGLAL_STRUCT(ResampleTSParams);
	ResampleTSFilter filterType;		REAL8 deltaT; /**< The sample interval desired in
	ResampleTSFilterParams filterParams;		the down sampled time series */
			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) */
	}		}
	ResampleTSParams;		ResampleTSParams;
	/**** <lalLaTeX>		/** @} */
	*
	* \vfill{\footnotesize\input{ResampleTimeSeriesHV}}
	* \newpage\input{ResampleTimeSeriesC}
	* \newpage\input{ResampleTimeSeriesTestC}
	*
	**** </lalLaTeX> */
	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
	);		);
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _RESAMPLETIMESERIES_H */		#endif /* _RESAMPLETIMESERIES_H */
End of changes. 19 change blocks.
	117 lines changed or deleted		96 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
	*/		*/
	/*----------------------------------- <lalVerbatim file="SegmentsHV">		/**
	* Author: Peter Shawhan		\author Peter Shawhan
	* Revision: $Id$		\defgroup Segments_h Segments
	*----------------------------------- </lalVerbatim> */		\ingroup tools
			\brief Provides data types and functions for manipulating lists of ``segmen
	#if 0		ts'' (GPS time intervals).
	\section{Header \texttt{Segments.h}}
	\label{s:Segments.h}
	Provides data types and functions for manipulating lists of ``segments''
	(GPS time intervals).
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/Segments.h>		#include <lal/Segments.h>
	\end{verbatim}		\endcode
	\noindent 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
	must be equal to or later than the start time. If the end time is equal to		must be equal to or later than the start time. If the end time is equal to
	the start time, then the segment represents a point in time. If the end ti me		the start time, then the segment represents a point in time. If the end ti me
	is later than the start time, then the segment represents a half-open time		is later than the start time, then the segment represents a half-open time
	interval, inclusive of its starting point and exclusive of its ending point .		interval, inclusive of its starting point and exclusive of its ending point .
	All of the segment list manipulation functions are XLAL functions.		All of the segment list manipulation functions are XLAL functions.
	They handle error conditions by invoking the current XLAL error handler		They handle error conditions by invoking the current XLAL error handler
	and setting \texttt{xlalErrno} to a nonzero value.		and setting \c xlalErrno to a nonzero value.
	\subsection*{Error conditions}
	\begin{center}		\heading{Error conditions}
	\begin{tabular}{|cp{5.0in}|} \hline
	\texttt{xlalErrno} & description \\ \hline
	\tt XLAL\_EFAULT & Null pointer passed for some argument \\
	\tt XLAL\_EINVAL & Attempted to use an uninitialized segment list structu
	re \\
	\tt XLAL\_EDOM & Pair of GPS times does not represent a valid segment \
	\
	\hline
	\end{tabular}
	\end{center}
	\subsection*{Structures}		<table><tr><th>xlalErrno</th><th>description</th></tr>
	\idx[Type]{LALSeg}		<tr><td> XLAL_EFAULT</td><td>Null pointer passed for some argument</td></
	\idx[Type]{LALSegList}		tr>
	\input{SegmentsHS}		<tr><td> XLAL_EINVAL</td><td>Attempted to use an uninitialized segment li
			st structure</td></tr>
			<tr><td> XLAL_EDOM</td><td>Pair of GPS times does not represent a valid s
			egment</td></tr>
			</table>
	\subsection*{Notes}		\heading{Notes}
	A \texttt{LALSegList} must be initialized before it is used. Initializatio		A \c LALSegList must be initialized before it is used. Initialization
	n		leaves it in an ``empty'' state, containing no segments. They also must be
	leaves it in an ``empty'' state, containing no segments. They also must be		''cleared''
	''cleared'' after using \texttt{XLALSegListClear}, and freed with \texttt{L		after using \c XLALSegListClear(), and freed with \c LALFree() if it was dy
	ALFree} if it was dynamically allocated. Segments can then		namically allocated.
	be added to the list through an ``append'' operation. The information abou		Segments can then be added to the list through an ``append'' operation. Th
	t		e information about
	each segment appended is copied to a memory location managed by the		each segment appended is copied to a memory location managed by the
	\texttt{LALSegList} object. In fact, the segments are stored in the form o		\c LALSegList object. In fact, the segments are stored in the form of
	f		an array of \c LALSeg structures, with the \c segs field of
	an array of \texttt{LALSeg} structures, with the \texttt{segs} field of
	the segment list structure being the base address of the array.		the segment list structure being the base address of the array.
	This allows the segments to be accessed directly using a pointer as an		This allows the segments to be accessed directly using a pointer as an
	iterator, as in the following example code:		iterator, as in the following example code:
	%
	\begin{verbatim}		\code
	LALSegList mylist;		LALSegList mylist;
	LALSeg *segp;		LALSeg *segp;
	...		...
	/* (Append segments to the segment list 'mylist' here) */		/\* (Append segments to the segment list 'mylist' here) *\/
	...		...
	for ( segp=mylist.segs; segp<mylist.segs+mylist.length; segp++ ) {		for ( segp=mylist.segs; segp<mylist.segs+mylist.length; segp++ ) {
	printf( "The end time of the segment is GPS %d.%09d\n",		printf( "The end time of the segment is GPS %d.%09d\n", segp->end.gpsSe
	segp->end.gpsSeconds, segp->end.gpsNanoSeconds );		conds, segp->end.gpsNanoSeconds );
	}		}
	\end{verbatim}		\endcode
	%
	\ldots or by using an integer array index, as in the following example code		... or by using an integer array index, as in the following example code:
	:
	%		\code
	\begin{verbatim}
	LALSegList mylist;		LALSegList mylist;
	LALSeg *segp;		LALSeg *segp;
	INT4 iseg;		INT4 iseg;
	LIGOTimeGPS startgps;		LIGOTimeGPS startgps;
	...		...
	/* (Append segments to the segment list 'mylist' here) */		/\* (Append segments to the segment list 'mylist' here) *\/
	...		...
	for ( iseg=0; iseg<mylist.length; iseg++ ) {		for ( iseg=0; iseg<mylist.length; iseg++ ) {
	/* One way to access the segment... */		/\* One way to access the segment... *\/
	startgps = mylist.segs[iseg].start;		startgps = mylist.segs[iseg].start;
	printf( "The start time of the segment is GPS %d.%09d\n",		printf( "The start time of the segment is GPS %d.%09d\n", startgps.gpsS
	startgps.gpsSeconds, startgps.gpsNanoSeconds );		econds, startgps.gpsNanoSeconds );
	/* Another way to access the segment... */		/\* Another way to access the segment... *\/
	segp = mylist.segs + iseg;		segp = mylist.segs + iseg;
	printf( "The end time of the segment is GPS %d.%09d\n",		printf( "The end time of the segment is GPS %d.%09d\n", segp->end.gpsSe
	segp->end.gpsSeconds, segp->end.gpsNanoSeconds );		conds, segp->end.gpsNanoSeconds );
	}		}
	\end{verbatim}		\endcode
	Note that if the segment list is empty, then the \texttt{segs} field will		Note that if the segment list is empty, then the \c segs field will
	be NULL and the \texttt{length} field will be $0$. So be careful not to		be NULL and the \c length field will be \f$0\f$. So be careful not to
	dereference the \texttt{segs} pointer unless you know that the length is		dereference the \c segs pointer unless you know that the length is
	nonzero.		nonzero.
	A segment list is considered ``sorted'' if the segments are in ascending		A segment list is considered ``sorted'' if the segments are in ascending
	(or at least non-descending) order according to the comparison done by		(or at least non-descending) order according to the comparison done by
	the \texttt{XLALSegCmp} function. A segment list is considered ``disjoint' '		the \c XLALSegCmp() function. A segment list is considered ``disjoint''
	if no two segments in the list overlap, although they		if no two segments in the list overlap, although they
	may touch at an endpoint due to the half-open nature of the time intervals		may touch at an endpoint due to the half-open nature of the time intervals
	represented by segments. The \texttt{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 \texttt{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 \emph{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 \texttt{XLALS egListShift}.		Also all segments in a segment list can be time-shifted using \c XLALSegLis tShift().
	\vfill{\footnotesize\input{SegmentsHV}}		*/
	\newpage\input{SegmentsC}
	#endif
	#ifndef _SEGMENTS_H		#ifndef _SEGMENTS_H
	#define _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/LALDatatypes.h>
	#include <lal/XLALError.h>		#include <lal/XLALError.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
			/** \cond DONT_DOXYGEN */
	NRCSID( SEGMENTSH, "$Id$" );		NRCSID( SEGMENTSH, "$Id$" );
			/** \endcond */
	/*------------------- 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
	* 'initMagic' field to provide a		* 'initMagic' field to provide a
	* check that the structure was		* check that the structure was
	* properly initialized. */		* properly initialized. */
	/*------------------- Data structure definitions -------------------*/		/*------------------- Data structure definitions -------------------*/
	/* <lalVerbatim file="SegmentsHS"> */		/** Struct holding a single segment */
	typedef struct		typedef struct
	tagLALSeg		tagLALSeg
	{		{
			SWIGLAL_STRUCT(LALSeg);
	LIGOTimeGPS start; /**< Beginning time of the segment */		LIGOTimeGPS start; /**< Beginning time of the segment */
	LIGOTimeGPS end; /**< Ending time of the segment */		LIGOTimeGPS end; /**< Ending time of the segment */
	INT4 id; /**< Identifier (segment ID, array index, etc.) for us er */		INT4 id; /**< Identifier (segment ID, array index, etc.) for us er */
	}		}
	LALSeg;		LALSeg;
	/* </lalVerbatim> */
	/* <lalVerbatim file="SegmentsHS"> */		/** Struct holding a segment list */
	typedef struct		typedef struct
	tagLALSegList		tagLALSegList
	{		{
			SWIGLAL_STRUCT(LALSegList);
	LALSeg *segs; /**< Pointer to array of segments (LALSeg structures) */		LALSeg *segs; /**< Pointer to array of segments (LALSeg structures) */
	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;
	/* </lalVerbatim> */
			/*@}*/
	/*----------------------- 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
	skipping to change at line 241		skipping to change at line 231
	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 ----------------------------*/		/*----------------------- Trailer stuff ----------------------------*/
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif /* C++ protection. */		#endif /* C++ protection. */
	#endif /* Double-include protection. */		#endif /* Double-include protection. */
End of changes. 41 change blocks.
	83 lines changed or deleted		79 lines changed or added

	SeqFactories.h		SeqFactories.h
	/*-----------------------------------------------------------------------		/**
			\defgroup SeqFactories_h SeqFactories_h
			\ingroup factories
	File Name: SeqFactories.h		\brief Provides prototype and status code information for use of CreateVect
			orSequence
			and DestroyVectorSequence.
	<lalVerbatim file="SeqFactoriesHV">		\heading{Synopsis}
	Revision: $Id$		\code
	</lalVerbatim>		#include <lal/SeqFactories.h>
			\endcode
			\section sec_SF_XLALfcts XLAL Functions
	/* <lalLaTeX>		\code
			REAL4VectorSequence * XLALCreateVectorSequence(UINT4 length, UINT4 veclen);
			void XLALCreateVectorSequence(REAL4VectorSequence *vecseq);
	\section{Header \texttt{SeqFactories.h}}		<vecseqtype> * XLALCreate<vecseqtype>(UINT4 length, UINT4 veclen);
	\label{s:SeqFactories.h}		void XLALCreate<vecseqtype>(<vecseqtype> *vecseq);
			\endcode
	Provides prototype and status code information for use of CreateVectorSeque		Here <tt>\<vecseqtype\></tt> is one of
	nce		\c COMPLEX16VectorSequence,
	and DestroyVectorSequence.		\c COMPLEX8VectorSequence,
			\c REAL8VectorSequence,
			\c REAL4VectorSequence,
			\c INT8VectorSequence,
			\c INT4VectorSequence,
			\c INT2VectorSequence,
			\c UINT8VectorSequence,
			\c UINT4VectorSequence,
			\c UINT2VectorSequence, or
			\c CHARVectorSequence.
	\subsection*{Synopsis}		\subsection ss_SF_desc Description
	\begin{verbatim}
	#include <lal/SeqFactories.h>
	\end{verbatim}
	</lalLaTeX> */		The <tt>XLALCreate\<type\>VectorSequence</tt> functions create vector seque
			nces
			of type <tt>\<type\></tt>, length and vector length \c veclen.
			The function \c XLALCreateVectorSequence is the same as
			\c XLALCreateREAL4VectorSequence.
			The <tt>XLALDestroy\<type\>VectorSequence</tt> functions deallocate the mem
			ory
			allocation pointed to by \c vecseq including its contents. The function
			\c XLALDestroyVectorSequence is the same as
			\c XLALDestroyREAL4VectorSequence.
			\subsection ss_SF_ret Return Values
			The create functions return a pointer to the created vector sequence if
			successful; upon failure they will return \c NULL and set \c xlalErrno
			to one of the following values: \c #XLAL_ENOMEM if memory allocation
			failed, or \c #XLAL_EBADLEN if the requested \c length or \c veclen
			is zero.
			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
			\c #XLAL_EFAULT, or if the vector sequency passed to the destroy routine
			has zero length, vector length, or \c NULL data pointer then
			\c xlalErrno is set to \c #XLAL_EINVAL.
			*/
	#ifndef _SEQFACTORIES_H		#ifndef _SEQFACTORIES_H
	#define _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/LALDatatypes.h>
	#include <lal/AVFactories.h>		#include <lal/AVFactories.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (SEQFACTORIESH, "$Id$");		NRCSID (SEQFACTORIESH, "$Id$");
	/* <lalLaTeX>		/**\name Error Codes *//*@{*/
			/** \ingroup SeqFactories_h */
	\subsection*{Error conditions}
	\input{SeqFactoriesHErrTab}
	</lalLaTeX> */
	/*
	<lalErrTable file="SeqFactoriesHErrTab">
	*/
	#define SEQFACTORIESH_ESLENGTH 1		#define SEQFACTORIESH_ESLENGTH 1
	#define SEQFACTORIESH_EVLENGTH 2		#define SEQFACTORIESH_EVLENGTH 2
	#define SEQFACTORIESH_EALENGTH 4		#define SEQFACTORIESH_EALENGTH 4
	#define SEQFACTORIESH_EVPTR 8		#define SEQFACTORIESH_EVPTR 8
	#define SEQFACTORIESH_EUPTR 16		#define SEQFACTORIESH_EUPTR 16
	#define SEQFACTORIESH_EDPTR 32		#define SEQFACTORIESH_EDPTR 32
	#define SEQFACTORIESH_EINPTR 64		#define SEQFACTORIESH_EINPTR 64
	#define SEQFACTORIESH_EMALLOC 128		#define SEQFACTORIESH_EMALLOC 128
	#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."
			/*@}*/
	/*		/** \ingroup SeqFactories_h
	</lalErrTable>		* \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
	/* Structures. */		* vectors) and the length of each vector.
	/* <lalLaTeX>		*/
	\subsection*{Structures}
	\begin{verbatim}
	CreateVectorSequenceIn
	\end{verbatim}
	\idx[Type]{CreateVectorSequenceIn}
	\noindent This structure stores the input required for creating a vector
	sequence. This input includes the length of the sequence (i.e., the number
	of
	vectors) and the length of each vector. The fields are:
	\begin{description}
	\item[\texttt{UINT4 length}] The sequence length.
	\item[\texttt{UINT4 vectorLength}] The length of each vector in the sequenc
	e.
	\end{description}
	</lalLaTeX> */
	typedef struct tagCreateVectorSequenceIn {		typedef struct tagCreateVectorSequenceIn {
	UINT4 length;		SWIGLAL_STRUCT(CreateVectorSequenceIn);
	UINT4 vectorLength;		UINT4 length; /**< The sequence length */
			UINT4 vectorLength; /**< The length of each vector in the sequence */
	} CreateVectorSequenceIn;		} CreateVectorSequenceIn;
	/* <lalLaTeX>		/** \ingroup SeqFactories_h
			* \brief This structure stores the input required for creating an array
	\begin{verbatim}		* sequence. This input includes the length of the sequence (i.e., the num
	CreateArraySequenceIn		ber of
	\end{verbatim}		* array) and the dimensions of each array index.
	\idx[Type]{CreateArraySequenceIn}		*/
	\noindent This structure stores the input required for creating an array
	sequence. This input includes the length of the sequence (i.e., the number
	of
	array) and the dimensions of each array index. The fields are:
	\begin{description}
	\item[\texttt{UINT4 length}] The sequence length.
	\item[\texttt{UINT4Vector *dimLength}] The dimensions of each array
	index (the same for every array in the sequence).
	\end{description}
	</lalLaTeX> */
	typedef struct tagCreateArraySequenceIn {		typedef struct tagCreateArraySequenceIn {
	UINT4 length;		SWIGLAL_STRUCT(CreateArraySequenceIn);
	UINT4Vector *dimLength;		UINT4 length; /**< The sequence length */
			UINT4Vector *dimLength; /**< The dimensions of each array index (the
			same for every array in the sequence) */
	} CreateArraySequenceIn;		} CreateArraySequenceIn;
	/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{VectorSequenceFactoriesC}
	\newpage
	\subsection{XLAL Functions}
	\subsubsection*{Synopsis}
	\begin{verbatim}
	REAL4VectorSequence * XLALCreateVectorSequence(UINT4 length, UINT4 veclen);
	void XLALCreateVectorSequence(REAL4VectorSequence *vecseq);
	<vecseqtype> * XLALCreate<vecseqtype>(UINT4 length, UINT4 veclen);
	void XLALCreate<vecseqtype>(<vecseqtype> *vecseq);
	\end{verbatim}
	\idx{XLALCreateREAL4VectorSequence}
	\idx{XLALDestroyREAL4VectorSequence}
	\idx{XLALCreate<type>VectorSequence}
	\idx{XLALDestroy<type>VectorSequence}
	Here \verb+<vecseqtype>+ is one of
	\verb+COMPLEX16VectorSequence+,
	\verb+COMPLEX8VectorSequence+,
	\verb+REAL8VectorSequence+,
	\verb+REAL4VectorSequence+,
	\verb+INT8VectorSequence+,
	\verb+INT4VectorSequence+,
	\verb+INT2VectorSequence+,
	\verb+UINT8VectorSequence+,
	\verb+UINT4VectorSequence+,
	\verb+UINT2VectorSequence+, or
	\verb+CHARVectorSequence+.
	\subsubsection*{Description}
	The \verb+XLALCreate<type>VectorSequence+ functions create vector sequences
	of type \verb+<type>, length \verb+length+, and vector length \verb+veclen+
	.
	The function \verb+XLALCreateVectorSequence+ is the same as
	\verb+XLALCreateREAL4VectorSequence+.
	The \verb+XLALDestroy<type>VectorSequence+ functions deallocate the memory
	allocation pointed to by \verb+vecseq+ including its contents. The functio
	n
	\verb+XLALDestroyVectorSequence+ is the same as
	\verb+XLALDestroyREAL4VectorSequence+.
	\subsubsection*{Return Values}
	The create functions return a pointer to the created vector sequence if
	successful; upon failure they will return \verb+NULL+ and set \verb+xlalErr
	no+
	to one of the following values: \verb+XLAL_ENOMEM+ if memory allocation
	failed, or \verb+XLAL_EBADLEN+ if the requested \verb+length+ or \verb+vecl
	en+
	is zero.
	The destroy functions do not have a return value. They can fail if they ar
	e
	passed a \verb+NULL+ pointer, in which case \verb+xlalErrno+ is set to
	\verb+XLAL_EFAULT+, or if the vector sequency passed to the destroy routine
	has zero length, vector length, or \verb+NULL+ data pointer then
	\verb+xlalErrno+ is set to \verb+XLAL_EINVAL+.
	</lalLaTeX> */
	REAL4VectorSequence * XLALCreateVectorSequence ( UINT4 length, UINT4 veclen );		REAL4VectorSequence * XLALCreateVectorSequence ( UINT4 length, UINT4 veclen );
	void XLALDestroyVectorSequence ( REAL4VectorSequence * vecseq );		void XLALDestroyVectorSequence ( REAL4VectorSequence * vecseq );
	void LALCreateSequence(LALStatus *, REAL4Sequence **, UINT4);
	void LALDestroySequence(LALStatus *, REAL4Sequence **);
	void LALCreateVectorSequence(LALStatus *, REAL4VectorSequence **,		void LALCreateVectorSequence(LALStatus *, REAL4VectorSequence **,
	CreateVectorSequenceIn *);		CreateVectorSequenceIn *);
	void LALDestroyVectorSequence(LALStatus *, REAL4VectorSequence**);		void LALDestroyVectorSequence(LALStatus *, REAL4VectorSequence**);
	void LALCreateArraySequence(LALStatus *, REAL4ArraySequence **,		void LALCreateArraySequence(LALStatus *, REAL4ArraySequence **,
	CreateArraySequenceIn *);		CreateArraySequenceIn *);
	void LALDestroyArraySequence(LALStatus *, REAL4ArraySequence **);		void LALDestroyArraySequence(LALStatus *, REAL4ArraySequence **);
	/*		/* 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 LALCHARCreateSequence ( LALStatus *status,
	CHARSequence **sequence,
	UINT4);
	void LALCHARDestroySequence ( LALStatus *status,
	CHARSequence **sequence);
	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 */
	*/
	INT2VectorSequence * XLALCreateINT2VectorSequence ( UINT4 length, UINT4 vec len );		INT2VectorSequence * XLALCreateINT2VectorSequence ( UINT4 length, UINT4 vec len );
	void XLALDestroyINT2VectorSequence ( INT2VectorSequence * vecseq );		void XLALDestroyINT2VectorSequence ( INT2VectorSequence * vecseq );
	void LALI2CreateSequence ( LALStatus *status,
	INT2Sequence **sequence,
	UINT4);
	void LALI2DestroySequence ( LALStatus *status,
	INT2Sequence **sequence);
	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,		void LALI2CreateArraySequence ( LALStatus *status,
	INT2ArraySequence **arraySequence,		INT2ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALI2DestroyArraySequence ( LALStatus *status,		void LALI2DestroyArraySequence ( LALStatus *status,
	INT2ArraySequence **arraySeqence);		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 LALI4CreateSequence ( LALStatus *status,
	INT4Sequence **sequence,
	UINT4);
	void LALI4DestroySequence ( LALStatus *status,
	INT4Sequence **sequence);
	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,		void LALI4CreateArraySequence ( LALStatus *status,
	INT4ArraySequence **arraySequence,		INT4ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALI4DestroyArraySequence ( LALStatus *status,		void LALI4DestroyArraySequence ( LALStatus *status,
	INT4ArraySequence **arraySeqence);		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 LALI8CreateSequence ( LALStatus *status,
	INT8Sequence **sequence,
	UINT4);
	void LALI8DestroySequence ( LALStatus *status,
	INT8Sequence **sequence);
	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,		void LALI8CreateArraySequence ( LALStatus *status,
	INT8ArraySequence **arraySequence,		INT8ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALI8DestroyArraySequence ( LALStatus *status,		void LALI8DestroyArraySequence ( LALStatus *status,
	INT8ArraySequence **arraySeqence);		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 LALU2CreateSequence ( LALStatus *status,
	UINT2Sequence **sequence,
	UINT4);
	void LALU2DestroySequence ( LALStatus *status,
	UINT2Sequence **sequence);
	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,		void LALU2CreateArraySequence ( LALStatus *status,
	UINT2ArraySequence **arraySequence,		UINT2ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALU2DestroyArraySequence ( LALStatus *status,		void LALU2DestroyArraySequence ( LALStatus *status,
	UINT2ArraySequence **arraySeqence);		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 LALU4CreateSequence ( LALStatus *status,
	UINT4Sequence **sequence,
	UINT4);
	void LALU4DestroySequence ( LALStatus *status,
	UINT4Sequence **sequence);
	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,		void LALU4CreateArraySequence ( LALStatus *status,
	UINT4ArraySequence **arraySequence,		UINT4ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALU4DestroyArraySequence ( LALStatus *status,		void LALU4DestroyArraySequence ( LALStatus *status,
	UINT4ArraySequence **arraySeqence);		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 LALU8CreateSequence ( LALStatus *status,
	UINT8Sequence **sequence,
	UINT4);
	void LALU8DestroySequence ( LALStatus *status,
	UINT8Sequence **sequence);
	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,		void LALU8CreateArraySequence ( LALStatus *status,
	UINT8ArraySequence **arraySequence,		UINT8ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALU8DestroyArraySequence ( LALStatus *status,		void LALU8DestroyArraySequence ( LALStatus *status,
	UINT8ArraySequence **arraySeqence);		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 LALSCreateSequence ( LALStatus *status,
	REAL4Sequence **sequence,
	UINT4);
	void LALSDestroySequence ( LALStatus *status,
	REAL4Sequence **sequence);
	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,		void LALSCreateArraySequence ( LALStatus *status,
	REAL4ArraySequence **arraySequence,		REAL4ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALSDestroyArraySequence ( LALStatus *status,		void LALSDestroyArraySequence ( LALStatus *status,
	REAL4ArraySequence **arraySeqence);		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 LALDCreateSequence ( LALStatus *status,
	REAL8Sequence **sequence,
	UINT4);
	void LALDDestroySequence ( LALStatus *status,
	REAL8Sequence **sequence);
	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,		void LALDCreateArraySequence ( LALStatus *status,
	REAL8ArraySequence **arraySequence,		REAL8ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALDDestroyArraySequence ( LALStatus *status,		void LALDDestroyArraySequence ( LALStatus *status,
	REAL8ArraySequence **arraySeqence);		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 LALCCreateSequence ( LALStatus *status,
	COMPLEX8Sequence **sequence,
	UINT4);
	void LALCDestroySequence ( LALStatus *status,
	COMPLEX8Sequence **sequence);
	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,		void LALCCreateArraySequence ( LALStatus *status,
	COMPLEX8ArraySequence **arraySequence,		COMPLEX8ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALCDestroyArraySequence ( LALStatus *status,		void LALCDestroyArraySequence ( LALStatus *status,
	COMPLEX8ArraySequence **arraySeqence);		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 LALZCreateSequence ( LALStatus *status,
	COMPLEX16Sequence **sequence,
	UINT4);
	void LALZDestroySequence ( LALStatus *status,
	COMPLEX16Sequence **sequence);
	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,		void LALZCreateArraySequence ( LALStatus *status,
	COMPLEX16ArraySequence **arraySequence,		COMPLEX16ArraySequence **arraySequence,
	CreateArraySequenceIn *aSeqParams);		CreateArraySequenceIn *aSeqParams);
	void LALZDestroyArraySequence ( LALStatus *status,		void LALZDestroyArraySequence ( LALStatus *status,
	COMPLEX16ArraySequence **arraySeqence);		COMPLEX16ArraySequence **arraySeqence);
	/* <lalLaTeX>
	\newpage\input{VectorSequenceFactoriesTestC}
	</lalLaTeX> */
	/* <lalLaTeX>
	\newpage\input{ArraySequenceFactoriesTestC}
	</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _SEQFACTORIES_H */		#endif /* _SEQFACTORIES_H */
End of changes. 51 change blocks.
	304 lines changed or deleted		96 lines changed or added

	Sequence.h		Sequence.h
	/*		/*
	* $Id$
	*		*
	* Copyright (C) 2007 Kipp Cannon		* Copyright (C) 2007 Kipp Cannon
	*		*
	* This program is free software; you can redistribute it and/or modify it		* This program is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License as published by the		* under the terms of the GNU General Public License as published by the
	* Free Software Foundation; either version 2 of the License, or (at your		* Free Software Foundation; either version 2 of the License, or (at your
	* option) any later version.		* option) any later version.
	*		*
	* This program is distributed in the hope that it will be useful, but		* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of		* WITHOUT ANY WARRANTY; without even the implied warranty of
	skipping to change at line 26		skipping to change at line 25
	* You should have received a copy of the GNU General Public License along		* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,		* with this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/		*/
	#ifndef _SEQUENCE_H		#ifndef _SEQUENCE_H
	#define _SEQUENCE_H		#define _SEQUENCE_H
	#include <stddef.h>		#include <stddef.h>
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
			#if defined(__cplusplus)
			extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
	NRCSID(SEQUENCEH, "$Id:");		NRCSID(SEQUENCEH, "$Id:");
	/* <lalLaTeX file="SequenceDestroyP">		/* COMPLEX8 prototypes */
	\idx{XLALDestroyCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyCOMPLEX8Sequence (		void XLALDestroyCOMPLEX8Sequence (
	COMPLEX8Sequence *sequence		COMPLEX8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	COMPLEX8Sequence *XLALCreateCOMPLEX8Sequence (		COMPLEX8Sequence *XLALCreateCOMPLEX8Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	COMPLEX8Sequence *XLALCutCOMPLEX8Sequence (		COMPLEX8Sequence *XLALCutCOMPLEX8Sequence (
	COMPLEX8Sequence *sequence,		COMPLEX8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	COMPLEX8Sequence *XLALCopyCOMPLEX8Sequence (		COMPLEX8Sequence *XLALCopyCOMPLEX8Sequence (
	COMPLEX8Sequence *sequence		COMPLEX8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftCOMPLEX8Sequence (		void XLALShiftCOMPLEX8Sequence (
	COMPLEX8Sequence *sequence,		COMPLEX8Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	COMPLEX8Sequence *XLALResizeCOMPLEX8Sequence (		COMPLEX8Sequence *XLALResizeCOMPLEX8Sequence (
	COMPLEX8Sequence *sequence,		COMPLEX8Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	COMPLEX8Sequence *XLALShrinkCOMPLEX8Sequence (		COMPLEX8Sequence *XLALShrinkCOMPLEX8Sequence (
	COMPLEX8Sequence *sequence,		COMPLEX8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX8Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	COMPLEX8 XLALCOMPLEX8Sum (		COMPLEX8 XLALCOMPLEX8Sum (
	const COMPLEX8 *data,		const COMPLEX8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX8SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL4 XLALCOMPLEX8SumSquares (		REAL4 XLALCOMPLEX8SumSquares (
	const COMPLEX8 *data,		const COMPLEX8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX8SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	COMPLEX8 XLALCOMPLEX8SequenceSum (		COMPLEX8 XLALCOMPLEX8SequenceSum (
	const COMPLEX8Sequence *sequence,		const COMPLEX8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX8SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL4 XLALCOMPLEX8SequenceSumSquares (		REAL4 XLALCOMPLEX8SequenceSumSquares (
	const COMPLEX8Sequence *sequence,		const COMPLEX8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceConjugateP">
	\idx{XLALConjugateCOMPLEX8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceConjugateP"> */
	COMPLEX8Sequence *XLALConjugateCOMPLEX8Sequence (		COMPLEX8Sequence *XLALConjugateCOMPLEX8Sequence (
	COMPLEX8Sequence *series		COMPLEX8Sequence *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* COMPLEX16 prototypes */
	\idx{XLALDestroyCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyCOMPLEX16Sequence (		void XLALDestroyCOMPLEX16Sequence (
	COMPLEX16Sequence *sequence		COMPLEX16Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	COMPLEX16Sequence *XLALCreateCOMPLEX16Sequence (		COMPLEX16Sequence *XLALCreateCOMPLEX16Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	COMPLEX16Sequence *XLALCutCOMPLEX16Sequence (		COMPLEX16Sequence *XLALCutCOMPLEX16Sequence (
	COMPLEX16Sequence *sequence,		COMPLEX16Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	COMPLEX16Sequence *XLALCopyCOMPLEX16Sequence (		COMPLEX16Sequence *XLALCopyCOMPLEX16Sequence (
	COMPLEX16Sequence *sequence		COMPLEX16Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftCOMPLEX16Sequence (		void XLALShiftCOMPLEX16Sequence (
	COMPLEX16Sequence *sequence,		COMPLEX16Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	COMPLEX16Sequence *XLALResizeCOMPLEX16Sequence (		COMPLEX16Sequence *XLALResizeCOMPLEX16Sequence (
	COMPLEX16Sequence *sequence,		COMPLEX16Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	COMPLEX16Sequence *XLALShrinkCOMPLEX16Sequence (		COMPLEX16Sequence *XLALShrinkCOMPLEX16Sequence (
	COMPLEX16Sequence *sequence,		COMPLEX16Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX16Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	COMPLEX16 XLALCOMPLEX16Sum (		COMPLEX16 XLALCOMPLEX16Sum (
	const COMPLEX16 *data,		const COMPLEX16 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX16SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL8 XLALCOMPLEX16SumSquares (		REAL8 XLALCOMPLEX16SumSquares (
	const COMPLEX16 *data,		const COMPLEX16 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX16SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	COMPLEX16 XLALCOMPLEX16SequenceSum (		COMPLEX16 XLALCOMPLEX16SequenceSum (
	const COMPLEX16Sequence *sequence,		const COMPLEX16Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALCOMPLEX16SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL8 XLALCOMPLEX16SequenceSumSquares (		REAL8 XLALCOMPLEX16SequenceSumSquares (
	const COMPLEX16Sequence *sequence,		const COMPLEX16Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceConjugateP">
	\idx{XLALConjugateCOMPLEX16Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceConjugateP"> */
	COMPLEX16Sequence *XLALConjugateCOMPLEX16Sequence (		COMPLEX16Sequence *XLALConjugateCOMPLEX16Sequence (
	COMPLEX16Sequence *series		COMPLEX16Sequence *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* REAL4 prototypes */
	\idx{XLALDestroyREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyREAL4Sequence (		void XLALDestroyREAL4Sequence (
	REAL4Sequence *sequence		REAL4Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	REAL4Sequence *XLALCreateREAL4Sequence (		REAL4Sequence *XLALCreateREAL4Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	REAL4Sequence *XLALCutREAL4Sequence (		REAL4Sequence *XLALCutREAL4Sequence (
	REAL4Sequence *sequence,		REAL4Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	REAL4Sequence *XLALCopyREAL4Sequence (		REAL4Sequence *XLALCopyREAL4Sequence (
	REAL4Sequence *sequence		REAL4Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftREAL4Sequence (		void XLALShiftREAL4Sequence (
	REAL4Sequence *sequence,		REAL4Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	REAL4Sequence *XLALResizeREAL4Sequence (		REAL4Sequence *XLALResizeREAL4Sequence (
	REAL4Sequence *sequence,		REAL4Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkREAL4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	REAL4Sequence *XLALShrinkREAL4Sequence (		REAL4Sequence *XLALShrinkREAL4Sequence (
	REAL4Sequence *sequence,		REAL4Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL4Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL4 XLALREAL4Sum (		REAL4 XLALREAL4Sum (
	const REAL4 *data,		const REAL4 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL4SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL4 XLALREAL4SumSquares (		REAL4 XLALREAL4SumSquares (
	const REAL4 *data,		const REAL4 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL4SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL4 XLALREAL4SequenceSum (		REAL4 XLALREAL4SequenceSum (
	const REAL4Sequence *sequence,		const REAL4Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL4SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL4 XLALREAL4SequenceSumSquares (		REAL4 XLALREAL4SequenceSumSquares (
	const REAL4Sequence *sequence,		const REAL4Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* REAL8 prototypes */
	\idx{XLALDestroyREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyREAL8Sequence (		void XLALDestroyREAL8Sequence (
	REAL8Sequence *sequence		REAL8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	REAL8Sequence *XLALCreateREAL8Sequence (		REAL8Sequence *XLALCreateREAL8Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	REAL8Sequence *XLALCutREAL8Sequence (		REAL8Sequence *XLALCutREAL8Sequence (
	REAL8Sequence *sequence,		REAL8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	REAL8Sequence *XLALCopyREAL8Sequence (		REAL8Sequence *XLALCopyREAL8Sequence (
	REAL8Sequence *sequence		REAL8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftREAL8Sequence (		void XLALShiftREAL8Sequence (
	REAL8Sequence *sequence,		REAL8Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	REAL8Sequence *XLALResizeREAL8Sequence (		REAL8Sequence *XLALResizeREAL8Sequence (
	REAL8Sequence *sequence,		REAL8Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkREAL8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	REAL8Sequence *XLALShrinkREAL8Sequence (		REAL8Sequence *XLALShrinkREAL8Sequence (
	REAL8Sequence *sequence,		REAL8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL8Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL8 XLALREAL8Sum (		REAL8 XLALREAL8Sum (
	const REAL8 *data,		const REAL8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL8SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL8 XLALREAL8SumSquares (		REAL8 XLALREAL8SumSquares (
	const REAL8 *data,		const REAL8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL8SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL8 XLALREAL8SequenceSum (		REAL8 XLALREAL8SequenceSum (
	const REAL8Sequence *sequence,		const REAL8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALREAL8SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	REAL8 XLALREAL8SequenceSumSquares (		REAL8 XLALREAL8SequenceSumSquares (
	const REAL8Sequence *sequence,		const REAL8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* INT2 prototypes */
	\idx{XLALDestroyINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyINT2Sequence (		void XLALDestroyINT2Sequence (
	INT2Sequence *sequence		INT2Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	INT2Sequence *XLALCreateINT2Sequence (		INT2Sequence *XLALCreateINT2Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	INT2Sequence *XLALCutINT2Sequence (		INT2Sequence *XLALCutINT2Sequence (
	INT2Sequence *sequence,		INT2Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	INT2Sequence *XLALCopyINT2Sequence (		INT2Sequence *XLALCopyINT2Sequence (
	INT2Sequence *sequence		INT2Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftINT2Sequence (		void XLALShiftINT2Sequence (
	INT2Sequence *sequence,		INT2Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	INT2Sequence *XLALResizeINT2Sequence (		INT2Sequence *XLALResizeINT2Sequence (
	INT2Sequence *sequence,		INT2Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	INT2Sequence *XLALShrinkINT2Sequence (		INT2Sequence *XLALShrinkINT2Sequence (
	INT2Sequence *sequence,		INT2Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT2Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	INT2 XLALINT2Sum (		INT2 XLALINT2Sum (
	const INT2 *data,		const INT2 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT2SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT2 XLALINT2SumSquares (		UINT2 XLALINT2SumSquares (
	const INT2 *data,		const INT2 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT2SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	INT2 XLALINT2SequenceSum (		INT2 XLALINT2SequenceSum (
	const INT2Sequence *sequence,		const INT2Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT2SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT2 XLALINT2SequenceSumSquares (		UINT2 XLALINT2SequenceSumSquares (
	const INT2Sequence *sequence,		const INT2Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* INT4 prototypes */
	\idx{XLALDestroyINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyINT4Sequence (		void XLALDestroyINT4Sequence (
	INT4Sequence *sequence		INT4Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	INT4Sequence *XLALCreateINT4Sequence (		INT4Sequence *XLALCreateINT4Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	INT4Sequence *XLALCutINT4Sequence (		INT4Sequence *XLALCutINT4Sequence (
	INT4Sequence *sequence,		INT4Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	INT4Sequence *XLALCopyINT4Sequence (		INT4Sequence *XLALCopyINT4Sequence (
	INT4Sequence *sequence		INT4Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftINT4Sequence (		void XLALShiftINT4Sequence (
	INT4Sequence *sequence,		INT4Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	INT4Sequence *XLALResizeINT4Sequence (		INT4Sequence *XLALResizeINT4Sequence (
	INT4Sequence *sequence,		INT4Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	INT4Sequence *XLALShrinkINT4Sequence (		INT4Sequence *XLALShrinkINT4Sequence (
	INT4Sequence *sequence,		INT4Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT4Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	INT4 XLALINT4Sum (		INT4 XLALINT4Sum (
	const INT4 *data,		const INT4 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT4SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT4 XLALINT4SumSquares (		UINT4 XLALINT4SumSquares (
	const INT4 *data,		const INT4 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT4SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	INT4 XLALINT4SequenceSum (		INT4 XLALINT4SequenceSum (
	const INT4Sequence *sequence,		const INT4Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT4SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT4 XLALINT4SequenceSumSquares (		UINT4 XLALINT4SequenceSumSquares (
	const INT4Sequence *sequence,		const INT4Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* INT8 prototypes */
	\idx{XLALDestroyINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyINT8Sequence (		void XLALDestroyINT8Sequence (
	INT8Sequence *sequence		INT8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	INT8Sequence *XLALCreateINT8Sequence (		INT8Sequence *XLALCreateINT8Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	INT8Sequence *XLALCutINT8Sequence (		INT8Sequence *XLALCutINT8Sequence (
	INT8Sequence *sequence,		INT8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	INT8Sequence *XLALCopyINT8Sequence (		INT8Sequence *XLALCopyINT8Sequence (
	INT8Sequence *sequence		INT8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftINT8Sequence (		void XLALShiftINT8Sequence (
	INT8Sequence *sequence,		INT8Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	INT8Sequence *XLALResizeINT8Sequence (		INT8Sequence *XLALResizeINT8Sequence (
	INT8Sequence *sequence,		INT8Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	INT8Sequence *XLALShrinkINT8Sequence (		INT8Sequence *XLALShrinkINT8Sequence (
	INT8Sequence *sequence,		INT8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT8Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	INT8 XLALINT8Sum (		INT8 XLALINT8Sum (
	const INT8 *data,		const INT8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT8SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT8 XLALINT8SumSquares (		UINT8 XLALINT8SumSquares (
	const INT8 *data,		const INT8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT8SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	INT8 XLALINT8SequenceSum (		INT8 XLALINT8SequenceSum (
	const INT8Sequence *sequence,		const INT8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALINT8SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT8 XLALINT8SequenceSumSquares (		UINT8 XLALINT8SequenceSumSquares (
	const INT8Sequence *sequence,		const INT8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* UINT2 prototypes */
	\idx{XLALDestroyUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyUINT2Sequence (		void XLALDestroyUINT2Sequence (
	UINT2Sequence *sequence		UINT2Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	UINT2Sequence *XLALCreateUINT2Sequence (		UINT2Sequence *XLALCreateUINT2Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	UINT2Sequence *XLALCutUINT2Sequence (		UINT2Sequence *XLALCutUINT2Sequence (
	UINT2Sequence *sequence,		UINT2Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	UINT2Sequence *XLALCopyUINT2Sequence (		UINT2Sequence *XLALCopyUINT2Sequence (
	UINT2Sequence *sequence		UINT2Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftUINT2Sequence (		void XLALShiftUINT2Sequence (
	UINT2Sequence *sequence,		UINT2Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	UINT2Sequence *XLALResizeUINT2Sequence (		UINT2Sequence *XLALResizeUINT2Sequence (
	UINT2Sequence *sequence,		UINT2Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkUINT2Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	UINT2Sequence *XLALShrinkUINT2Sequence (		UINT2Sequence *XLALShrinkUINT2Sequence (
	UINT2Sequence *sequence,		UINT2Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT2Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT2 XLALUINT2Sum (		UINT2 XLALUINT2Sum (
	const UINT2 *data,		const UINT2 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT2SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT2 XLALUINT2SumSquares (		UINT2 XLALUINT2SumSquares (
	const UINT2 *data,		const UINT2 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT2SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT2 XLALUINT2SequenceSum (		UINT2 XLALUINT2SequenceSum (
	const UINT2Sequence *sequence,		const UINT2Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT2SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT2 XLALUINT2SequenceSumSquares (		UINT2 XLALUINT2SequenceSumSquares (
	const UINT2Sequence *sequence,		const UINT2Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* UINT4 prototypes */
	\idx{XLALDestroyUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyUINT4Sequence (		void XLALDestroyUINT4Sequence (
	UINT4Sequence *sequence		UINT4Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	UINT4Sequence *XLALCreateUINT4Sequence (		UINT4Sequence *XLALCreateUINT4Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	UINT4Sequence *XLALCutUINT4Sequence (		UINT4Sequence *XLALCutUINT4Sequence (
	UINT4Sequence *sequence,		UINT4Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	UINT4Sequence *XLALCopyUINT4Sequence (		UINT4Sequence *XLALCopyUINT4Sequence (
	UINT4Sequence *sequence		UINT4Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftUINT4Sequence (		void XLALShiftUINT4Sequence (
	UINT4Sequence *sequence,		UINT4Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	UINT4Sequence *XLALResizeUINT4Sequence (		UINT4Sequence *XLALResizeUINT4Sequence (
	UINT4Sequence *sequence,		UINT4Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkUINT4Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	UINT4Sequence *XLALShrinkUINT4Sequence (		UINT4Sequence *XLALShrinkUINT4Sequence (
	UINT4Sequence *sequence,		UINT4Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT4Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT4 XLALUINT4Sum (		UINT4 XLALUINT4Sum (
	const UINT4 *data,		const UINT4 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT4SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT4 XLALUINT4SumSquares (		UINT4 XLALUINT4SumSquares (
	const UINT4 *data,		const UINT4 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT4SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT4 XLALUINT4SequenceSum (		UINT4 XLALUINT4SequenceSum (
	const UINT4Sequence *sequence,		const UINT4Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT4SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT4 XLALUINT4SequenceSumSquares (		UINT4 XLALUINT4SequenceSumSquares (
	const UINT4Sequence *sequence,		const UINT4Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceDestroyP">		/* UINT8 prototypes */
	\idx{XLALDestroyUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceDestroyP"> */
	void XLALDestroyUINT8Sequence (		void XLALDestroyUINT8Sequence (
	UINT8Sequence *sequence		UINT8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCreateP">
	\idx{XLALCreateUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCreateP"> */
	UINT8Sequence *XLALCreateUINT8Sequence (		UINT8Sequence *XLALCreateUINT8Sequence (
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCutUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	UINT8Sequence *XLALCutUINT8Sequence (		UINT8Sequence *XLALCutUINT8Sequence (
	UINT8Sequence *sequence,		UINT8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceCutP">
	\idx{XLALCopyUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceCutP"> */
	UINT8Sequence *XLALCopyUINT8Sequence (		UINT8Sequence *XLALCopyUINT8Sequence (
	UINT8Sequence *sequence		UINT8Sequence *sequence
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceShiftP">
	\idx{XLALShiftUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceShiftP"> */
	void XLALShiftUINT8Sequence (		void XLALShiftUINT8Sequence (
	UINT8Sequence *sequence,		UINT8Sequence *sequence,
	int count		int count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALResizeUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	UINT8Sequence *XLALResizeUINT8Sequence (		UINT8Sequence *XLALResizeUINT8Sequence (
	UINT8Sequence *sequence,		UINT8Sequence *sequence,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceResizeP">
	\idx{XLALShrinkUINT8Sequence ()}
	</lalLaTeX> <lalVerbatim file="SequenceResizeP"> */
	UINT8Sequence *XLALShrinkUINT8Sequence (		UINT8Sequence *XLALShrinkUINT8Sequence (
	UINT8Sequence *sequence,		UINT8Sequence *sequence,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT8Sum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT8 XLALUINT8Sum (		UINT8 XLALUINT8Sum (
	const UINT8 *data,		const UINT8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT8SumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT8 XLALUINT8SumSquares (		UINT8 XLALUINT8SumSquares (
	const UINT8 *data,		const UINT8 *data,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT8SequenceSum ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT8 XLALUINT8SequenceSum (		UINT8 XLALUINT8SequenceSum (
	const UINT8Sequence *sequence,		const UINT8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="SequenceSumP">
	\idx{XLALUINT8SequenceSumSquares ()}
	</lalLaTeX> <lalVerbatim file="SequenceSumP"> */
	UINT8 XLALUINT8SequenceSumSquares (		UINT8 XLALUINT8SequenceSumSquares (
	const UINT8Sequence *sequence,		const UINT8Sequence *sequence,
	size_t first,		size_t first,
	size_t count		size_t count
	);		);
	/* </lalVerbatim> */
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
			}
			#endif
	#endif /* _SEQUENCE_H */		#endif /* _SEQUENCE_H */
End of changes. 227 change blocks.
	450 lines changed or deleted		33 lines changed or added

	SimulateCoherentGW.h		SimulateCoherentGW.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
	*/		*/
	/*************************** <lalVerbatim file="SimulateCoherentGWHV">		#ifndef _SIMULATECOHERENTGW_H
	Author: Creighton, T. D.		#define _SIMULATECOHERENTGW_H
	$Id$
	**************************************************** </lalVerbatim> */
	/********************************************************** <lalLaTeX>		/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	\providecommand{\bm}[1]{\mbox{\boldmath$#1$\unboldmath}}		#include <lal/LALStdlib.h>
	\providecommand{\lessim}{\stackrel{<}{\scriptstyle\sim}}		#include <lal/DetectorSite.h>
			#include <lal/SkyCoordinates.h>
			#include <lal/LALBarycenter.h>
	\section{Header \texttt{SimulateCoherentGW.h}}		#if defined(__cplusplus)
	\label{s:SimulateCoherentGW.h}		extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
	Provides routines to simulate generic gravitational waveforms		NRCSID( SIMULATECOHERENTGWH, "$Id$" );
			/**
			\author Creighton, T. D.
			\addtogroup SimulateCoherentGW_h
			\brief Provides routines to simulate generic gravitational waveforms
	originating from a particular source.		originating from a particular source.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/SimulateCoherentGW.h>		#include <lal/SimulateCoherentGW.h>
	\end{verbatim}		\endcode
	This header covers generic routines and structures to represent and		This header covers generic routines and structures to represent and
	simulate the effects of a plane gravitational wave propagating from a		simulate the effects of a plane gravitational wave propagating from a
	distinct point on the sky.		distinct point on the sky.
	Any plane gravitational wave is specified by a direction		Any plane gravitational wave is specified by a direction
	$\bm{\hat{n}}$ to its apparent source (i.e.\ opposite to its direction		\f$\mathbf{\hat{n}}\f$ to its apparent source (i.e.\ opposite to its direct
	of propagation), and by the inistantaneous values $h_+(t)$,		ion
	$h_\times(t)$ of its plus and cross polarizations as functions of		of propagation), and by the inistantaneous values \f$h_+(t)\f$,
	(retarded) time $t=t_0+\bm{\hat{n}}\cdot(\bm{x}-\bm{x}_0)$, where		\f$h_\times(t)\f$ of its plus and cross polarizations as functions of
	$t_0$ is the time measured at some local reference point $\bm{x}_0$,		(retarded) time \f$t=t_0+\mathbf{\hat{n}}\cdot(\mathbf{x}-\mathbf{x}_0)\f$,
	and $t$ is the time measured by a synchronized clock at $\bm{x}$. We		where
			\f$t_0\f$ is the time measured at some local reference point \f$\mathbf{x}_
			0\f$,
			and \f$t\f$ is the time measured by a synchronized clock at \f$\mathbf{x}\f
			$. We
	adopt the standard meaning of the instantaneous strain amplitudes		adopt the standard meaning of the instantaneous strain amplitudes
	$h_{+,\times}$: in some reference transverse $x$-$y$ coordinate system		\f$h_{+,\times}\f$: in some reference transverse \f$x\f$-\f$y\f$ coordinate
	oriented such that $\bm{\hat{x}}\times\bm{\hat{y}}=-\bm{\hat{n}}$		system
			oriented such that \f$\mathbf{\hat{x}}\times\mathbf{\hat{y}}=-\mathbf{\hat{
			n}}\f$
	points in the direction of propagation, two free observers originally		points in the direction of propagation, two free observers originally
	separated by a displacement $(x,y)$ will experience an additional		separated by a displacement \f$(x,y)\f$ will experience an additional
	tidal displacement $\delta x=(xh_+ + yh_\times)/2$, $\delta		tidal displacement \f$\delta x=(xh_+ + yh_\times)/2\f$, \f$\delta
	y=(xh_\times - yh_+)/2$.		y=(xh_\times - yh_+)/2\f$.
	\paragraph{Quasiperiodic waves:} Most astrophysical sources of		\heading{Quasiperiodic waves:} Most astrophysical sources of
	gravitational radiation are described as \emph{quasiperiodic} (or,		gravitational radiation are described as \e quasiperiodic (or,
	less accurately, as ``adiabatic''), in that they can be said to have		less accurately, as "adiabatic"), in that they can be said to have
	an instantaneous frequency, amplitude, and polarization, all of which		an instantaneous frequency, amplitude, and polarization, all of which
	vary on timescales much longer than a wave period. Mathematically we		vary on timescales much longer than a wave period. Mathematically we
	write this as:		write this as:
	$$		\f[
	h_{+,\times}(t) = A_{+,\times}(t)\cos\phi(t)		h_{+,\times}(t) = A_{+,\times}(t)\cos\phi(t)
	+ B_{+,\times}(t)\sin\phi(t) \; ,		+ B_{+,\times}(t)\sin\phi(t) \; ,
	$$		\f]
	\begin{wrapfigure}{r}{0.47\textwidth}
	\vspace{-4ex}		\wrapfig{r,0.47\textwidth,fig_phase_diagram}
	\begin{center}		\image html inject_phase_diagram.png "Fig. [fig_phase_diagram]: Polarizatio
	\resizebox{0.42\textwidth}{!}{\includegraphics{inject_phase_diagram}} \\		n phase diagram for a quasiperiodic gravitational wave. The phase point p(t
	\parbox{0.42\textwidth}{\caption{\label{fig:phase-diagram}		) traces out the indicated ellipse in the h_+,h_x plane; the parameters A1,
	Polarization phase diagram for a quasiperiodic gravitational wave.		A2 and Phi remain roughly constant over many cycles in phi."
	The phase point $p(t)$ traces out the indicated ellipse in the		\image latex inject_phase_diagram.eps "Polarization phase diagram for a qua
	$h_+,h_\times$ plane; the parameters $A_1$, $A_2$, and $\Phi$		siperiodic gravitational wave. The phase point p(t) traces out the indicate
	remain roughly constant over many cycles in $\phi$.}}		d ellipse in the h_+,h_x plane; the parameters A1, A2 and Phi remain roughl
	\end{center}		y constant over many cycles in phi." width=0.42\textwidth
	\vspace{-2ex}
	\end{wrapfigure}		where \f$\phi(t)=2\pi\int f(t)\,dt\f$, and the <em>evolution timescale</em>
	where $\phi(t)=2\pi\int f(t)\,dt$, and the \emph{evolution timescale}		\f$\tau=\min\{A/\dot{A},B/\dot{B},f/\dot{f}\}\f$ is much greater than
	$\tau=\min\{A/\dot{A},B/\dot{B},f/\dot{f}\}$ is much greater than		\f$h/\dot{h}\sim1/f\f$. Obviously it is mathematically impossible for the
	$h/\dot{h}\sim1/f$. Obviously it is mathematically impossible for the		physical functions \f$h_{+,\times}(t)\f$ to specify uniquely more than two
	physical functions $h_{+,\times}(t)$ to specify uniquely more than two
	other functions of time; we rely on the notion of quasiperiodicity to		other functions of time; we rely on the notion of quasiperiodicity to
	define ``natural'' choices of instantaneous frequency and amplitude.		define "natural" choices of instantaneous frequency and amplitude.
	The ambiguity in this choice is on the order of the amount that these		The ambiguity in this choice is on the order of the amount that these
	quantities change over a cycle.		quantities change over a cycle.
	While the above formula appears to have five degrees of freedom (two		While the above formula appears to have five degrees of freedom (two
	quadrature amplitudes $A$ and $B$ for each polarization, plus a common		quadrature amplitudes \f$A\f$ and \f$B\f$ for each polarization, plus a com
	phase function $\phi$), there is a degeneracy between the two		mon
			phase function \f$\phi\f$), there is a degeneracy between the two
	quadrature amplitudes and a shift in phase. One could simply treat		quadrature amplitudes and a shift in phase. One could simply treat
	each polarization independently and represent the system with two		each polarization independently and represent the system with two
	amplitude functions $A_{+,\times}$ and two phase functions		amplitude functions \f$A_{+,\times}\f$ and two phase functions
	$\phi_{+,\times}$, but we would like to preserve the notion that the		\f$\phi_{+,\times}\f$, but we would like to preserve the notion that the
	phases of the two waveforms derive from a single underlying		phases of the two waveforms derive from a single underlying
	instantaneous frequency. We therefore write the waveforms in terms of		instantaneous frequency. We therefore write the waveforms in terms of
	two polarization amplitudes $A_1(t)$ and $A_2(t)$, a single phase		two polarization amplitudes \f$A_1(t)\f$ and \f$A_2(t)\f$, a single phase
	function $\phi(t)$, and a polarization shift $\Phi(t)$:		function \f$\phi(t)\f$, and a polarization shift \f$\Phi(t)\f$:
	\begin{eqnarray}		\anchor eq_quasiperiodic_hplus \anchor eq_quasiperiodic_hcross \f{eqnarray}
	\label{eq:quasiperiodic-hplus}		{
			\label{eq_quasiperiodic_hplus}
	h_+(t) & = & A_1(t)\cos\Phi(t)\cos\phi(t)		h_+(t) & = & A_1(t)\cos\Phi(t)\cos\phi(t)
	- A_2(t)\sin\Phi(t)\sin\phi(t) \; , \\		- A_2(t)\sin\Phi(t)\sin\phi(t) \; , \\
	\label{eq:quasiperiodic-hcross}		\label{eq_quasiperiodic_hcross}
	h_\times(t) & = & A_1(t)\sin\Phi(t)\cos\phi(t)		h_\times(t) & = & A_1(t)\sin\Phi(t)\cos\phi(t)
	+ A_2(t)\cos\Phi(t)\sin\phi(t) \; .		+ A_2(t)\cos\Phi(t)\sin\phi(t) \; .
	\end{eqnarray}		\f}
	The physical meaning of these functions is shown in		The physical meaning of these functions is shown in Fig.\figref{fig_phase_d
	Fig.~\ref{fig:phase-diagram}.		iagram}.
	There is a close relationship between the polarization shift $\Phi$		There is a close relationship between the polarization shift \f$\Phi\f$
	and the orientation of the $x$-$y$ coordinates used to define our		and the orientation of the \f$x\f$-\f$y\f$ coordinates used to define our
	polarization basis: if we rotate the $x$ and $y$ axes by an angle		polarization basis: if we rotate the \f$x\f$ and \f$y\f$ axes by an angle
	$\Delta\psi$, we change $\Phi$ by an amount $-2\Delta\psi$. (The		\f$\Delta\psi\f$, we change \f$\Phi\f$ by an amount \f$-2\Delta\psi\f$. (T
	factor of 2 comes from the fact that the + and $\times$ modes are		he
	quadrupolar: a + mode rotated $45^\circ$ is a $\times$ mode, and a		factor of 2 comes from the fact that the + and \f$\times\f$ modes are
	mode rotated $90^\circ$ is the opposite of itself.) We use the		quadrupolar: a + mode rotated \f$45^\circ\f$ is a \f$\times\f$ mode, and a
	\emph{polarization angle} $\psi$ to define the orientation of the		mode rotated \f$90^\circ\f$ is the opposite of itself.) We use the
	$x$-axis of the polarization basis relative to an Earth-fixed		<em>polarization angle</em> \f$\psi\f$ to define the orientation of the
	reference frame (see the coordinate conventions below). If $\Phi$ is		\f$x\f$-axis of the polarization basis relative to an Earth-fixed
	constant, one can redefine $\psi$ such that $\Phi=0$; however, when		reference frame (see the coordinate conventions below). If \f$\Phi\f$ is
	$\Phi$ changes with time, we would nonetheless like our polarization		constant, one can redefine \f$\psi\f$ such that \f$\Phi=0\f$; however, when
	basis to remain fixed. We therefore retain the constant $\psi$ and		\f$\Phi\f$ changes with time, we would nonetheless like our polarization
	the function $\Phi(t)$ as distinct quantities.		basis to remain fixed. We therefore retain the constant \f$\psi\f$ and
			the function \f$\Phi(t)\f$ as distinct quantities.
	The advantage of this quasiperiodic representation of a gravitational		The advantage of this quasiperiodic representation of a gravitational
	wave is that a physical sampling of the parameters $A_1$, $A_2$,		wave is that a physical sampling of the parameters \f$A_1\f$, \f$A_2\f$,
	$\phi$, and $\Phi$ need only be done on timescales $\Delta		\f$\phi\f$, and \f$\Phi\f$ need only be done on timescales \f$\Delta
	t\lessim\tau$, whereas the actual wave functions $h_{+,\times}$ need		t\lessim\tau\f$, whereas the actual wave functions \f$h_{+,\times}\f$ need
	to be sampled on timescales $\Delta t\lessim1/f$.		to be sampled on timescales \f$\Delta t\lessim1/f\f$.
	The following coordinate conventions are assumed:		The following coordinate conventions are assumed:
	\begin{enumerate}		<ol>
	\item Fig.~7 of~\cite{Will_C:1996} defines standard coordinate		<li> Fig. 7 of [\ref Will_C_1996] defines standard coordinate
	conventions for nonprecessing binaries, and by extension, for any		conventions for nonprecessing binaries, and by extension, for any
	fixed-axis rotating source: If $\bm{\hat{z}}$ points in the direction		fixed-axis rotating source: If \f$\mathbf{\hat{z}}\f$ points in the directi
	of wave propagation (away from the source), and $\bm{\hat{l}}$ points		on
			of wave propagation (away from the source), and \f$\mathbf{\hat{l}}\f$ poin
			ts
	in the (constant) direction of the source's angular momentum vector,		in the (constant) direction of the source's angular momentum vector,
	then the $x$-$y$ coordinates used to define the + and $\times$		then the \f$x\f$-\f$y\f$ coordinates used to define the + and \f$\times\f$
	polarizations are given by $\bm{\hat{x}}=|\csc		polarizations are given by \f$\mathbf{\hat{x}}=|\csc
	i|\bm{\hat{z}}\times\bm{\hat{l}}$ and		i|\mathbf{\hat{z}}\times\mathbf{\hat{l}}\f$ and
	$\bm{\hat{y}}=\bm{\hat{z}}\times\bm{\hat{x}}$, where		\f$\mathbf{\hat{y}}=\mathbf{\hat{z}}\times\mathbf{\hat{x}}\f$, where
	$i=\arccos(\bm{\hat{z}}\cdot\bm{\hat{l}})$ is the inclination angle		\f$i=\arccos(\mathbf{\hat{z}}\cdot\mathbf{\hat{l}})\f$ is the inclination a
	between $\bm{\hat{l}}$ and $\bm{\hat{z}}$. Such a system will		ngle
	generically have $A_1(t)=A(t)(1+\cos^2i)$, $A_2(t)=2A(t)\cos i$,		between \f$\mathbf{\hat{l}}\f$ and \f$\mathbf{\hat{z}}\f$. Such a system w
	$\Phi(t)=0$, and $f(t)>0$ (i.e.\ $\phi(t)$ increasing with time). For		ill
	precessing systems, prescriptions for $\bm{\hat{x}}$ and		generically have \f$A_1(t)=A(t)(1+\cos^2i)\f$, \f$A_2(t)=2A(t)\cos i\f$,
	$\bm{\hat{y}}$ become ambiguous, but they \emph{must} be fixed; the		\f$\Phi(t)=0\f$, and \f$f(t)>0\f$ (i.e.\ \f$\phi(t)\f$ increasing with time
	relations for $A_1$, $A_2$, and $\Phi$ will no longer be maintained.		). For
			precessing systems, prescriptions for \f$\mathbf{\hat{x}}\f$ and
			\f$\mathbf{\hat{y}}\f$ become ambiguous, but they \e must be fixed; the
			relations for \f$A_1\f$, \f$A_2\f$, and \f$\Phi\f$ will no longer be mainta
			ined.</li>
	\item Appendix~B of~\cite{Anderson_W:2000} defines a convention for		<li> Appendix B of [\ref Anderson_W2000] defines a convention for
	the overal polarization angle $\psi$: Let $\bm{\hat{N}}$ be the		the overal polarization angle \f$\psi\f$: Let \f$\mathbf{\hat{N}}\f$ be the
	direction of the Earth's north celestial pole, and define the		direction of the Earth's north celestial pole, and define the
	direction of the \emph{ascending node}		direction of the <em>ascending node</em>
	$\bm{\hat{\Omega}}=|\csc\alpha|\bm{\hat{N}}\times\bm{\hat{z}}$, where		\f$\mathbf{\hat{\Omega}}=|\csc\alpha|\mathbf{\hat{N}}\times\mathbf{\hat{z}}
	$\alpha$ is the right ascension of the source. Then $\psi$ is the		\f$, where
	angle, right-handed about $\bm{\hat{z}}$, from $\bm{\hat{\Omega}}$ to		\f$\alpha\f$ is the right ascension of the source. Then \f$\psi\f$ is the
	$\bm{\hat{x}}$.		angle, right-handed about \f$\mathbf{\hat{z}}\f$, from \f$\mathbf{\hat{\Ome
			ga}}\f$ to
			\f$\mathbf{\hat{x}}\f$.</li>
	\item The direction of propagation of the wave is defined by the right		<li> The direction of propagation of the wave is defined by the right
	ascension $\alpha$ and declination $\delta$ of the \emph{source}, as		ascension \f$\alpha\f$ and declination \f$\delta\f$ of the \e source, as
	seen from the point of measurement. See \verb@SkyCoordinates.h@ for a		seen from the point of measurement. See \ref SkyCoordinates_h for a
	definition of these quantities. We expect that these will be		definition of these quantities. We expect that these will be
	effectively constant for almost any gravitational wave source of		effectively constant for almost any gravitational wave source of
	interest.		interest.</li>
	\end{enumerate}		</ol>
	\paragraph{The polarization response:} The relative strain induced in		\heading{The polarization response:} The relative strain induced in
	the test masses of a detector by a passing gravitational wave depends		the test masses of a detector by a passing gravitational wave depends
	not only on the amplitudes $h_{+,\times}$ of the gravitational wave,		not only on the amplitudes \f$h_{+,\times}\f$ of the gravitational wave,
	but also on the design of the detector and its orientation with		but also on the design of the detector and its orientation with
	relative to the $x$-$y$ coordinate system used to define the + and		relative to the \f$x\f$-\f$y\f$ coordinate system used to define the + and
	$\times$ polarizations. For a given detector, the response to each		\f$\times\f$ polarizations. For a given detector, the response to each
	polarization thus depends on the right ascension $\alpha$, declination		polarization thus depends on the right ascension \f$\alpha\f$, declination
	$\delta$, and polarization angle $\psi$ of the source (which define		\f$\delta\f$, and polarization angle \f$\psi\f$ of the source (which define
	the orientation of the + and $\times$ polarization axes relative to		the orientation of the + and \f$\times\f$ polarization axes relative to
	the Earth), and on the time $t$ (which determines the orientation of		the Earth), and on the time \f$t\f$ (which determines the orientation of
	the detector as the Earth rotates). The strain $h(t)$ induced in the		the detector as the Earth rotates). The strain \f$h(t)\f$ induced in the
	detector is thus given by two polarization response functions		detector is thus given by two polarization response functions
	$F_{+,\times}(\alpha,\delta,\psi;t)$ by:		\f$F_{+,\times}(\alpha,\delta,\psi;t)\f$ by:
	$$		\f[
	h(t) = h_+(t)F_+(\alpha,\delta,\psi;t) +		h(t) = h_+(t)F_+(\alpha,\delta,\psi;t) +
	h_\times(t)F_\times(\alpha,\delta,\psi;t) \; .		h_\times(t)F_\times(\alpha,\delta,\psi;t) \; .
	$$		\f]
	We will not discuss the computation of these functions $F_{+,\times}$,		We will not discuss the computation of these functions \f$F_{+,\times}\f$,
	as these are covered under the header \verb@DetResponse.h@.		as these are covered under the header \ref DetResponse_h.
	\paragraph{The transfer function:} All gravitational wave detectors		\heading{The transfer function:} All gravitational wave detectors
	incorporate a set of analog and digital filters that convert a		incorporate a set of analog and digital filters that convert a
	gravitational excitation on the test masses into a measurable output		gravitational excitation on the test masses into a measurable output
	time series. The effects of these functions are aggregated into a		time series. The effects of these functions are aggregated into a
	complex-valued \emph{transfer function} ${\cal T}(f)$, which gives the		complex-valued <em>transfer function</em> \f${\cal T}(f)\f$, which gives th
	instrumental response (in units of ``counts'' from an		e
	analog$\rightarrow$digital converter) to gravitational waves of unit		instrumental response (in units of "counts" from an
	amplitued at the frequency $f$. Specifically, if the strain exerted		analog\f$\rightarrow\f$digital converter) to gravitational waves of unit
	on the antenna is given by $h(t)=\mathrm{Re}[{\cal H}e^{2\pi ift}]$		amplitued at the frequency \f$f\f$. Specifically, if the strain exerted
	(where the complex amplitude $\cal H$ includes the phase of the wave),		on the antenna is given by \f$h(t)=\mathrm{Re}[{\cal H}e^{2\pi ift}]\f$
			(where the complex amplitude \f$\cal H\f$ includes the phase of the wave),
	then the ADC output of the instrument is given by:		then the ADC output of the instrument is given by:
	$$		\f[
	o(t) = \mathrm{Re}\left[ {\cal T}(f) {\cal H}e^{2\pi ift} \right] \; .		o(t) = \mathrm{Re}\left[ {\cal T}(f) {\cal H}e^{2\pi ift} \right] \; .
	$$		\f]
	The transfer function has a strong frequency dependence in order to		The transfer function has a strong frequency dependence in order to
	``whiten'' the highly-coloured instrumental noise, and thus preserve		"whiten" the highly-coloured instrumental noise, and thus preserve
	instrumental sensitivity across a broad band of frequencies.		instrumental sensitivity across a broad band of frequencies.
	We note that although the transfer function measures the response of		We note that although the transfer function measures the response of
	the instrument to a gravitational wave, the term \emph{response		the instrument to a gravitational wave, the term <em>response
	function} refers to inverse transformation of taking an instrumental		function</em> refers to inverse transformation of taking an instrumental
	response and computing a gravitational waveform; that is, ${\cal		response and computing a gravitational waveform; that is, \f${\cal
	R}(f)=1/{\cal T}(f)$. This confusing bit of nomenclature arises from		R}(f)=1/{\cal T}(f)\f$. This confusing bit of nomenclature arises from
	the fact that most data analysis deals with extracting gravitational		the fact that most data analysis deals with extracting gravitational
	waveforms from the instrumental output, rather than injecting		waveforms from the instrumental output, rather than injecting
	waveforms into the output.		waveforms into the output.
	For quasiperiodic waveforms with a well-defined instantaneous		For quasiperiodic waveforms with a well-defined instantaneous
	frequency $f(t)$ and phase $\phi(t)$, we can compute the response of		frequency \f$f(t)\f$ and phase \f$\phi(t)\f$, we can compute the response o f
	the instrument entirely in the time domain in the adiabatic limit: if		the instrument entirely in the time domain in the adiabatic limit: if
	our instrumental excitation is a linear superposition of waveforms		our instrumental excitation is a linear superposition of waveforms
	$h(t)=\mathrm{Re}[{\cal H}(t)e^{i\phi(t)}]$, then the output is a		\f$h(t)=\mathrm{Re}[{\cal H}(t)e^{i\phi(t)}]\f$, then the output is a
	superposition of waves of the form		superposition of waves of the form
	$$		\f[
	o(t) \approx \mathrm{Re}\left[ {\cal T}\{f(t)\}		o(t) \approx \mathrm{Re}\left[ {\cal T}\{f(t)\}
	{\cal H}(t)e^{i\phi(t)} \right] \; .		{\cal H}(t)e^{i\phi(t)} \right] \; .
	$$		\f]
	This expression is approximate to the extent that ${\cal T}(f)$ varies		This expression is approximate to the extent that \f${\cal T}(f)\f$ varies
	over the range $f\pm1/\tau$, where $\tau$ is the evolution timescale		over the range \f$f\pm1/\tau\f$, where \f$\tau\f$ is the evolution timescal
	of ${\cal H}(t)$ and $f(t)$. Since the transfer function and		e
			of \f${\cal H}(t)\f$ and \f$f(t)\f$. Since the transfer function and
	polarization response (above) are linear operators, we can apply them		polarization response (above) are linear operators, we can apply them
	in either order.		in either order.
	\paragraph{A note on terminology:} We use the word ``coherent'' in the		\heading{A note on terminology:} We use the word "coherent" in the
	name of this header in the loosest possible sense, refering to any		name of this header in the loosest possible sense, refering to any
	wave with a well-defined direction of propagation, whose wave		wave with a well-defined direction of propagation, whose wave
	amplitudes $h_{+,\times}$ are deterministic functions of retarded		amplitudes \f$h_{+,\times}\f$ are deterministic functions of retarded
	time. Given a knowledge of these parameters, such a waveform is		time. Given a knowledge of these parameters, such a waveform is
	amenable to ``coherent'' detection in a network of detectors, through		amenable to "coherent" detection in a network of detectors, through
	time-shifted matched filtering.		time-shifted matched filtering.
	However, coherence is often used to refer to a more restricted class		However, coherence is often used to refer to a more restricted class
	of waveforms that are ``effectively monochromatic'' over some		of waveforms that are "effectively monochromatic" over some
	coherence timescale $t_\mathrm{coh}$; i.e.\ in any timespan		coherence timescale \f$t_\mathrm{coh}\f$; i.e.\ in any timespan
	$t_\mathrm{coh}$ there is a fixed-frequency sinusoid that is never		\f$t_\mathrm{coh}\f$ there is a fixed-frequency sinusoid that is never
	more than $90^\circ$ out of phase with the waveform. This is more		more than \f$90^\circ\f$ out of phase with the waveform. This is more
	retrictive even than our concept of quasiperiodic waves; for		retrictive even than our concept of quasiperiodic waves; for
	smoothly-varying waveforms one has $t_\mathrm{coh}\sim\dot{f}^{-1/2}$,		smoothly-varying waveforms one has \f$t_\mathrm{coh}\sim\dot{f}^{-1/2}\f$,
	which is much shorter than the evolution timescale $\tau\sim		which is much shorter than the evolution timescale \f$\tau\sim
	f/\dot{f}$ (provided $\tau\gg1/f$, as we have assumed).		f/\dot{f}\f$ (provided \f$\tau\gg1/f\f$, as we have assumed).
	******************************************************* </lalLaTeX> */
	#ifndef _SIMULATECOHERENTGW_H
	#define _SIMULATECOHERENTGW_H
	#include <lal/LALStdlib.h>
	#include <lal/DetectorSite.h>
	#include <lal/SkyCoordinates.h>
	#include <lal/LALBarycenter.h>
	#ifdef __cplusplus
	extern "C" {
	#pragma }
	#endif
	NRCSID( SIMULATECOHERENTGWH, "$Id$" );
	/********************************************************** <lalLaTeX>		*/ /**@{ */
	\subsection*{Error conditions}		/** \name Error Codes */ /*@{*/
	****************************************** </lalLaTeX><lalErrTable> */		#define SIMULATECOHERENTGWH_ENUL 1 /**< Unexpected null pointer in argu
	#define SIMULATECOHERENTGWH_ENUL 1		ments */
	#define SIMULATECOHERENTGWH_EBAD 2		#define SIMULATECOHERENTGWH_EBAD 2 /**< A sampling interval is (effecti
	#define SIMULATECOHERENTGWH_ESIG 3		vely) zero */
	#define SIMULATECOHERENTGWH_EDIM 4		#define SIMULATECOHERENTGWH_ESIG 3 /**< Input signal must specify ampli
	#define SIMULATECOHERENTGWH_EMEM 5		tude and phase functions */
	#define SIMULATECOHERENTGWH_EUNIT 6		#define SIMULATECOHERENTGWH_EDIM 4 /**< Amplitude must be a 2-dimension
			al vector */
			#define SIMULATECOHERENTGWH_EMEM 5 /**< Memory allocation error */
			#define SIMULATECOHERENTGWH_EUNIT 6 /**< Bad input units */
			/** @} */
			/** @} */
			/** \cond DONT_DOXYGEN */
	#define SIMULATECOHERENTGWH_MSGENUL "Unexpected null pointer in arguments"		#define SIMULATECOHERENTGWH_MSGENUL "Unexpected null pointer in arguments"
	#define SIMULATECOHERENTGWH_MSGEBAD "A sampling interval is (effectively) zero"		#define SIMULATECOHERENTGWH_MSGEBAD "A sampling interval is (effectively) zero"
	#define SIMULATECOHERENTGWH_MSGESIG "Input signal must specify amplitude a nd phase functions"		#define SIMULATECOHERENTGWH_MSGESIG "Input signal must specify amplitude a nd phase functions"
	#define SIMULATECOHERENTGWH_MSGEDIM "Amplitude must be a 2-dimensional vec tor"		#define SIMULATECOHERENTGWH_MSGEDIM "Amplitude must be a 2-dimensional vec tor"
	#define SIMULATECOHERENTGWH_MSGEMEM "Memory allocation error"		#define SIMULATECOHERENTGWH_MSGEMEM "Memory allocation error"
	#define SIMULATECOHERENTGWH_MSGEUNIT "Bad input units"		#define SIMULATECOHERENTGWH_MSGEUNIT "Bad input units"
	/******************************************** </lalErrTable><lalLaTeX>		/** \endcond */
	\subsection*{Types}
	\subsubsection*{Structure \texttt{CoherentGW}}
	\idx[Type]{CoherentGW}
	\noindent This structure stores a representation of a plane
	gravitational wave propagating from a particular point on the sky.
	Several alternate representations are permitted to allow a more
	natural characterization of quasiperiodic waveforms. The fields are:
	\begin{description}
	\item[\texttt{SkyPosition position}] The location of the source in the
	sky. This should be in equatorial celestial coordinates, but routines
	may be able to do the conversion.
	\item[\texttt{REAL4 psi}] The polarization angle $\psi$, in radians,
	as defined in Appendix~B of~\cite{Anderson_W:2000}.
	\item[\texttt{REAL4TimeVectorSeries *h}] A time-sampled
	two-dimensional vector storing the waveforms $h_+(t)$ and
	$h_\times(t)$, in dimensionless strain.
	\item[\texttt{REAL4TimeVectorSeries *a}] A time-sampled
	two-dimensional vector storing the amplitudes $A_1(t)$ and $A_2(t)$,
	in dimensionless strain.
	\item[\texttt{REAL4TimeSeries *f}] A time-sampled sequence storing the
	instantaneous frequency $f(t)$, in Hz.
	\item[\texttt{REAL8TimeSeries *phi}] A time-sampled sequence storing
	the phase function $\phi(t)$, in radians.
	\item[\texttt{REAL4TimeSeries *shift}] A time-sampled sequence storing
	the polarization shift $\Phi(t)$, in radians.
	\end{description}
	\noindent It is permissible to set only some of the
	\verb@REAL4TimeSeries@ or \verb@REAL4TimeVectorSeries@ fields above,
	but the waveform is treated as being zero except during those times
	when either \verb@h@, or both \verb@a@ and \verb@phi@, are defined.
	Where \verb@shift@ is not specified, it is assumed that $\Phi$ is
	zero; where \verb@f@ is not specified but \verb@phi@ is, $f(t)$ can be
	computed as $\dot{\phi}(t)/2\pi$. Where \verb@f@ and \verb@phi@
	overlap, or where \verb@h@ and any other time series overlap, they
	must be defined consistently.
	******************************************************* </lalLaTeX> */		/** \ingroup SimulateCoherentGW_h
	/** This structure stores a representation of a plane		* This structure stores a representation of a plane
	gravitational wave propagating from a particular point on the sky.		* gravitational wave propagating from a particular point on the sky.
	Several alternate representations are permitted to allow a more		* Several alternate representations are permitted to allow a more
	natural characterization of quasiperiodic waveforms.*/		* natural characterization of quasiperiodic waveforms.
			*
			* \note It is permissible to set only some of the
			* \c REAL4TimeSeries or \c REAL4TimeVectorSeries fields above,
			* but the waveform is treated as being zero except during those times
			* when either \c h, or both \c a and \c phi, are defined.
			* Where \c shift is not specified, it is assumed that \f$\Phi\f$ is
			* zero; where \c f is not specified but \c phi is, \f$f(t)\f$ can be
			* computed as \f$\dot{\phi}(t)/2\pi\f$. Where \c f and \c phi
			* overlap, or where \c h and any other time series overlap, they
			* must be defined consistently.
			*
			*/
	typedef struct tagCoherentGW {		typedef struct tagCoherentGW {
	SkyPosition position; /**< sky position of source */		SWIGLAL_STRUCT(CoherentGW);
	REAL4 psi; /**< polarization angle of source */		SkyPosition position; /**< The location of the source in the sky; thi
	REAL4TimeVectorSeries *h; /**< sampled waveforms \f$h_+, h_\times\f$ */		s should be in equatorial celestial coordinates, but routines may be able t
	REAL4TimeVectorSeries *a; /**< amplitudes \f$A_+, A_\times\f$ */		o do the conversion */
	REAL4TimeSeries *f; /**< instantaneous frequency */		REAL4 psi; /**< The polarization angle \f$\psi\f$, in radi
	REAL8TimeSeries *phi; /**< phase function */		ans, as defined in Appendix B of [\ref Anderson_W2000] */
	REAL4TimeSeries *shift; /**< polarization shift Phi */		REAL4TimeVectorSeries *h; /**< A time-sampled two-dimensional vector stor
			ing the waveforms \f$h_+(t)\f$ and \f$h_\times(t)\f$, in dimensionless stra
			in */
			REAL4TimeVectorSeries *a; /**< A time-sampled two-dimensional vector stor
			ing the amplitudes \f$A_1(t)\f$ and \f$A_2(t)\f$, in dimensionless strain *
			/
			REAL4TimeSeries *f; /**< A time-sampled sequence storing the instan
			taneous frequency \f$f(t)\f$, in Hz. */
			REAL8TimeSeries *phi; /**< A time-sampled sequence storing the phase
			function \f$\phi(t)\f$, in radians */
			REAL4TimeSeries *shift; /**< A time-sampled sequence storing the polari
			zation shift \f$\Phi(t)\f$, in radians */
	} CoherentGW;		} CoherentGW;
	/********************************************************** <lalLaTeX>		/** \ingroup SimulateCoherentGW_h
			* This structure contains information required to determine the response
	\subsubsection*{Structure \texttt{DetectorResponse}}		* of a detector to a gravitational waveform.
	\idx[Type]{DetectorResponse}		*/
	\noindent This structure contains information required to determine
	the response of a detector to a gravitational waveform. The fields
	are:
	\begin{description}
	\item[\texttt{COMPLEX8FrequencySeries *transfer}] The
	frequency-dependent transfer function of the interferometer, in ADC
	counts per unit strain amplitude at any given frequency. If absent,
	the response will be given in raw strain rather than ADC output.
	\item[\texttt{LALDetector *site}] A structure storing site and
	polarization information, used to compute the polarization response
	and the propagation delay. If absent, the response will be computed
	to the plus mode waveform with no time delay.
	\item[\texttt{EphemerisData *ephemerides}] A structure storing the
	positions, velocities, and accelerations of the Earth and Sun centres
	of mass, used to compute the propagation delay to the solar system
	barycentre. If absent, the propagation delay will be computed to the
	Earth centre (rather than a true barycentre).
	\item[\texttt{LIGOTimeGPS heterodyneEpoch}] A reference time for
	heterodyned detector output time series, where the phase of the mixing
	signal is zero. This parameter is only used when generating detector
	output time series with nonzero heterodyne frequency \verb@f0@.
	(Note: This should really be a parameter stored in the
	\verb@TimeSeries@ structure along with \verb@f0@, but it isnt, so we
	have to add it here.)
	\end{description}
	******************************************************* </lalLaTeX> */
	/** This structure contains information required to determine
	the response of a detector to a gravitational waveform. */
	typedef struct tagDetectorResponse {		typedef struct tagDetectorResponse {
	COMPLEX8FrequencySeries *transfer; /**< frequency transfer function */		SWIGLAL_STRUCT(DetectorResponse);
	LALDetector *site; /**< detector location and o		COMPLEX8FrequencySeries *transfer; /**< The frequency-dependent transfe
	rientation */		r function of the interferometer, in ADC counts per unit strain amplitude a
	EphemerisData *ephemerides; /**< Earth and Sun ephemerid		t any given frequency;
	es */		* if absent, the response will be
	LIGOTimeGPS heterodyneEpoch; /**< reference time for hete		given in raw strain rather than ADC output */
	rodyning */		LALDetector *site; /**< A structure storing sit
			e and polarization information, used to compute the polarization response a
			nd the propagation delay;
			* if absent, the response will be
			computed to the plus mode waveform with no time delay */
			EphemerisData *ephemerides; /**< A structure storing the
			positions, velocities, and accelerations of the Earth and Sun centres of m
			ass, used to compute
			* the propagation delay to the sol
			ar system barycentre;
			* if absent, the propagation delay
			will be computed to the Earth centre (rather than a true barycentre) */
			LIGOTimeGPS heterodyneEpoch; /**< A reference time for he
			terodyned detector output time series, where the phase of the mixing signal
			is zero.
			* This parameter is only used when
			generating detector output time series with nonzero heterodyne frequency \
			c f0.
			* (Note: This should really be a p
			arameter stored in the \c TimeSeries structure along with \c f0, but it isn
			t, so we
			* have to add it here.)
			*/
	} DetectorResponse;		} DetectorResponse;
	/* <lalLaTeX>
	\vfill{\footnotesize\input{SimulateCoherentGWHV}}
	</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{SimulateCoherentGWC}
	</lalLaTeX> */
	void		void
	LALSimulateCoherentGW( LALStatus *status,		LALSimulateCoherentGW( LALStatus *status,
	REAL4TimeSeries *output,		REAL4TimeSeries *output,
	CoherentGW *input,		CoherentGW *input,
	DetectorResponse *detector );		DetectorResponse *detector );
	void		#if 0
	LALSimulateCoherentGW_exp (LALStatus *status,		{ /* so that editors will match succeeding brace */
	REAL4TimeSeries *output,		#elif defined(__cplusplus)
	CoherentGW *input,
	DetectorResponse *detector );
	/* <lalLaTeX>
	%\newpage\input{SimulateCoherentGWTestC}
	</lalLaTeX> */
	#ifdef __cplusplus
	#pragma {
	}		}
	#endif		#endif
	#endif /* _SIMULATECOHERENTGW_H */		#endif /* _SIMULATECOHERENTGW_H */
End of changes. 58 change blocks.
	297 lines changed or deleted		265 lines changed or added

	SkyCoordinates.h		SkyCoordinates.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
	*/		*/
	/** \file
	* \ingroup SkyCoordinates
	* \author Creighton, T. D.
	* \date 2002
	* \brief This header covers routines to perform coordinate transformation
	s
	* among the various spherical coordinate systems used in astronomy.
	*/
	#ifndef _SKYCOORDINATES_H		#ifndef _SKYCOORDINATES_H
	#define _SKYCOORDINATES_H		#define _SKYCOORDINATES_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( SKYCOORDINATESH, "$Id$" );		NRCSID( SKYCOORDINATESH, "$Id$" );
	/** \name Error codes */		/** \addtogroup SkyCoordinates_h
	/*@{*/		*
	#define SKYCOORDINATESH_ENUL 1		* @{
	#define SKYCOORDINATESH_ESYS 2		* \defgroup CelestialCoordinates_c Module CelestialCoordinates.c
	#define SKYCOORDINATESH_EZERO 3		* \defgroup TerrestrialCoordinates_c Module TerrestrialCoordinates.c
	#define SKYCOORDINATESH_ESING 4		* \defgroup SkyCoordinates_c Module SkyCoordinates.c
			*
			*/
			/** \name Error codes *//**@{*/
			#define SKYCOORDINATESH_ENUL 1 /**< Unexpected null pointer in argu
			ments */
			#define SKYCOORDINATESH_ESYS 2 /**< Wrong coordinate system in inpu
			t */
			#define SKYCOORDINATESH_EZERO 3 /**< Angular coordinates undefined a
			t origin */
			#define SKYCOORDINATESH_ESING 4 /**< Point is inside singular ellips
			oid */
			/*@}*/
			/** \cond DONT_DOXYGEN */
	#define SKYCOORDINATESH_MSGENUL "Unexpected null pointer in arguments"		#define SKYCOORDINATESH_MSGENUL "Unexpected null pointer in arguments"
	#define SKYCOORDINATESH_MSGESYS "Wrong coordinate system in input"		#define SKYCOORDINATESH_MSGESYS "Wrong coordinate system in input"
	#define SKYCOORDINATESH_MSGEZERO "Angular coordinates undefined at origin"		#define SKYCOORDINATESH_MSGEZERO "Angular coordinates undefined at origin"
	#define SKYCOORDINATESH_MSGESING "Point is inside singular ellipsoid"		#define SKYCOORDINATESH_MSGESING "Point is inside singular ellipsoid"
	/*@}*/		/** \endcond */
	/*---------- exported types ---------- */		/*---------- exported types ---------- */
	/** This enumerated type is used to identify data as being in one of the		/** This enumerated type is used to identify data as being in one of the
	* coordinate systems discussed in \ref SkyCoordinates. */		* coordinate systems discussed in \ref SkyCoordinates. */
	typedef enum {		typedef enum {
	COORDINATESYSTEM_HORIZON, /**< A horizon coordinate system. */		COORDINATESYSTEM_HORIZON, /**< A horizon coordinate system. */
	COORDINATESYSTEM_GEOGRAPHIC, /**< The Earth-fixed geographic coordinate s ystem. */		COORDINATESYSTEM_GEOGRAPHIC, /**< The Earth-fixed geographic coordinate s ystem. */
	COORDINATESYSTEM_EQUATORIAL, /**< The sky-fixed equatorial coordinate sys tem. */		COORDINATESYSTEM_EQUATORIAL, /**< The sky-fixed equatorial coordinate sys tem. */
	COORDINATESYSTEM_ECLIPTIC, /**< The ecliptic coordinate system. */		COORDINATESYSTEM_ECLIPTIC, /**< The ecliptic coordinate system. */
	COORDINATESYSTEM_GALACTIC /**< The galactic coordinate system. */		COORDINATESYSTEM_GALACTIC /**< The galactic coordinate system. */
	} CoordinateSystem;		} CoordinateSystem;
	/** This structure stores the two spherical coordinates of a sky position;		/** This structure stores the two spherical coordinates of a sky position;
	* ie a generic latitude and longitude; the structure is not defined		* ie a generic latitude and longitude; the structure is not defined
	* specific to a particular coordinate system, but maintains a tag		* specific to a particular coordinate system, but maintains a tag
	* indicating which coordinate system it is expressed in.		* indicating which coordinate system it is expressed in.
	*/		*/
	typedef struct tagSkyPosition {		typedef struct tagSkyPosition {
			SWIGLAL_STRUCT(SkyPosition);
	REAL8 longitude; /**< The longitudinal coordinate (in radians ), as defined above.*/		REAL8 longitude; /**< The longitudinal coordinate (in radians ), as defined above.*/
	REAL8 latitude; /**< The latitudinal coordinate (in radians) , as defined above. */		REAL8 latitude; /**< The latitudinal coordinate (in radians) , as defined above. */
	CoordinateSystem system; /**< The coordinate system in which latitude /longitude are expressed. */		CoordinateSystem system; /**< The coordinate system in which latitude /longitude are expressed. */
	} SkyPosition;		} SkyPosition;
	/** This structure stores the location of a point on (or near) the surface		/** This structure stores the location of a point on (or near) the surface
	* of the Earth in both geodetic and geocentric coordinates, as described		* of the Earth in both geodetic and geocentric coordinates, as described
	* in TerrestrialCoordinates.c .		* in TerrestrialCoordinates.c .
	*/		*/
	typedef struct tagEarthPosition {		typedef struct tagEarthPosition {
			SWIGLAL_STRUCT(EarthPosition);
	SkyPosition geodetic; /**< The geographic coordinates of the		SkyPosition geodetic; /**< The geographic coordinates of the
	* upward vertical direction from the point; that is, the point's		* upward vertical direction from the point; that is, the point's
	* <em>geodetic</em> latitude and longitude. */		* <em>geodetic</em> latitude and longitude. */
	REAL8 elevation; /**< The vertical distance of the point abov e the reference ellipsoid,		REAL8 elevation; /**< The vertical distance of the point abov e the reference ellipsoid,
	* in metres.*/		* in metres.*/
	REAL8 x, y, z; /**< The Earth-fixed geocentric Cartesian co ordinates of the point,		REAL8 x, y, z; /**< The Earth-fixed geocentric Cartesian co ordinates of the point,
	*in metres.*/		*in metres.*/
	REAL8 radius; /**< The distance of the point from the geocentre, in metres. */		REAL8 radius; /**< The distance of the point from the geocentre, in metres. */
	SkyPosition geocentric; /**< The geographic coordinates of the dire ction from the centre		SkyPosition geocentric; /**< The geographic coordinates of the dire ction from the centre
	* of the Earth through the point; that is, the point's		* of the Earth through the point; that is, the point's
	* <em>geocentric</em> latitude and longitud e.*/		* <em>geocentric</em> latitude and longitud e.*/
	} EarthPosition;		} EarthPosition;
	/** This structure stores parameters for the function <tt>LALConvertSkyPosi tion()</tt>.		/** This structure stores parameters for the function <tt>LALConvertSkyPosi tion()</tt>.
	*/		*/
	typedef struct tagConvertSkyParams {		typedef struct tagConvertSkyParams {
			SWIGLAL_STRUCT(ConvertSkyParams);
	CoordinateSystem system; /**< The coordinate system to which one is transforming. */		CoordinateSystem system; /**< The coordinate system to which one is transforming. */
	SkyPosition *zenith; /**< The position of the zenith of the horiz on coordinate system;		SkyPosition *zenith; /**< The position of the zenith of the horiz on coordinate system;
	* may be <tt>NULL</tt> if one is neither co nverting to nor from		* may be <tt>NULL</tt> if one is neither co nverting to nor from
	* a horizon system. */		* a horizon system. */
	LIGOTimeGPS *gpsTime; /**< The GPS time for conversions be tween Earth-fixed and		LIGOTimeGPS *gpsTime; /**< The GPS time for conversions be tween Earth-fixed and
	* sky-fixed coordinates; may be <tt>NULL</t t> if no such conversion		* sky-fixed coordinates; may be <tt>NULL</t t> if no such conversion
	* is required (or if one is transforming to or from horizon		* is required (or if one is transforming to or from horizon
	* coordinates and <tt>*zenith</tt> is given in the sky-fixed		* coordinates and <tt>*zenith</tt> is given in the sky-fixed
	* equatorial system). */		* equatorial system). */
	} ConvertSkyParams;		} ConvertSkyParams;
			/** @} */
	/* ---------- Function prototypes ---------- */		/* ---------- Function prototypes ---------- */
	void		void
	LALGalacticToEquatorial( LALStatus *,		LALGalacticToEquatorial( LALStatus *,
	SkyPosition *output,		SkyPosition *output,
	SkyPosition *input );		SkyPosition *input );
	void		void
	LALEquatorialToGalactic( LALStatus *,		LALEquatorialToGalactic( LALStatus *,
	SkyPosition *output,		SkyPosition *output,
End of changes. 9 change blocks.
	16 lines changed or deleted		30 lines changed or added

	Skymap.h		Skymap.h
	skipping to change at line 24		skipping to change at line 24
	* Public License for more details.		* Public License for more details.
	*		*
	* You should have received a copy of the GNU General Public License along		* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,		* with this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/		*/
	#ifndef SKYMAP_H		#ifndef SKYMAP_H
	#define SKYMAP_H		#define SKYMAP_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	#include <lal/LALDetectors.h>		#include <lal/LALDetectors.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	NRCSID(EPSEARCHH, "$Id$");		NRCSID(EPSEARCHH, "$Id$");
	// Manipulate log-represented values without overflowing		// Manipulate log-represented values without overflowing
	skipping to change at line 61		skipping to change at line 66
	// LAL_TAMA_300_DETECTOR = 0		// LAL_TAMA_300_DETECTOR = 0
	// LAL_VIRGO_DETECTOR = 1		// LAL_VIRGO_DETECTOR = 1
	// LAL_GEO_600_DETECTOR = 2		// LAL_GEO_600_DETECTOR = 2
	// LAL_LHO_2K_DETECTOR = 3		// LAL_LHO_2K_DETECTOR = 3
	// LAL_LHO_4K_DETECTOR = 4		// LAL_LHO_4K_DETECTOR = 4
	// LAL_LLO_4K_DETECTOR = 5		// LAL_LLO_4K_DETECTOR = 5
	// Struct to store basic properties of the analysis: the sample rate, and		// Struct to store basic properties of the analysis: the sample rate, and
	// the detectors involved (described by their LAL ID numbers)		// the detectors involved (described by their LAL ID numbers)
	typedef struct		typedef struct tagXLALSkymapPlanType
	{		{
			SWIGLAL_STRUCT(XLALSkymapPlanType);
	int sampleFrequency;		int sampleFrequency;
	int n;		int n;
	LALDetector site[XLALSKYMAP_N];		LALDetector site[XLALSKYMAP_N];
	} XLALSkymapPlanType;		} XLALSkymapPlanType;
	void XLALSkymapPlanConstruct(		void XLALSkymapPlanConstruct(
	int sampleFrequency,		int sampleFrequency,
	int n,		int n,
	int* detectors,		int* detectors,
	XLALSkymapPlanType* plan		XLALSkymapPlanType* plan
	);		);
	// Struct to store reuseable pre-computed quantities for a specific		// Struct to store reuseable pre-computed quantities for a specific
	// direction, set of detectors, and sample rate		// direction, set of detectors, and sample rate
	typedef struct		typedef struct tagXLALSkymapDirectionPropertiesType
	{		{
			SWIGLAL_STRUCT(XLALSkymapDirectionPropertiesType);
	double f[XLALSKYMAP_N][2];		double f[XLALSKYMAP_N][2];
	double delay[XLALSKYMAP_N];		double delay[XLALSKYMAP_N];
	} XLALSkymapDirectionPropertiesType;		} XLALSkymapDirectionPropertiesType;
	void XLALSkymapDirectionPropertiesConstruct(		void XLALSkymapDirectionPropertiesConstruct(
	XLALSkymapPlanType* plan,		XLALSkymapPlanType* plan,
	double* direction,		double* direction,
	XLALSkymapDirectionPropertiesType* properties		XLALSkymapDirectionPropertiesType* properties
	);		);
	// Struct to store reuseable pre-computed kernel for a specific direction,		// Struct to store reuseable pre-computed kernel for a specific direction,
	// power spectra, and sample rate		// power spectra, and sample rate
	typedef struct		typedef struct tagXLALSkymapKernelType
	{		{
			SWIGLAL_STRUCT(XLALSkymapKernelType);
	double k[XLALSKYMAP_N][XLALSKYMAP_N];		double k[XLALSKYMAP_N][XLALSKYMAP_N];
	double logNormalization;		double logNormalization;
	} XLALSkymapKernelType;		} XLALSkymapKernelType;
	void XLALSkymapKernelConstruct(		void XLALSkymapKernelConstruct(
	XLALSkymapPlanType* plan,		XLALSkymapPlanType* plan,
	XLALSkymapDirectionPropertiesType* properties,		XLALSkymapDirectionPropertiesType* properties,
	double* wSw,		double* wSw,
	XLALSkymapKernelType* kernel		XLALSkymapKernelType* kernel
	);		);
End of changes. 7 change blocks.
	3 lines changed or deleted		11 lines changed or added

	StreamInput.h		StreamInput.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
	*/		*/
	/********************************** <lalVerbatim file="StreamInputHV">		/**
	Author: Creighton, T. D.		\author Creighton, T. D.
	$Id$		\file
	**************************************************** </lalVerbatim> */
	/********************************************************** <lalLaTeX>
	\section{Header \texttt{StreamInput.h}}		\heading{Header \ref StreamInput.h}
	\label{s:StreamInput.h}		\latexonly\label{s_StreamInput_h}\endlatexonly
	Provides routines to read data from an open stream and store it in LAL		Provides routines to read data from an open stream and store it in LAL
	data structures.		data structures.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include "StreamInput.h"		#include "StreamInput.h"
	\end{verbatim}		\endcode
	\noindent This header provides prototypes for routines that construct		This header provides prototypes for routines that construct
	LAL data structures using the data from a file (or other I/O) stream.		LAL data structures using the data from a file (or other I/O) stream.
	The routines do not provide a system-level interface to create files		The routines do not provide a system-level interface to create files
	and open or close file streams; they simply assume that they have been		and open or close file streams; they simply assume that they have been
	passed an open, readable stream. Nonetheless, because they involve		passed an open, readable stream. Nonetheless, because they involve
	I/O stream manipulation, these routines are placed in the		I/O stream manipulation, these routines are placed in the
	\verb@lalsupport@ library rather than in \verb@lal@ proper.		\c lalsupport library rather than in \c lal proper.
	The routines in \verb@StreamVectorInput.c@ and		The routines in \ref StreamVectorInput.c and
	\verb@StreamVectorSequenceInput.c@ are compartmentalized in such a way		\ref StreamVectorSequenceInput.c are compartmentalized in such a way
	that they can easily be converted if the LAL specification later		that they can easily be converted if the LAL specification later
	changes the way in which I/O streams are handled. In partucular, the		changes the way in which I/O streams are handled. In partucular, the
	only file I/O commands used are \verb@fgets()@ and \verb@feof()@.		only file I/O commands used are <tt>fgets()</tt> and <tt>feof()</tt>.
	Thus the upgrade would involve only the following global changes:		Thus the upgrade would involve only the following global changes:
	\begin{enumerate}		<ol>
	\item Replace all occurrences of \verb@FILE *@ with the name of the		<li> Replace all occurrences of <tt>FILE *</tt> with the name of the
	LAL I/O stream pointer type.		LAL I/O stream pointer type.</li>
	\item Replace all occurrences of \verb@fgets()@ and \verb@feof()@ with		<li> Replace all occurrences of <tt>fgets()</tt> and <tt>feof()</tt> with
	equivalent LAL functions.		equivalent LAL functions.</li>
	\end{enumerate}		</ol>
	In particular, there is no need to translate routines such as		In particular, there is no need to translate routines such as
	\verb@fscanf()@; one should simply read data into a LAL		<tt>fscanf()</tt>; one should simply read data into a LAL
	\verb@CHARVector@ and then use \verb@sscanf()@ to format the input.		\c CHARVector and then use <tt>sscanf()</tt> to format the input.
	This is the approach used in the numerical input routines in		This is the approach used in the numerical input routines in
	\verb@StreamVectorInput.c@ and \verb@StreamVectorSequenceInput.c@.		\ref StreamVectorInput.c and \ref StreamVectorSequenceInput.c.
	The routines in \verb@StreamSequenceInput.c@ are less robust but much		The routines in \ref StreamSequenceInput.c are less robust but much
	more efficient: they use \verb@fscanf()@ to parse the input stream		more efficient: they use <tt>fscanf()</tt> to parse the input stream
	directly. They are intended primarily for test programs that may need		directly. They are intended primarily for test programs that may need
	to read large datafiles of undetermined length. The routines in		to read large datafiles of undetermined length. The routines in
	\verb@StreamSeriesInput.c@ and \verb@StreamGridInput.c@ also parse the		\ref StreamSeriesInput.c and \ref StreamGridInput.c also parse the
	input stream directly using \verb@fscanf()@, to avoid potentially		input stream directly using <tt>fscanf()</tt>, to avoid potentially
	crippling computational overhead.		crippling computational overhead.
	******************************************************* </lalLaTeX> */		*/
	#ifndef _STREAMINPUT_H		#ifndef _STREAMINPUT_H
	#define _STREAMINPUT_H		#define _STREAMINPUT_H
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/Grid.h>		#include <lal/Grid.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID(STREAMINPUTH,"$Id$");		NRCSID(STREAMINPUTH,"$Id$");
	/********************************************************** <lalLaTeX>		/**
	\subsection*{Error conditions}		\heading{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		\name Error Codes */ /*@{*/
	#define STREAMINPUTH_ENUL 1		#define STREAMINPUTH_ENUL 1
	#define STREAMINPUTH_EOUT 2		#define STREAMINPUTH_EOUT 2
	#define STREAMINPUTH_EMEM 3		#define STREAMINPUTH_EMEM 3
	#define STREAMINPUTH_ELEN 4		#define STREAMINPUTH_ELEN 4
	#define STREAMINPUTH_ESLEN 5		#define STREAMINPUTH_ESLEN 5
	#define STREAMINPUTH_EVLEN 6		#define STREAMINPUTH_EVLEN 6
	#define STREAMINPUTH_EDLEN 7		#define STREAMINPUTH_EDLEN 7
	#define STREAMINPUTH_EDIM 8		#define STREAMINPUTH_EDIM 8
	#define STREAMINPUTH_EFMT 9		#define STREAMINPUTH_EFMT 9
	#define STREAMINPUTH_EBUF 10		#define STREAMINPUTH_EBUF 10
	skipping to change at line 110		skipping to change at line 107
	#define STREAMINPUTH_MSGENUL "Unexpected null pointer in arguments"		#define STREAMINPUTH_MSGENUL "Unexpected null pointer in arguments"
	#define STREAMINPUTH_MSGEOUT "Output handle points to a non-null pointer"		#define STREAMINPUTH_MSGEOUT "Output handle points to a non-null pointer"
	#define STREAMINPUTH_MSGEMEM "Memory allocation error"		#define STREAMINPUTH_MSGEMEM "Memory allocation error"
	#define STREAMINPUTH_MSGELEN "No numbers were read"		#define STREAMINPUTH_MSGELEN "No numbers were read"
	#define STREAMINPUTH_MSGESLEN "Not enough numbers read to fill sequence"		#define STREAMINPUTH_MSGESLEN "Not enough numbers read to fill sequence"
	#define STREAMINPUTH_MSGEVLEN "Could not determine complex vectorLength"		#define STREAMINPUTH_MSGEVLEN "Could not determine complex vectorLength"
	#define STREAMINPUTH_MSGEDLEN "Dimension lengths inconsistent or not given"		#define STREAMINPUTH_MSGEDLEN "Dimension lengths inconsistent or not given"
	#define STREAMINPUTH_MSGEDIM "Inconsistent or non-positive arrayDim value"		#define STREAMINPUTH_MSGEDIM "Inconsistent or non-positive arrayDim value"
	#define STREAMINPUTH_MSGEFMT "Badly formatted number"		#define STREAMINPUTH_MSGEFMT "Badly formatted number"
	#define STREAMINPUTH_MSGEBUF "BUFFSIZE not a multiple of largest complex t ype size"		#define STREAMINPUTH_MSGEBUF "BUFFSIZE not a multiple of largest complex t ype size"
	/******************************************** </lalErrTable><lalLaTeX>		/*@}*//**
	\subsection*{Types}
	******************************************************* </lalLaTeX> */		\heading{Types}
	/* <lalLaTeX>		*/
	\vfill{\footnotesize\input{StreamInputHV}}
	</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{StreamVectorInputC}
	</lalLaTeX> */
	void		void
	LALCHARReadVector( LALStatus *status, CHARVector **vector, FILE *stream );		LALCHARReadVector( LALStatus *status, CHARVector **vector, FILE *stream );
	void		void
	LALI2ReadVector( LALStatus *status, INT2Vector **vector, FILE *stream, BOO LEAN strict );		LALI2ReadVector( LALStatus *status, INT2Vector **vector, FILE *stream, BOO LEAN strict );
	void		void
	LALI4ReadVector( LALStatus *status, INT4Vector **vector, FILE *stream, BOO LEAN strict );		LALI4ReadVector( LALStatus *status, INT4Vector **vector, FILE *stream, BOO LEAN strict );
	void		void
	skipping to change at line 152		skipping to change at line 142
	void		void
	LALU8ReadVector( LALStatus *status, UINT8Vector **vector, FILE *stream, BO OLEAN strict );		LALU8ReadVector( LALStatus *status, UINT8Vector **vector, FILE *stream, BO OLEAN strict );
	void		void
	LALSReadVector( LALStatus *status, REAL4Vector **vector, FILE *stream, BOO LEAN strict );		LALSReadVector( LALStatus *status, REAL4Vector **vector, FILE *stream, BOO LEAN strict );
	void		void
	LALDReadVector( LALStatus *status, REAL8Vector **vector, FILE *stream, BOO LEAN strict );		LALDReadVector( LALStatus *status, REAL8Vector **vector, FILE *stream, BOO LEAN strict );
	/* <lalLaTeX>
	\newpage\input{StreamVectorSequenceInputC}
	</lalLaTeX> */
	void		void
	LALCHARReadVectorSequence( LALStatus *status, CHARVectorSequence **sequenc e, FILE *stream );		LALCHARReadVectorSequence( LALStatus *status, CHARVectorSequence **sequenc e, FILE *stream );
	void		void
	LALI2ReadVectorSequence( LALStatus *status, INT2VectorSequence **sequence, FILE *stream );		LALI2ReadVectorSequence( LALStatus *status, INT2VectorSequence **sequence, FILE *stream );
	void		void
	LALI4ReadVectorSequence( LALStatus *status, INT4VectorSequence **sequence, FILE *stream );		LALI4ReadVectorSequence( LALStatus *status, INT4VectorSequence **sequence, FILE *stream );
	void		void
	skipping to change at line 182		skipping to change at line 169
	void		void
	LALU8ReadVectorSequence( LALStatus *status, UINT8VectorSequence **sequence , FILE *stream );		LALU8ReadVectorSequence( LALStatus *status, UINT8VectorSequence **sequence , FILE *stream );
	void		void
	LALSReadVectorSequence( LALStatus *status, REAL4VectorSequence **sequence, FILE *stream );		LALSReadVectorSequence( LALStatus *status, REAL4VectorSequence **sequence, FILE *stream );
	void		void
	LALDReadVectorSequence( LALStatus *status, REAL8VectorSequence **sequence, FILE *stream );		LALDReadVectorSequence( LALStatus *status, REAL8VectorSequence **sequence, FILE *stream );
	/* <lalLaTeX>
	\newpage\input{StreamSequenceInputC}
	</lalLaTeX> */
	void		void
	LALCHARReadSequence( LALStatus *status, CHARSequence **sequence, FILE *stre am );		LALCHARReadSequence( LALStatus *status, CHARSequence **sequence, FILE *stre am );
	void		void
	LALI2ReadSequence( LALStatus *status, INT2Sequence **sequence, FILE *stream );		LALI2ReadSequence( LALStatus *status, INT2Sequence **sequence, FILE *stream );
	void		void
	LALI4ReadSequence( LALStatus *status, INT4Sequence **sequence, FILE *stream );		LALI4ReadSequence( LALStatus *status, INT4Sequence **sequence, FILE *stream );
	void		void
	skipping to change at line 218		skipping to change at line 202
	void		void
	LALDReadSequence( LALStatus *status, REAL8Sequence **sequence, FILE *stream );		LALDReadSequence( LALStatus *status, REAL8Sequence **sequence, FILE *stream );
	void		void
	LALCReadSequence( LALStatus *status, COMPLEX8Sequence **sequence, FILE *str eam );		LALCReadSequence( LALStatus *status, COMPLEX8Sequence **sequence, FILE *str eam );
	void		void
	LALZReadSequence( LALStatus *status, COMPLEX16Sequence **sequence, FILE *st ream );		LALZReadSequence( LALStatus *status, COMPLEX16Sequence **sequence, FILE *st ream );
	/* <lalLaTeX>
	\newpage\input{StreamSeriesInputC}
	</lalLaTeX> */
	void		void
	LALI2ReadTSeries( LALStatus *status, INT2TimeSeries *series, FILE *stream ) ;		LALI2ReadTSeries( LALStatus *status, INT2TimeSeries *series, FILE *stream ) ;
	void		void
	LALI4ReadTSeries( LALStatus *status, INT4TimeSeries *series, FILE *stream ) ;		LALI4ReadTSeries( LALStatus *status, INT4TimeSeries *series, FILE *stream ) ;
	void		void
	LALI8ReadTSeries( LALStatus *status, INT8TimeSeries *series, FILE *stream ) ;		LALI8ReadTSeries( LALStatus *status, INT8TimeSeries *series, FILE *stream ) ;
	void		void
	LALU2ReadTSeries( LALStatus *status, UINT2TimeSeries *series, FILE *stream );		LALU2ReadTSeries( LALStatus *status, UINT2TimeSeries *series, FILE *stream );
	void		void
	LALU4ReadTSeries( LALStatus *status, UINT4TimeSeries *series, FILE *stream );		LALU4ReadTSeries( LALStatus *status, UINT4TimeSeries *series, FILE *stream );
	skipping to change at line 305		skipping to change at line 286
	LALU8ReadFSeries( LALStatus *status, UINT8FrequencySeries *series, FILE *st ream );		LALU8ReadFSeries( LALStatus *status, UINT8FrequencySeries *series, FILE *st ream );
	void		void
	LALSReadFSeries( LALStatus *status, REAL4FrequencySeries *series, FILE *str eam );		LALSReadFSeries( LALStatus *status, REAL4FrequencySeries *series, FILE *str eam );
	void		void
	LALDReadFSeries( LALStatus *status, REAL8FrequencySeries *series, FILE *str eam );		LALDReadFSeries( LALStatus *status, REAL8FrequencySeries *series, FILE *str eam );
	void		void
	LALCReadFSeries( LALStatus *status, COMPLEX8FrequencySeries *series, FILE * stream );		LALCReadFSeries( LALStatus *status, COMPLEX8FrequencySeries *series, FILE * stream );
	void		void
	LALZReadFSeries( LALStatus *status, COMPLEX16FrequencySeries *series, FILE *stream );		LALZReadFSeries( LALStatus *status, COMPLEX16FrequencySeries *series, FILE *stream );
	/* <lalLaTeX>
	\newpage\input{StreamGridInputC}
	</lalLaTeX> */
	void		void
	LALI2ReadGrid( LALStatus *status, INT2Grid **grid, FILE *stream );		LALI2ReadGrid( LALStatus *status, INT2Grid **grid, FILE *stream );
	void		void
	LALI4ReadGrid( LALStatus *status, INT4Grid **grid, FILE *stream );		LALI4ReadGrid( LALStatus *status, INT4Grid **grid, FILE *stream );
	void		void
	LALI8ReadGrid( LALStatus *status, INT8Grid **grid, FILE *stream );		LALI8ReadGrid( LALStatus *status, INT8Grid **grid, FILE *stream );
	void		void
	LALU2ReadGrid( LALStatus *status, UINT2Grid **grid, FILE *stream );		LALU2ReadGrid( LALStatus *status, UINT2Grid **grid, FILE *stream );
	void		void
	LALU4ReadGrid( LALStatus *status, UINT4Grid **grid, FILE *stream );		LALU4ReadGrid( LALStatus *status, UINT4Grid **grid, FILE *stream );
	skipping to change at line 329		skipping to change at line 307
	LALU8ReadGrid( LALStatus *status, UINT8Grid **grid, FILE *stream );		LALU8ReadGrid( LALStatus *status, UINT8Grid **grid, FILE *stream );
	void		void
	LALSReadGrid( LALStatus *status, REAL4Grid **grid, FILE *stream );		LALSReadGrid( LALStatus *status, REAL4Grid **grid, FILE *stream );
	void		void
	LALDReadGrid( LALStatus *status, REAL8Grid **grid, FILE *stream );		LALDReadGrid( LALStatus *status, REAL8Grid **grid, FILE *stream );
	void		void
	LALCReadGrid( LALStatus *status, COMPLEX8Grid **grid, FILE *stream );		LALCReadGrid( LALStatus *status, COMPLEX8Grid **grid, FILE *stream );
	void		void
	LALZReadGrid( LALStatus *status, COMPLEX16Grid **grid, FILE *stream );		LALZReadGrid( LALStatus *status, COMPLEX16Grid **grid, FILE *stream );
	/* <lalLaTeX>
	\newpage\input{StreamInputTestC}
	\newpage\input{StreamSeriesInputTestC}
	</lalLaTeX> */
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	#endif /* _STREAMINPUT_H */		#endif /* _STREAMINPUT_H */
End of changes. 24 change blocks.
	60 lines changed or deleted		33 lines changed or added

	StreamOutput.h		StreamOutput.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
	*/		*/
	/********************************* <lalVerbatim file="StreamOutputHV">		/**
	Author: Creighton, T. D.		\author Creighton, T. D.
	$Id$		\file
	**************************************************** </lalVerbatim> */
	/********************************************************** <lalLaTeX>
	\section{Header \texttt{StreamOutput.h}}		\heading{Header \ref StreamOutput.h}
	\label{s:StreamOutput.h}		\latexonly\label{s_StreamOutput_h}\endlatexonly
	Provides routines to write data from LAL data structures to an open		Provides routines to write data from LAL data structures to an open
	stream.		stream.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include "StreamOutput.h"		#include "StreamOutput.h"
	\end{verbatim}		\endcode
	\noindent This header provides prototypes for routines that write the		This header provides prototypes for routines that write the
	contents of LAL time/frequency series structures or grid structures to		contents of LAL time/frequency series structures or grid structures to
	a file (or other I/O) stream, in a standard format. The routines do		a file (or other I/O) stream, in a standard format. The routines do
	not provide a system-level interface to create files and open or close		not provide a system-level interface to create files and open or close
	file streams; they simply assume that they have been passed an open,		file streams; they simply assume that they have been passed an open,
	writeable stream. Nonetheless, because they involve I/O stream		writeable stream. Nonetheless, because they involve I/O stream
	manipulation, these routines are placed in the \verb@lalsupport@		manipulation, these routines are placed in the \c lalsupport
	library rather than in \verb@lal@ proper.		library rather than in \c lal proper.
	******************************************************* </lalLaTeX> */		*/
	#ifndef _STREAMOUTPUT_H		#ifndef _STREAMOUTPUT_H
	#define _STREAMOUTPUT_H		#define _STREAMOUTPUT_H
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/Grid.h>		#include <lal/Grid.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID( STREAMOUTPUTH, "$Id$" );		NRCSID( STREAMOUTPUTH, "$Id$" );
	/********************************************************** <lalLaTeX>		/**
	\subsection*{Error conditions}		\heading{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		\name Error Codes */ /*@{*/
	#define STREAMOUTPUTH_ENUL 1		#define STREAMOUTPUTH_ENUL 1
	#define STREAMOUTPUTH_EPRN 2		#define STREAMOUTPUTH_EPRN 2
	#define STREAMOUTPUTH_MSGENUL "Unexpected null pointer in arguments"		#define STREAMOUTPUTH_MSGENUL "Unexpected null pointer in arguments"
	#define STREAMOUTPUTH_MSGEPRN "Print statement failed"		#define STREAMOUTPUTH_MSGEPRN "Print statement failed"
	/******************************************** </lalErrTable><lalLaTeX>		/*@}*//**
	\subsection*{Types}
	******************************************************* </lalLaTeX> */		\heading{Types}
	/* <lalLaTeX>		*/
	\vfill{\footnotesize\input{StreamOutputHV}}
	</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	/* <lalLaTeX>
	\newpage\input{StreamSeriesOutputC}
	</lalLaTeX> */
	void		void
	LALI2WriteTSeries( LALStatus *status, FILE *stream, INT2TimeSeries *series );		LALI2WriteTSeries( LALStatus *status, FILE *stream, INT2TimeSeries *series );
	void		void
	LALI4WriteTSeries( LALStatus *status, FILE *stream, INT4TimeSeries *series );		LALI4WriteTSeries( LALStatus *status, FILE *stream, INT4TimeSeries *series );
	void		void
	LALI8WriteTSeries( LALStatus *status, FILE *stream, INT8TimeSeries *series );		LALI8WriteTSeries( LALStatus *status, FILE *stream, INT8TimeSeries *series );
	void		void
	LALU2WriteTSeries( LALStatus *status, FILE *stream, UINT2TimeSeries *serie s );		LALU2WriteTSeries( LALStatus *status, FILE *stream, UINT2TimeSeries *serie s );
	void		void
	LALU4WriteTSeries( LALStatus *status, FILE *stream, UINT4TimeSeries *serie s );		LALU4WriteTSeries( LALStatus *status, FILE *stream, UINT4TimeSeries *serie s );
	skipping to change at line 168		skipping to change at line 158
	LALU8WriteFSeries( LALStatus *status, FILE *stream, UINT8FrequencySeries * series );		LALU8WriteFSeries( LALStatus *status, FILE *stream, UINT8FrequencySeries * series );
	void		void
	LALSWriteFSeries( LALStatus *status, FILE *stream, REAL4FrequencySeries *s eries );		LALSWriteFSeries( LALStatus *status, FILE *stream, REAL4FrequencySeries *s eries );
	void		void
	LALDWriteFSeries( LALStatus *status, FILE *stream, REAL8FrequencySeries *s eries );		LALDWriteFSeries( LALStatus *status, FILE *stream, REAL8FrequencySeries *s eries );
	void		void
	LALCWriteFSeries( LALStatus *status, FILE *stream, COMPLEX8FrequencySeries *series );		LALCWriteFSeries( LALStatus *status, FILE *stream, COMPLEX8FrequencySeries *series );
	void		void
	LALZWriteFSeries( LALStatus *status, FILE *stream, COMPLEX16FrequencySerie s *series );		LALZWriteFSeries( LALStatus *status, FILE *stream, COMPLEX16FrequencySerie s *series );
	/* <lalLaTeX>
	\newpage\input{StreamGridOutputC}
	</lalLaTeX> */
	void		void
	LALI2WriteGrid( LALStatus *status, FILE *stream, INT2Grid *grid );		LALI2WriteGrid( LALStatus *status, FILE *stream, INT2Grid *grid );
	void		void
	LALI4WriteGrid( LALStatus *status, FILE *stream, INT4Grid *grid );		LALI4WriteGrid( LALStatus *status, FILE *stream, INT4Grid *grid );
	void		void
	LALI8WriteGrid( LALStatus *status, FILE *stream, INT8Grid *grid );		LALI8WriteGrid( LALStatus *status, FILE *stream, INT8Grid *grid );
	void		void
	LALU2WriteGrid( LALStatus *status, FILE *stream, UINT2Grid *grid );		LALU2WriteGrid( LALStatus *status, FILE *stream, UINT2Grid *grid );
	void		void
	LALU4WriteGrid( LALStatus *status, FILE *stream, UINT4Grid *grid );		LALU4WriteGrid( LALStatus *status, FILE *stream, UINT4Grid *grid );
End of changes. 13 change blocks.
	31 lines changed or deleted		18 lines changed or added

	StringInput.h		StringInput.h
	skipping to change at line 69		skipping to change at line 69
	in \verb@StreamInput.h@ to add LAL robustness to otherwise ad-hoc data		in \verb@StreamInput.h@ to add LAL robustness to otherwise ad-hoc data
	input routines. However, the functions in \verb@StringInput.h@ are		input routines. However, the functions in \verb@StringInput.h@ are
	fully LAL-compliant and use only LAL types, so they are included in		fully LAL-compliant and use only LAL types, so they are included in
	\verb@liblal@ proper.		\verb@liblal@ proper.
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
	#ifndef _STRINGINPUT_H		#ifndef _STRINGINPUT_H
	#define _STRINGINPUT_H		#define _STRINGINPUT_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/LALStdio.h>		#include <lal/LALStdio.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID( STRINGINPUTH, "$Id$");		NRCSID( STRINGINPUTH, "$Id$");
	/********************************************************** <lalLaTeX>		/********************************************************** <lalLaTeX>
	\subsection*{Error conditions}		\subsection*{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		****************************************** </lalLaTeX><lalErrTable> */
	#define STRINGINPUTH_ENUL 1		#define STRINGINPUTH_ENUL 1
	#define STRINGINPUTH_EOUT 2		#define STRINGINPUTH_EOUT 2
	#define STRINGINPUTH_EMEM 3		#define STRINGINPUTH_EMEM 3
	skipping to change at line 176		skipping to change at line 182
	the element \verb@tokens[nTokens]@ is explicitly \verb@NULL@ (as is		the element \verb@tokens[nTokens]@ is explicitly \verb@NULL@ (as is
	the convention for an \verb@argv@ argument list).		the convention for an \verb@argv@ argument list).
	\item[\texttt{CHARVector *list}] The flattened list of tokens,		\item[\texttt{CHARVector *list}] The flattened list of tokens,
	separated by (and terminated with) \verb@'\0'@ characters.		separated by (and terminated with) \verb@'\0'@ characters.
	\end{description}		\end{description}
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
	typedef struct tagTokenList {		typedef struct tagTokenList {
			SWIGLAL_STRUCT(TokenList);
	UINT4 nTokens; /* number of tokens */		UINT4 nTokens; /* number of tokens */
	CHAR **tokens; /* list of pointers to tokens */		CHAR **tokens; /* list of pointers to tokens */
	CHARVector *list; /* flattened list of null-terminated tokens */		CHARVector *list; /* flattened list of null-terminated tokens */
	} TokenList;		} TokenList;
	/* <lalLaTeX>		/* <lalLaTeX>
	\vfill{\footnotesize\input{StringInputHV}}		\vfill{\footnotesize\input{StringInputHV}}
	</lalLaTeX> */		</lalLaTeX> */
	/* Function prototypes. */		/* Function prototypes. */
	skipping to change at line 244		skipping to change at line 251
	void		void
	LALStringToC( LALStatus *status, COMPLEX8 *value, const CHAR *string, CHAR **endptr );		LALStringToC( LALStatus *status, COMPLEX8 *value, const CHAR *string, CHAR **endptr );
	void		void
	LALStringToZ( LALStatus *status, COMPLEX16 *value, const CHAR *string, CHAR **endptr );		LALStringToZ( LALStatus *status, COMPLEX16 *value, const CHAR *string, CHAR **endptr );
	void		void
	LALStringToGPS( LALStatus *status, LIGOTimeGPS *value, const CHAR *string, CHAR **endptr );		LALStringToGPS( LALStatus *status, LIGOTimeGPS *value, const CHAR *string, CHAR **endptr );
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _STRINGINPUT_H */		#endif /* _STRINGINPUT_H */
End of changes. 5 change blocks.
	4 lines changed or deleted		12 lines changed or added

	StringVector.h		StringVector.h
	skipping to change at line 23		skipping to change at line 23
	*		*
	* You should have received a copy of the GNU General Public License		* You should have received a copy of the GNU General Public License
	* along with with program; see the file COPYING. If not, write to the		* along with with program; see the file COPYING. If not, write to the
	* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,		* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	* MA 02111-1307 USA		* MA 02111-1307 USA
	*/		*/
	/**		/**
	* \author Reinhard Prix		* \author Reinhard Prix
	* \date 2008		* \date 2008
	* \file		* \defgroup StringVector StringVector
	* \ingroup factories		* \ingroup factories
	* \brief Creation/destruction/manipulation API for 'StringVector' type obj ects,		* \brief Creation/destruction/manipulation API for ::LALStringVector objec ts,
	* which are just LAL 'vectors' of CHAR * pointers.		* which are just LAL 'vectors' of CHAR * pointers.
	*		*
	* $Id$		* \heading{Synopsis}
			* \code
			* #include <lal/StringVector.h>
			* \endcode
	*		*
	*/		*/
	#ifndef _STRINGVECTOR_H /* Double-include protection. */		#ifndef _STRINGVECTOR_H /* Double-include protection. */
	#define _STRINGVECTOR_H		#define _STRINGVECTOR_H
	/* C++ protection. */		/* C++ protection. */
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	/*---------- INCLUDES ----------*/		/*---------- INCLUDES ----------*/
	#include <stdarg.h>		#include <stdarg.h>
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	/*---------- DEFINES ----------*/		/*---------- DEFINES ----------*/
	NRCSID( STRINGVECTORH, "$Id$" );
	/*----- Error-codes -----*/		/*----- Error-codes -----*/
	/*---------- exported types ----------*/		/*---------- exported types ----------*/
	/*---------- Global variables ----------*/		/*---------- Global variables ----------*/
	/*---------- exported prototypes [API] ----------*/		/*---------- exported prototypes [API] ----------*/
			#ifdef SWIG /* SWIG interface directives */
			/* disable keywords arguments for XLALCreateStringVector */
			%feature("kwargs", 0) XLALCreateStringVector;
			/* ensure that SWIG generates "compact" default arguments,
			i.e. it only generates one wrapping function where all
			missing arguments are assigned NULL (it should do this
			anyway, since we're inside an extern "C" block and SWIG
			doesn't do any overloading for C-linkage functions) */
			%feature("compactdefaultargs") XLALCreateStringVector;
			/* add 20 optional arguments to XLALCreateStringVector,
			so that it can be called with up to 21 arguments */
			%varargs(20, CHAR *arg = NULL) XLALCreateStringVector;
			/* but since XLALCreateStringVector will crash if none
			of its arguments is NULL, add a contract to require
			that at least the final 21st argument is NULL */
			%contract XLALCreateStringVector {
			require:
			arg21 == NULL;
			}
			#endif /* SWIG */
	LALStringVector *XLALCreateStringVector ( const CHAR *str1, ... );		LALStringVector *XLALCreateStringVector ( const CHAR *str1, ... );
	LALStringVector *XLALAppendString2Vector (LALStringVector *vect, const CHAR *string );		LALStringVector *XLALAppendString2Vector (LALStringVector *vect, const CHAR *string );
	void XLALDestroyStringVector ( LALStringVector *vect );		void XLALDestroyStringVector ( LALStringVector *vect );
	int XLALSortStringVector (LALStringVector *strings);		int XLALSortStringVector (LALStringVector *strings);
	LALStringVector *XLALParseCSV2StringVector ( const CHAR *CSVlist );		LALStringVector *XLALParseCSV2StringVector ( const CHAR *CSVlist );
			INT4 XLALFindStringInVector ( const char *needle, const LALStringVector *ha ystack );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif		#endif
	/* C++ protection. */		/* C++ protection. */
	#endif /* Double-include protection. */		#endif /* Double-include protection. */
End of changes. 6 change blocks.
	4 lines changed or deleted		28 lines changed or added

	TimeDelay.h		TimeDelay.h
	skipping to change at line 20		skipping to change at line 20
	* but WITHOUT ANY WARRANTY; without even the implied warranty of		* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	*		*
	* You should have received a copy of the GNU General Public License		* You should have received a copy of the GNU General Public License
	* along with with program; see the file COPYING. If not, write to the		* along with with program; see the file COPYING. If not, write to the
	* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,		* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	* MA 02111-1307 USA		* MA 02111-1307 USA
	*/		*/
			/**
			* \defgroup TimeDelay_h TimeDelay
			* \ingroup date
			* \brief Provides routines to compute time delay between two detectors
			*
			* \heading{Synopsis}
			* \code
			* #include <lal/TimeDelay.h>
			* \endcode
			*/
	#ifndef _TIMEDELAY_H		#ifndef _TIMEDELAY_H
	#define _TIMEDELAY_H		#define _TIMEDELAY_H
	#include <lal/Date.h>		#include <lal/Date.h>
	#include <lal/DetectorSite.h>		#include <lal/DetectorSite.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C"		extern "C"
	{		{
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		11 lines changed or added

	TimeFreqFFT.h		TimeFreqFFT.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
	*/		*/
	/**** <lalVerbatim file="TimeFreqFFTHV">		#ifndef _TIMEFREQFFT_H
	* $Id$		#define _TIMEFREQFFT_H
	**** </lalVerbatim> */
	/**** <lalLaTeX>		/* remove SWIG interface directives */
	*		#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
	* \section{Header \texttt{TimeFreqFFT.h}}		#define SWIGLAL_STRUCT(...)
	* \label{s:TimeFreqFFT.h}		#endif
			#include <lal/LALDatatypes.h>
			#include <lal/ComplexFFT.h>
			#include <lal/RealFFT.h>
			#include <lal/Window.h>
			#if defined(__cplusplus)
			extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
			NRCSID( TIMEFREQFFTH, "$Id$" );
			/**
			* \addtogroup TimeFreqFFT_h
	*		*
	* Performs real-to-complex, complex-to-real FFTs and average power		* \brief Performs real-to-complex, complex-to-real FFTs and average power
	* spectrum estimation.		spectrum estimation.
	*		*
	* \subsection*{Synopsis}		* \heading{Synopsis}
	* \begin{verbatim}		* \code
	* #include <lal/TimeFreqFFT.h>		* #include <lal/TimeFreqFFT.h>
	* \end{verbatim}		* \endcode
	*
	* \noindent Perform time-to-frequency and frequency-to-time fast Fourier
	* transforms. Also provides a function to compute mean and median power
	* spectra with user specified windowning.
	*
	**** </lalLaTeX> */
	/** \defgroup fft Fourier Transform and Spectral Methods
	*
	* Performs real-to-complex, complex-to-real FFTs and average power
	* spectrum estimation.
	*		*
	* Perform time-to-frequency and frequency-to-time fast Fourier		* Perform time-to-frequency and frequency-to-time fast Fourier
	* transforms. Also provides a function to compute mean and median power		* transforms. Also provides a function to compute mean and median power
	* spectra with user specified windowning.		* spectra with user specified windowning.
	*		*
	* The definition of the Fourier transform is \f$ e^{2 \pi i f t} \f$		* The definition of the Fourier transform is \f$ e^{2 \pi i f t} \f$
	* and the inline equation version of that is		* and the inline equation version of that is
	* \f[		* \f[
	* \tilde{h}_k = \sum		* \tilde{h}_k = \sum
	* \f]		* \f]
	*		*
	*
	*/		*/
			/*@{*/
	#ifndef _TIMEFREQFFT_H		/**\name Error Codes */ /*@{*/
	#define _TIMEFREQFFT_H		#define TIMEFREQFFTH_ENULL 1 /**< Null pointer */
			#define TIMEFREQFFTH_ESIZE 2 /**< Invalid size */
	#include <lal/LALDatatypes.h>		#define TIMEFREQFFTH_ERATE 4 /**< Invalid rate */
	#include <lal/ComplexFFT.h>		#define TIMEFREQFFTH_ESIGN 4 /**< Incorrect plan sign */
	#include <lal/RealFFT.h>		#define TIMEFREQFFTH_EALLOC 16 /**< Pointer has already been allocated, sho
	#include <lal/Window.h>		uld be null */
			#define TIMEFREQFFTH_EPOSARG 32 /**< Argument must be positive */
	#ifdef __cplusplus		#define TIMEFREQFFTH_EMALLOC 64 /**< Malloc failure */
	extern "C" {		#define TIMEFREQFFTH_EINCOMP 128/**< Incompatible arguments */
	#pragma }		#define TIMEFREQFFTH_ENNUL 256 /**< Non-null pointer */
	#endif		#define TIMEFREQFFTH_EZSEG 512 /**< Segment length is zero */
			#define TIMEFREQFFTH_EZOVR 1024 /**< Overlap length is zero */
	NRCSID( TIMEFREQFFTH, "$Id$" );		#define TIMEFREQFFTH_EMISM 2048 /**< Mismatch beteen segment, overla
			p and data length */
	/**** <lalLaTeX>		#define TIMEFREQFFTH_EUAVG 4096 /**< Unknown average power spectum m
	* \subsection*{Error conditions}		ethod */
	**** </lalLaTeX> */		/*@}*/
	/**** <lalErrTable> */
	#define TIMEFREQFFTH_ENULL 1
	#define TIMEFREQFFTH_ESIZE 2
	#define TIMEFREQFFTH_ERATE 4
	#define TIMEFREQFFTH_ESIGN 4
	#define TIMEFREQFFTH_EALLOC 16
	#define TIMEFREQFFTH_EPOSARG 32
	#define TIMEFREQFFTH_EMALLOC 64
	#define TIMEFREQFFTH_EINCOMP 128
	#define TIMEFREQFFTH_ENNUL 256
	#define TIMEFREQFFTH_EZSEG 512
	#define TIMEFREQFFTH_EZOVR 1024
	#define TIMEFREQFFTH_EMISM 2048
	#define TIMEFREQFFTH_EUAVG 4096
			/** \cond DONT_DOXYGEN */
	#define TIMEFREQFFTH_MSGENULL "Null pointer"		#define TIMEFREQFFTH_MSGENULL "Null pointer"
	#define TIMEFREQFFTH_MSGESIZE "Invalid size"		#define TIMEFREQFFTH_MSGESIZE "Invalid size"
	#define TIMEFREQFFTH_MSGERATE "Invalid rate"		#define TIMEFREQFFTH_MSGERATE "Invalid rate"
	#define TIMEFREQFFTH_MSGESIGN "Incorrect plan sign"		#define TIMEFREQFFTH_MSGESIGN "Incorrect plan sign"
	#define TIMEFREQFFTH_MSGEALLOC "Pointer has already been allocated, should be null"		#define TIMEFREQFFTH_MSGEALLOC "Pointer has already been allocated, should be null"
	#define TIMEFREQFFTH_MSGEPOSARG "Argument must be positive"		#define TIMEFREQFFTH_MSGEPOSARG "Argument must be positive"
	#define TIMEFREQFFTH_MSGEMALLOC "Malloc failure"		#define TIMEFREQFFTH_MSGEMALLOC "Malloc failure"
	#define TIMEFREQFFTH_MSGEINCOMP "Incompatible arguments"		#define TIMEFREQFFTH_MSGEINCOMP "Incompatible arguments"
	#define TIMEFREQFFTH_MSGENNUL "Non-null pointer"		#define TIMEFREQFFTH_MSGENNUL "Non-null pointer"
	#define TIMEFREQFFTH_MSGEZSEG "Segment length is zero"		#define TIMEFREQFFTH_MSGEZSEG "Segment length is zero"
	#define TIMEFREQFFTH_MSGEZOVR "Overlap length is zero"		#define TIMEFREQFFTH_MSGEZOVR "Overlap length is zero"
	#define TIMEFREQFFTH_MSGEMISM "Mismatch beteen segment, overlap and data le ngth"		#define TIMEFREQFFTH_MSGEMISM "Mismatch beteen segment, overlap and data le ngth"
	#define TIMEFREQFFTH_MSGEUAVG "Unknown average power spectum method"		#define TIMEFREQFFTH_MSGEUAVG "Unknown average power spectum method"
			/** \endcond */
	/**** </lalErrTable> */		/** This type determines the method the type of average that will be used t
			o
	/* <lalLaTeX>		* compute the power sperum estimate by the LALREAL4AverageSpectrum()
	\subsection*{Types}		* function. The function computes a series of (possibly overlapping) power
			* spectra and computes the average using one of the following methods.
	\subsubsection*{Enum type \texttt{AvgSpecMethod}}		*/
	\idx[Type]{AvgSpecMethod}
	This type determines the method the type of average that will be used to
	compute the power sperum estimate by the \verb|LALREAL4AverageSpectrum()|
	function. The function computes a series of (possibly overlapping) power
	spectra and computes the average using one of the following methods:
	\begin{description}
	\item[\texttt{useUnity}] A constant PSD of value unity will be returned
	independent of the input data given. This is used for testing purposes.
	\item[\texttt{useMean}] The arithmetic mean of the individual power spectra
	computed will be used to compute the output power spectrum.
	\item[\texttt{useMedian}] The median value of the individual power spectra
	computed will be used to compute the output power spectrum.
	\item[\texttt{NumberAvgSpecMethods}] gives the number of defined methods.
	\end{description}
	</lalLaTeX> */
	typedef enum		typedef enum
	{		{
	useUnity,		useUnity, /**< A constant PSD of value unity will be returned independ
	useMean,		ent of the input data given; this is used for testing purposes */
	useMedian,		useMean, /**< The arithmetic mean of the individual power spectra com
	NumberAvgSpecMethods		puted will be used to compute the output power spectrum */
			useMedian, /**< The median value of the individual power spectra comput
			ed will be used to compute the output power spectrum */
			NumberAvgSpecMethods /**< gives the number of defined methods */
	}		}
	AvgSpecMethod;		AvgSpecMethod;
	/* <lalLaTeX>		/** This structure controls the behaviour of the LALREAL4AverageSpectrum()
	\subsubsection*{Structure \texttt{AvgerageSpectrumParams}}		function.
	\idx[Type]{AverageSpectrumParams}		*/
	This structure controls the behaviour of the \verb|LALREAL4AverageSpectrum(
	)|
	function.
	\begin{description}
	\item[\texttt{REAL4Window *window}] The windowing function to use when
	computing the individual power spectra from the input time series. The
	input time series is broken into smaller time series to compute power spect
	ra
	for the estimate. The legth of these time series is determined by the
	\texttt{length} parameter of the window vector.
	\item[\texttt{UINT4 overlap}] The overlap between sucessive time series use
	d
	to compute the power spectra.
	\item[\texttt{AvgSpecMethod method}] The method of computing the average
	as describe above.
	\item[\texttt{RealFFTPlan *plan}] The FFT plan to be used in the computatio
	n
	of the power spectrum.
	\end{description}
	</lalLaTeX> */
	typedef struct		typedef struct
	tagAverageSpectrumParams		tagAverageSpectrumParams
	{		{
	REAL4Window *window;		SWIGLAL_STRUCT(AverageSpectrumParams);
	UINT4 overlap;		REAL4Window *window; /**< The windowing function to use w
	AvgSpecMethod method;		hen computing the individual power spectra from the input time series.
	RealFFTPlan *plan;		* The input time series is broken into sma
			ller time series to compute power spectra
			* for the estimate. The length of these ti
			me series is determined by the \c length parameter of the window vector.
			*/
			UINT4 overlap; /**< The overlap between sucessive time se
			ries used to compute the power spectra. */
			AvgSpecMethod method; /**< The method of computing the ave
			rage as describe under ::AvgSpecMethod */
			RealFFTPlan *plan; /**< The FFT plan to be used in the computat
			ion of the power spectrum. */
	}		}
	AverageSpectrumParams;		AverageSpectrumParams;
			/** UNDOCUMENTED */
	typedef struct		typedef struct
	tagLALPSDRegressor		tagLALPSDRegressor
	{		{
			SWIGLAL_STRUCT(LALPSDRegressor);
	unsigned average_samples;		unsigned average_samples;
	unsigned median_samples;		unsigned median_samples;
	unsigned n_samples;		unsigned n_samples;
	REAL8Sequence **history;		REAL8Sequence **history;
	REAL8FrequencySeries *mean_square;		REAL8FrequencySeries *mean_square;
	}		}
	LALPSDRegressor;		LALPSDRegressor;
	/**** <lalLaTeX>
	* \newpage\input{TimeFreqFFTC}
	* \newpage\input{TimeFreqFFTTestC}
	**** </lalLaTeX> */
	/*		/*
	*		*
	* XLAL Functions		* XLAL Functions
	*		*
	*/		*/
	int XLALREAL4TimeFreqFFT(		int XLALREAL4TimeFreqFFT(
	COMPLEX8FrequencySeries *freq,		COMPLEX8FrequencySeries *freq,
	const REAL4TimeSeries *tser,		const REAL4TimeSeries *tser,
	const REAL4FFTPlan *plan		const REAL4FFTPlan *plan
	);		);
	int XLALREAL4FreqTimeFFT(		int XLALREAL4FreqTimeFFT(
	REAL4TimeSeries *tser,		REAL4TimeSeries *tser,
	const COMPLEX8FrequencySeries *freq,		const COMPLEX8FrequencySeries *freq,
	const REAL4FFTPlan *plan		const REAL4FFTPlan *plan
	skipping to change at line 462		skipping to change at line 401
	const LALPSDRegressor *r		const LALPSDRegressor *r
	);		);
	int		int
	XLALPSDRegressorSetPSD(		XLALPSDRegressorSetPSD(
	LALPSDRegressor *r,		LALPSDRegressor *r,
	const REAL8FrequencySeries *psd,		const REAL8FrequencySeries *psd,
	unsigned weight		unsigned weight
	);		);
	#ifdef __cplusplus		/*@}*/
	#pragma {
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _TIMEFREQFFT_H */		#endif /* _TIMEFREQFFT_H */
End of changes. 19 change blocks.
	132 lines changed or deleted		85 lines changed or added

	TimeSeries.h		TimeSeries.h
	skipping to change at line 26		skipping to change at line 26
	* You should have received a copy of the GNU General Public License along		* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,		* with this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.		* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	*/		*/
	#ifndef _TIMESERIES_H		#ifndef _TIMESERIES_H
	#define _TIMESERIES_H		#define _TIMESERIES_H
	#include <stddef.h>		#include <stddef.h>
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
			#if defined(__cplusplus)
			extern "C" {
			#elif 0
			} /* so that editors will match preceding brace */
			#endif
	NRCSID(TIMESERIESH, "$Id:");		NRCSID(TIMESERIESH, "$Id:");
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* COMPLEX8 prototypes */
	\idx{XLALDestroyCOMPLEX8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyCOMPLEX8TimeSeries (		void XLALDestroyCOMPLEX8TimeSeries (
	COMPLEX8TimeSeries *series		COMPLEX8TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateCOMPLEX8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	COMPLEX8TimeSeries *XLALCreateCOMPLEX8TimeSeries (		COMPLEX8TimeSeries *XLALCreateCOMPLEX8TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutCOMPLEX8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	COMPLEX8TimeSeries *XLALCutCOMPLEX8TimeSeries (		COMPLEX8TimeSeries *XLALCutCOMPLEX8TimeSeries (
	const COMPLEX8TimeSeries *series,		const COMPLEX8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeCOMPLEX8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	COMPLEX8TimeSeries *XLALResizeCOMPLEX8TimeSeries (		COMPLEX8TimeSeries *XLALResizeCOMPLEX8TimeSeries (
	COMPLEX8TimeSeries *series,		COMPLEX8TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkCOMPLEX8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	COMPLEX8TimeSeries *XLALShrinkCOMPLEX8TimeSeries (		COMPLEX8TimeSeries *XLALShrinkCOMPLEX8TimeSeries (
	COMPLEX8TimeSeries *series,		COMPLEX8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddCOMPLEX8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	COMPLEX8TimeSeries *XLALAddCOMPLEX8TimeSeries (		COMPLEX8TimeSeries *XLALAddCOMPLEX8TimeSeries (
	COMPLEX8TimeSeries *arg1,		COMPLEX8TimeSeries *arg1,
	const COMPLEX8TimeSeries *arg2		const COMPLEX8TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* COMPLEX16 prototypes */
	\idx{XLALDestroyCOMPLEX16TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyCOMPLEX16TimeSeries (		void XLALDestroyCOMPLEX16TimeSeries (
	COMPLEX16TimeSeries *series		COMPLEX16TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateCOMPLEX16TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	COMPLEX16TimeSeries *XLALCreateCOMPLEX16TimeSeries (		COMPLEX16TimeSeries *XLALCreateCOMPLEX16TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutCOMPLEX16TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	COMPLEX16TimeSeries *XLALCutCOMPLEX16TimeSeries (		COMPLEX16TimeSeries *XLALCutCOMPLEX16TimeSeries (
	const COMPLEX16TimeSeries *series,		const COMPLEX16TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeCOMPLEX16TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	COMPLEX16TimeSeries *XLALResizeCOMPLEX16TimeSeries (		COMPLEX16TimeSeries *XLALResizeCOMPLEX16TimeSeries (
	COMPLEX16TimeSeries *series,		COMPLEX16TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkCOMPLEX16TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	COMPLEX16TimeSeries *XLALShrinkCOMPLEX16TimeSeries (		COMPLEX16TimeSeries *XLALShrinkCOMPLEX16TimeSeries (
	COMPLEX16TimeSeries *series,		COMPLEX16TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddCOMPLEX16TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	COMPLEX16TimeSeries *XLALAddCOMPLEX16TimeSeries (		COMPLEX16TimeSeries *XLALAddCOMPLEX16TimeSeries (
	COMPLEX16TimeSeries *arg1,		COMPLEX16TimeSeries *arg1,
	const COMPLEX16TimeSeries *arg2		const COMPLEX16TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* REAL4 prototypes */
	\idx{XLALDestroyREAL4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyREAL4TimeSeries (		void XLALDestroyREAL4TimeSeries (
	REAL4TimeSeries *series		REAL4TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateREAL4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	REAL4TimeSeries *XLALCreateREAL4TimeSeries (		REAL4TimeSeries *XLALCreateREAL4TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutREAL4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	REAL4TimeSeries *XLALCutREAL4TimeSeries (		REAL4TimeSeries *XLALCutREAL4TimeSeries (
	const REAL4TimeSeries *series,		const REAL4TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeREAL4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	REAL4TimeSeries *XLALResizeREAL4TimeSeries (		REAL4TimeSeries *XLALResizeREAL4TimeSeries (
	REAL4TimeSeries *series,		REAL4TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkREAL4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	REAL4TimeSeries *XLALShrinkREAL4TimeSeries (		REAL4TimeSeries *XLALShrinkREAL4TimeSeries (
	REAL4TimeSeries *series,		REAL4TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddREAL4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	REAL4TimeSeries *XLALAddREAL4TimeSeries (		REAL4TimeSeries *XLALAddREAL4TimeSeries (
	REAL4TimeSeries *arg1,		REAL4TimeSeries *arg1,
	const REAL4TimeSeries *arg2		const REAL4TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* REAL8 prototypes */
	\idx{XLALDestroyREAL8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyREAL8TimeSeries (		void XLALDestroyREAL8TimeSeries (
	REAL8TimeSeries *series		REAL8TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateREAL8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	REAL8TimeSeries *XLALCreateREAL8TimeSeries (		REAL8TimeSeries *XLALCreateREAL8TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutREAL8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	REAL8TimeSeries *XLALCutREAL8TimeSeries (		REAL8TimeSeries *XLALCutREAL8TimeSeries (
	const REAL8TimeSeries *series,		const REAL8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeREAL8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	REAL8TimeSeries *XLALResizeREAL8TimeSeries (		REAL8TimeSeries *XLALResizeREAL8TimeSeries (
	REAL8TimeSeries *series,		REAL8TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkREAL8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	REAL8TimeSeries *XLALShrinkREAL8TimeSeries (		REAL8TimeSeries *XLALShrinkREAL8TimeSeries (
	REAL8TimeSeries *series,		REAL8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddREAL8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	REAL8TimeSeries *XLALAddREAL8TimeSeries (		REAL8TimeSeries *XLALAddREAL8TimeSeries (
	REAL8TimeSeries *arg1,		REAL8TimeSeries *arg1,
	const REAL8TimeSeries *arg2		const REAL8TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* INT2 prototypes */
	\idx{XLALDestroyINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyINT2TimeSeries (		void XLALDestroyINT2TimeSeries (
	INT2TimeSeries *series		INT2TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	INT2TimeSeries *XLALCreateINT2TimeSeries (		INT2TimeSeries *XLALCreateINT2TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	INT2TimeSeries *XLALCutINT2TimeSeries (		INT2TimeSeries *XLALCutINT2TimeSeries (
	const INT2TimeSeries *series,		const INT2TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	INT2TimeSeries *XLALResizeINT2TimeSeries (		INT2TimeSeries *XLALResizeINT2TimeSeries (
	INT2TimeSeries *series,		INT2TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	INT2TimeSeries *XLALShrinkINT2TimeSeries (		INT2TimeSeries *XLALShrinkINT2TimeSeries (
	INT2TimeSeries *series,		INT2TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	INT2TimeSeries *XLALAddINT2TimeSeries (		INT2TimeSeries *XLALAddINT2TimeSeries (
	INT2TimeSeries *arg1,		INT2TimeSeries *arg1,
	const INT2TimeSeries *arg2		const INT2TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* INT4 prototypes */
	\idx{XLALDestroyINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyINT4TimeSeries (		void XLALDestroyINT4TimeSeries (
	INT4TimeSeries *series		INT4TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	INT4TimeSeries *XLALCreateINT4TimeSeries (		INT4TimeSeries *XLALCreateINT4TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	INT4TimeSeries *XLALCutINT4TimeSeries (		INT4TimeSeries *XLALCutINT4TimeSeries (
	const INT4TimeSeries *series,		const INT4TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	INT4TimeSeries *XLALResizeINT4TimeSeries (		INT4TimeSeries *XLALResizeINT4TimeSeries (
	INT4TimeSeries *series,		INT4TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	INT4TimeSeries *XLALShrinkINT4TimeSeries (		INT4TimeSeries *XLALShrinkINT4TimeSeries (
	INT4TimeSeries *series,		INT4TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	INT4TimeSeries *XLALAddINT4TimeSeries (		INT4TimeSeries *XLALAddINT4TimeSeries (
	INT4TimeSeries *arg1,		INT4TimeSeries *arg1,
	const INT4TimeSeries *arg2		const INT4TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* INT8 prototypes */
	\idx{XLALDestroyINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyINT8TimeSeries (		void XLALDestroyINT8TimeSeries (
	INT8TimeSeries *series		INT8TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	INT8TimeSeries *XLALCreateINT8TimeSeries (		INT8TimeSeries *XLALCreateINT8TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	INT8TimeSeries *XLALCutINT8TimeSeries (		INT8TimeSeries *XLALCutINT8TimeSeries (
	const INT8TimeSeries *series,		const INT8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	INT8TimeSeries *XLALResizeINT8TimeSeries (		INT8TimeSeries *XLALResizeINT8TimeSeries (
	INT8TimeSeries *series,		INT8TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	INT8TimeSeries *XLALShrinkINT8TimeSeries (		INT8TimeSeries *XLALShrinkINT8TimeSeries (
	INT8TimeSeries *series,		INT8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	INT8TimeSeries *XLALAddINT8TimeSeries (		INT8TimeSeries *XLALAddINT8TimeSeries (
	INT8TimeSeries *arg1,		INT8TimeSeries *arg1,
	const INT8TimeSeries *arg2		const INT8TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* UINT2 prototypes */
	\idx{XLALDestroyUINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyUINT2TimeSeries (		void XLALDestroyUINT2TimeSeries (
	UINT2TimeSeries *series		UINT2TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateUINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	UINT2TimeSeries *XLALCreateUINT2TimeSeries (		UINT2TimeSeries *XLALCreateUINT2TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutUINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	UINT2TimeSeries *XLALCutUINT2TimeSeries (		UINT2TimeSeries *XLALCutUINT2TimeSeries (
	const UINT2TimeSeries *series,		const UINT2TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeUINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	UINT2TimeSeries *XLALResizeUINT2TimeSeries (		UINT2TimeSeries *XLALResizeUINT2TimeSeries (
	UINT2TimeSeries *series,		UINT2TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkUINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	UINT2TimeSeries *XLALShrinkUINT2TimeSeries (		UINT2TimeSeries *XLALShrinkUINT2TimeSeries (
	UINT2TimeSeries *series,		UINT2TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddUINT2TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	UINT2TimeSeries *XLALAddUINT2TimeSeries (		UINT2TimeSeries *XLALAddUINT2TimeSeries (
	UINT2TimeSeries *arg1,		UINT2TimeSeries *arg1,
	const UINT2TimeSeries *arg2		const UINT2TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* UINT4 prototypes */
	\idx{XLALDestroyUINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyUINT4TimeSeries (		void XLALDestroyUINT4TimeSeries (
	UINT4TimeSeries *series		UINT4TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateUINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	UINT4TimeSeries *XLALCreateUINT4TimeSeries (		UINT4TimeSeries *XLALCreateUINT4TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutUINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	UINT4TimeSeries *XLALCutUINT4TimeSeries (		UINT4TimeSeries *XLALCutUINT4TimeSeries (
	const UINT4TimeSeries *series,		const UINT4TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeUINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	UINT4TimeSeries *XLALResizeUINT4TimeSeries (		UINT4TimeSeries *XLALResizeUINT4TimeSeries (
	UINT4TimeSeries *series,		UINT4TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkUINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	UINT4TimeSeries *XLALShrinkUINT4TimeSeries (		UINT4TimeSeries *XLALShrinkUINT4TimeSeries (
	UINT4TimeSeries *series,		UINT4TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddUINT4TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	UINT4TimeSeries *XLALAddUINT4TimeSeries (		UINT4TimeSeries *XLALAddUINT4TimeSeries (
	UINT4TimeSeries *arg1,		UINT4TimeSeries *arg1,
	const UINT4TimeSeries *arg2		const UINT4TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesDestroyP">		/* UINT8 prototypes */
	\idx{XLALDestroyUINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesDestroyP"> */
	void XLALDestroyUINT8TimeSeries (		void XLALDestroyUINT8TimeSeries (
	UINT8TimeSeries *series		UINT8TimeSeries *series
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCreateP">
	\idx{XLALCreateUINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCreateP"> */
	UINT8TimeSeries *XLALCreateUINT8TimeSeries (		UINT8TimeSeries *XLALCreateUINT8TimeSeries (
	const CHAR *name,		const CHAR *name,
	const LIGOTimeGPS *epoch,		const LIGOTimeGPS *epoch,
	REAL8 f0,		REAL8 f0,
	REAL8 deltaT,		REAL8 deltaT,
	const LALUnit *sampleUnits,		const LALUnit *sampleUnits,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesCutP">
	\idx{XLALCutUINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesCutP"> */
	UINT8TimeSeries *XLALCutUINT8TimeSeries (		UINT8TimeSeries *XLALCutUINT8TimeSeries (
	const UINT8TimeSeries *series,		const UINT8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALResizeUINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	UINT8TimeSeries *XLALResizeUINT8TimeSeries (		UINT8TimeSeries *XLALResizeUINT8TimeSeries (
	UINT8TimeSeries *series,		UINT8TimeSeries *series,
	int first,		int first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesResizeP">
	\idx{XLALShrinkUINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesResizeP"> */
	UINT8TimeSeries *XLALShrinkUINT8TimeSeries (		UINT8TimeSeries *XLALShrinkUINT8TimeSeries (
	UINT8TimeSeries *series,		UINT8TimeSeries *series,
	size_t first,		size_t first,
	size_t length		size_t length
	);		);
	/* </lalVerbatim> */
	/* <lalLaTeX file="TimeSeriesAddP">
	\idx{XLALAddUINT8TimeSeries ()}
	</lalLaTeX> <lalVerbatim file="TimeSeriesAddP"> */
	UINT8TimeSeries *XLALAddUINT8TimeSeries (		UINT8TimeSeries *XLALAddUINT8TimeSeries (
	UINT8TimeSeries *arg1,		UINT8TimeSeries *arg1,
	const UINT8TimeSeries *arg2		const UINT8TimeSeries *arg2
	);		);
	/* </lalVerbatim> */
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
			}
			#endif
	#endif /* _TIMESERIES_H */		#endif /* _TIMESERIES_H */
End of changes. 122 change blocks.
	241 lines changed or deleted		33 lines changed or added

	Units.h		Units.h
	skipping to change at line 20		skipping to change at line 20
	* but WITHOUT ANY WARRANTY; without even the implied warranty of		* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	*		*
	* You should have received a copy of the GNU General Public License		* You should have received a copy of the GNU General Public License
	* along with with program; see the file COPYING. If not, write to the		* along with with program; see the file COPYING. If not, write to the
	* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,		* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	* MA 02111-1307 USA		* MA 02111-1307 USA
	*/		*/
	/********************************* <lalVerbatim file="UnitsHV">		/**
	Author: J. T. Whelan <john.whelan@ligo.org>		\author J. T. Whelan <john.whelan@ligo.org>
	$Id$		\addtogroup Units_h
	********************************** </lalVerbatim> */
	/* <lalLaTeX>
	\section{Header \texttt{Units.h}}
	\label{tools:s:Units.h}
	Provides prototypes for manipulation of units and declares		\brief Provides prototypes for manipulation of units and declares
	\texttt{extern} constants for the basic and derived SI units.		\c extern constants for the basic and derived SI units.
	\subsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/Units.h>		#include <lal/Units.h>
	\end{verbatim}		\endcode
	\noindent This header provides prototypes for functions to manipulate		This header provides prototypes for functions to manipulate
	the \texttt{LALUnit} structure. It also defines \texttt{extern}		the \c LALUnit structure. It also defines \c extern
	constants for a set of predefined units, which are designed to make		constants for a set of predefined units, which are designed to make
	the structure easier to use. For instance, to determine whether a		the structure easier to use. For instance, to determine whether a
	quantity has units of strain per root hertz, one constructs the unit		quantity has units of strain per root hertz, one constructs the unit
	"strain per root hertz" from the predefined \texttt{lalStrainUnit} and		"strain per root hertz" from the predefined \c lalStrainUnit and
	\texttt{lalHertzUnit} constant structures using the		\c lalHertzUnit constant structures using the
	\texttt{LALUnitRaise()} and \texttt{LALUnitMultiply()} functions, then		LALUnitRaise() and LALUnitMultiply() functions, then
	compares that to the unit structure in question using the		compares that to the unit structure in question using the
	\texttt{LALUnitCompare()} function.		LALUnitCompare() function.
	The LALUnit datatype itself is included in the header		The LALUnit datatype itself is included in the header
	\texttt{LALDatatypes.h}, and defines a unit in terms of an integer		\ref LALDatatypes.h, and defines a unit in terms of an integer
	power of ten multiplier along with rational powers of the basic SI		power of ten multiplier along with rational powers of the basic SI
	units (meters, kilograms, seconds, Amperes, and Kelvins) and two		units (meters, kilograms, seconds, Amperes, and Kelvins) and two
	custom units (strain and ADC counts).		custom units (strain and ADC counts).
	\subsection*{Error conditions}		@{
	\input{UnitsHErrTable}		\defgroup UnitDefs_c Module UnitDefs.c
			\defgroup UnitNormalize_c Module UnitNormalize.c
	\subsection*{Structures}		\defgroup UnitRaise_c Module UnitRaise.c
			\defgroup UnitMultiply_c Module UnitMultiply.c
	\subsubsection*{LALUnitPair}		\defgroup UnitCompare_c Module UnitCompare.c
	\idx[Type]{LALUnitPair}		\defgroup UnitXLALFunctions XLAL Functions
	Consists of a pair of unit structures; used as an input structure for		@}
	the \texttt{LALUnitCompare()} and \texttt{LALUnitMultiply()} functions.		*/
	The fields are:
	\begin{description}
	\item[\texttt{LALUnit *unitOne}] The first unit.
	\item[\texttt{LALUnit *unitTwo}] The second unit.
	\end{description}
	\subsubsection*{RAT4}
	\idx[Type]{RAT4}
	A four-byte rational number, used as a parameter structure for
	\texttt{LALUnitRaise()}. The fields are:
	\begin{description}
	\item[\texttt{INT2 numerator}] The numerator.
	\item[\texttt{UINT2 denominatorMinusOne}] One less than the denominator.
	\end{description}
	\vfill{\footnotesize\input{UnitsHV}}
	\newpage\input{UnitDefsC}
	\newpage\input{UnitNormalizeC}
	\newpage\input{UnitRaiseC}
	\newpage\input{UnitMultiplyC}
	\newpage\input{UnitCompareC}
	\newpage\subsection{XLAL Functions}		/**
			\addtogroup UnitXLALFunctions
			\brief XLAL interface to Unit.h functions
	\subsubsection*{Synopsis}		\heading{Synopsis}
	\begin{verbatim}		\code
	#include <lal/Units.h>		#include <lal/Units.h>
			\endcode
	char * XLALUnitAsString( char *string, UINT4 length, const LALUnit *input )		\heading{Description}
	;
	LALUnit * XLALParseUnitString( LALUnit *output, const char *string );
	int XLALUnitNormalize( LALUnit *unit );
	int XLALUnitCompare( const LALUnit *unit1, const LALUnit *unit2 );
	LALUnit * XLALUnitMultiply( LALUnit *output, const LALUnit *unit1,
	const LALUnit *unit2 );
	LALUnit * XLALUnitRaiseRAT4( LALUnit *output, const LALUnit *input,
	const RAT4 *power );
	LALUnit * XLALUnitRaiseINT2( LALUnit *output, const LALUnit *input,
	INT2 power );
	LALUnit * XLALUnitSquare( LALUnit *output, const LALUnit *input );
	LALUnit * XLALUnitSqrt( LALUnit *output, const LALUnit *input );
	\end{verbatim}
	\idx{XLALUnitAsString}
	\idx{XLALParseUnitString}
	\idx{XLALUnitNormalize}
	\idx{XLALUnitCompare}
	\idx{XLALUnitMultiply}
	\idx{XLALUnitRaiseRAT4}
	\idx{XLALUnitRaiseINT2}
	\idx{XLALUnitSquare}
	\idx{XLALUnitSqrt}
	\subsubsection*{Description}
	\verb+XLALUnitAsString+ converts a \verb+LALUnit+ structure into a characte		XLALUnitAsString() converts a ::LALUnit structure into a character
	r		string of maximum length \c length (including NUL termination)
	string of maximum length \verb+length+ (including NUL termination)		representation of the units. The inverse function, XLALParseUnitString()
	representation of the units. The inverse function, \verb+XLALParseUnitStri		parses a character string to produce a \c LALUnit structure; if
	ng+		\c output is \c NULL, memory for the output is allocated. If the input
	parses a character string to produce a \verb+LALUnit+ structure; if		\c string is \c NULL or is empty then the output units are
	\verb+output+ is \verb+NULL+, memory for the output is allocated. If the i		dimensionless: lalDimensionlessUnit.
	nput
	\verb+string+ is \verb+NULL+ or is empty then the output units are
	dimensionless: \verb+lalDimensionlessUnit+.
	\verb+XLALUnitNormalize+ puts a \verb+LALUnit+ structure into normal form		XLALUnitNormalize() puts a ::LALUnit structure into normal form
	by simplifying all unit exponent fractions to their simplest form.		by simplifying all unit exponent fractions to their simplest form.
	\verb+XLALUnitCompare+ compares two \verb+LALUnit+ structures: they are the		XLALUnitCompare() compares two ::LALUnit structures: they are the
	same if their normal forms are identical.		same if their normal forms are identical.
	\verb+XLALUnitMultiply+ multiplies two \verb+LALUnit+ structures. The resu lt		XLALUnitMultiply() multiplies two ::LALUnit structures. The result
	is put into normal form.		is put into normal form.
	\verb+XLALUnitRaiseRAT4+ raises a \verb+LALUnit+ structure to a rational		XLALUnitRaiseRAT4() raises a ::LALUnit structure to a rational
	power given by the \verb+RAT4+ structure \verb+power+.		power given by the ::RAT4 structure \c power.
	\verb+XLALUnitRaiseINT2+ raises a \verb+LALUnit+ structure to an integer		XLALUnitRaiseINT2() raises a ::LALUnit structure to an integer
	power \verb+power+.		power \c power.
	\verb+XLALUnitSquare+ produces the square of a \verb+LALUnit+ structure.		XLALUnitSquare() produces the square of a ::LALUnit structure.
	\verb+XLALUnitSqrt+ produces the square-root of a \verb+LALUnit+ structure.		XLALUnitSqrt() produces the square-root of a ::LALUnit structure.
	\subsubsection*{Return Values}		\heading{Return Values}
	\verb+XLALUnitAsString+ returns the pointer to the input \verb+string+, whi ch		XLALUnitAsString() returns the pointer to the input \c string, which
	is populated with the unit string if successful. If there is a failure,		is populated with the unit string if successful. If there is a failure,
	\verb+XLALUnitAsString+ returns a \verb+NULL+ pointer and \verb+xlalErrno+		XLALUnitAsString() returns a \c NULL pointer and \c ::xlalErrno
	is set to one of the following values: \verb+XLAL_EFAULT+ if one of the		is set to one of the following values: \c #XLAL_EFAULT if one of the
	input pointers is \verb+NULL+ or \verb+XLAL_EBADLEN+ if the length of the		input pointers is \c NULL or \c #XLAL_EBADLEN if the length of the
	string is insufficent for the unit string.		string is insufficent for the unit string.
	\verb+XLALParseUnitString+ returns the pointer \verb+output+ upon return		XLALParseUnitString() returns the pointer \c output upon return
	or a pointer to newly allocated memory if \verb+output+ was \verb+NULL+;		or a pointer to newly allocated memory if \c output was \c NULL;
	on failure, \verb+XLALParseUnitString+ returns \verb+NULL+ and sets		on failure, \c XLALParseUnitString returns \c NULL and sets
	\verb+xlalErrno+ to one of the following values: \verb+XLAL_ENOMEM+		\c ::xlalErrno to one of the following values: \c #XLAL_ENOMEM
	if the routine was unable to allocate memory for the output or		if the routine was unable to allocate memory for the output or
	\verb+XLAL_EFAILED+ if the routine was unable to parse the unit string.		\c #XLAL_EFAILED if the routine was unable to parse the unit string.
	\verb+XLALUnitNormalize+ returns 0 upon success or \verb+XLAL_FAILURE+		XLALUnitNormalize() returns 0 upon success or \c #XLAL_FAILURE
	if the input pointer is \verb+NULL+, in which case \verb+xlalErrno+		if the input pointer is \c NULL, in which case \c xlalErrno
	is set to \verb+XLAL_EFAULT+		is set to \c #XLAL_EFAULT
	\verb+XLALUnitCompare+ returns 0 if the the normal form of the two unit		XLALUnitCompare() returns 0 if the the normal form of the two unit
	structures are the same or > 0 if they are different. It returns		structures are the same or > 0 if they are different. It returns
	\verb+XLAL_FAILURE+ and \verb+xlalErrno+ is set to \verb+XLAL_EFAULT+ if		\c #XLAL_FAILURE and \c ::xlalErrno is set to \c #XLAL_EFAULT if
	one of the input pointers is \verb+NULL+.		one of the input pointers is \c NULL.
	\verb+XLALUnitMultiply+		XLALUnitMultiply(), XLALUnitRaiseRAT4(), XLALUnitRaiseINT2(), XLALUnitSquar
	\verb+XLALUnitRaiseRAT4+		e() and
	\verb+XLALUnitRaiseINT2+		XLALUnitSqrt() all return a pointer to the output unit structure
	\verb+XLALUnitSquare+ and		\c output upon success or \c NULL upon failure. If there is
	\verb+XLALUnitSqrt+ all return a pointer to the output unit structure		a failure, \c ::xlalErrno is set to one of the following values:
	\verb+output+ upon success or \verb+NULL+ upon failure. If there is		\c #XLAL_EFAULT if one of the input pointers is \c NULL,
	a failure, \verb+xlalErrno+ is set to one of the following values:		\c #XLAL_ERANGE if one of the unit powers exceeds the allowed range,
	\verb+XLAL_EFAULT+ if one of the input pointers is \verb+NULL+,		or \c #XLAL_EINVAL (for the raise functions only) if the unit power
	\verb+XLAL_ERANGE+ if one of the unit powers exceeds the allowed range,
	or \verb+XLAL_EINVAL+ (for the raise functions only) if the unit power
	would not be an integer.		would not be an integer.
			*/
	\newpage\input{UnitsTestC}
	</lalLaTeX> */
	#ifndef _UNITS_H		#ifndef _UNITS_H
	#define _UNITS_H		#define _UNITS_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (UNITSH, "$Id$");		NRCSID (UNITSH, "$Id$");
	/******************************** <lalErrTable file="UnitsHErrTable"> */		/** \ingroup Units_h
			* @{
	#define UNITSH_ENULLPIN 1		*/
	#define UNITSH_ENULLPOUT 2		/**\name Error Codes */ /*@{*/
	#define UNITSH_ENULLPD 3		#define UNITSH_ENULLPIN 1 /**< Null pointer to input */
	#define UNITSH_ENULLPPARAM 4		#define UNITSH_ENULLPOUT 2 /**< Null pointer to output */
	#define UNITSH_ESTRINGSIZE 5		#define UNITSH_ENULLPD 3 /**< Null pointer to data member of
	#define UNITSH_EOVERFLOW 6		vector */
	#define UNITSH_ENONINT 7		#define UNITSH_ENULLPPARAM 4 /**< Null pointer to parameters */
	#define UNITSH_EPARSE 8		#define UNITSH_ESTRINGSIZE 5 /**< Output string too short */
			#define UNITSH_EOVERFLOW 6 /**< Exponent outside of (U)INT2 bou
			nds */
			#define UNITSH_ENONINT 7 /**< Non-integer power of ten */
			#define UNITSH_EPARSE 8 /**< Error parsing unit string */
			/*@}*/
			/** \cond DONT_DOXYGEN */
	#define UNITSH_MSGENULLPIN "Null pointer to input"		#define UNITSH_MSGENULLPIN "Null pointer to input"
	#define UNITSH_MSGENULLPOUT "Null pointer to output"		#define UNITSH_MSGENULLPOUT "Null pointer to output"
	#define UNITSH_MSGENULLPD "Null pointer to data member of vector"		#define UNITSH_MSGENULLPD "Null pointer to data member of vector"
	#define UNITSH_MSGENULLPPARAM "Null pointer to parameters"		#define UNITSH_MSGENULLPPARAM "Null pointer to parameters"
	#define UNITSH_MSGESTRINGSIZE "Output string too short"		#define UNITSH_MSGESTRINGSIZE "Output string too short"
	#define UNITSH_MSGEOVERFLOW "Exponent outside of (U)INT2 bounds"		#define UNITSH_MSGEOVERFLOW "Exponent outside of (U)INT2 bounds"
	#define UNITSH_MSGENONINT "Non-integer power of ten"		#define UNITSH_MSGENONINT "Non-integer power of ten"
	#define UNITSH_MSGEPARSE "Error parsing unit string"		#define UNITSH_MSGEPARSE "Error parsing unit string"
			/** \endcond */
	/************************************ </lalErrTable> */		/** A four-byte rational number, used as a parameter structure for
			* LALUnitRaise().
	/* The parameter structure for LALUnitRaise contains the numerator and
	* denominator-minus-one of the rational power.
	*/		*/
	typedef struct		typedef struct
	tagRAT4		tagRAT4
	{		{
	INT2 numerator;		SWIGLAL_STRUCT(RAT4);
	UINT2 denominatorMinusOne;		INT2 numerator; /**< The numerator */
			UINT2 denominatorMinusOne; /**< One less than the denominator */
	} RAT4;		} RAT4;
			/** @} */
	/*********************************************************		/*********************************************************
	* *		* *
	* Functions to manipulate unit structures *		* Functions to manipulate unit structures *
	* *		* *
	*********************************************************/		*********************************************************/
	/* XLAL routines */		/* XLAL routines */
			/** \addtogroup UnitXLALFunctions
			* @{
			*/
	char * XLALUnitAsString( char *string, UINT4 length, const LALUnit *input ) ;		char * XLALUnitAsString( char *string, UINT4 length, const LALUnit *input ) ;
	LALUnit * XLALParseUnitString( LALUnit *output, const char *string );		LALUnit * XLALParseUnitString( LALUnit *output, const char *string );
	int XLALUnitNormalize( LALUnit *unit );		int XLALUnitNormalize( LALUnit *unit );
	int XLALUnitCompare( const LALUnit *unit1, const LALUnit *unit2 );		int XLALUnitCompare( const LALUnit *unit1, const LALUnit *unit2 );
	LALUnit * XLALUnitMultiply( LALUnit *output, const LALUnit *unit1,		LALUnit * XLALUnitMultiply( LALUnit *output, const LALUnit *unit1,
	const LALUnit *unit2 );		const LALUnit *unit2 );
	LALUnit * XLALUnitDivide( LALUnit *output, const LALUnit *unit1,		LALUnit * XLALUnitDivide( LALUnit *output, const LALUnit *unit1,
	const LALUnit *unit2 );		const LALUnit *unit2 );
	LALUnit * XLALUnitRaiseRAT4( LALUnit *output, const LALUnit *input,		LALUnit * XLALUnitRaiseRAT4( LALUnit *output, const LALUnit *input,
	const RAT4 *power );		const RAT4 *power );
	LALUnit * XLALUnitRaiseINT2( LALUnit *output, const LALUnit *input,		LALUnit * XLALUnitRaiseINT2( LALUnit *output, const LALUnit *input,
	INT2 power );		INT2 power );
	LALUnit * XLALUnitSquare( LALUnit *output, const LALUnit *input );		LALUnit * XLALUnitSquare( LALUnit *output, const LALUnit *input );
	LALUnit * XLALUnitSqrt( LALUnit *output, const LALUnit *input );		LALUnit * XLALUnitSqrt( LALUnit *output, const LALUnit *input );
	LALUnit * XLALUnitInvert( LALUnit *output, const LALUnit *input );		LALUnit * XLALUnitInvert( LALUnit *output, const LALUnit *input );
	REAL8 XLALUnitPrefactor(const LALUnit *unit);		REAL8 XLALUnitPrefactor(const LALUnit *unit);
	int XLALUnitIsDimensionless(const LALUnit *unit);		int XLALUnitIsDimensionless(const LALUnit *unit);
	REAL8 XLALUnitRatio(const LALUnit *unit1, const LALUnit *unit2);		REAL8 XLALUnitRatio(const LALUnit *unit1, const LALUnit *unit2);
			/** @} */
	/* LALUnitNormalize will reduce the rational powers in the basic unit		/* LALUnitNormalize() will reduce the rational powers in the basic unit
	* exponents, e.g. converting 2/2 to 1/1 and 3/6 to 1/2.		* exponents, e.g. converting 2/2 to 1/1 and 3/6 to 1/2.
	*/		*/
	void LALUnitNormalize (LALStatus *status, LALUnit *output,		void LALUnitNormalize (LALStatus *status, LALUnit *output,
	const LALUnit *input);		const LALUnit *input);
	/* Several functions take two Unit variables as input, so need the		/* Several functions take two Unit variables as input, so need the
	* following structure.		* following structure.
	*/		*/
			/* Consists of a pair of unit structures; used as an input structure for
			* the LALUnitCompare() and LALUnitMultiply() functions.
			*/
	typedef struct		typedef struct
	tagLALUnitPair		tagLALUnitPair
	{		{
	const LALUnit *unitOne;		SWIGLAL_STRUCT(LALUnitPair);
	const LALUnit *unitTwo;		const LALUnit *unitOne; /**< The first unit */
			const LALUnit *unitTwo; /**< The second unit */
	}		}
	LALUnitPair;		LALUnitPair;
	/* LALUnitMultiply will multiply together two Unit variables and		/* LALUnitMultiply will multiply together two Unit variables and
	* output their product; it will call LALUnitNormalize.		* output their product; it will call LALUnitNormalize.
	*/		*/
	void LALUnitMultiply (LALStatus *status, LALUnit *output,		void LALUnitMultiply (LALStatus *status, LALUnit *output,
	const LALUnitPair *input);		const LALUnitPair *input);
	/* LALUnitCompare will compare two Unit variables and return true if		/* LALUnitCompare will compare two Unit variables and return true if
	* they are the equivalent (the same power of ten offset as well as		* they are the equivalent (the same power of ten offset as well as
	* equivalent ratioanl powers of the base units).		* equivalent ratioanl powers of the base units).
	*/		*/
	void LALUnitCompare (LALStatus *status, BOOLEAN *output,		void LALUnitCompare (LALStatus *status, BOOLEAN *output,
	const LALUnitPair *input);		const LALUnitPair *input);
	/* LALUnitRaise will raise a unit structure to a rational power; the		/* LALUnitRaise() will raise a unit structure to a rational power; the
	* most common choices will presumably be -1, 2, and 1/2. An error		* most common choices will presumably be -1, 2, and 1/2. An error
	* occurs if input->powerOfTen is not evenly divisible by the		* occurs if input->powerOfTen is not evenly divisible by the
	* denominator of the specified power		* denominator of the specified power
	*/		*/
	void LALUnitRaise (LALStatus *status, LALUnit *output,		void LALUnitRaise (LALStatus *status, LALUnit *output,
	const LALUnit *input, const RAT4 *power);		const LALUnit *input, const RAT4 *power);
	/* LALUnitAsString will convert an LALUnit structure into a		/** Converts a LALUnit structure into a human-readable text form.
	* human-readable text form.
	*/		*/
	void LALUnitAsString (LALStatus *status, CHARVector *output,		void LALUnitAsString (LALStatus *status, CHARVector *output,
	const LALUnit *input);		const LALUnit *input);
	void		void
	LALParseUnitString ( LALStatus *status,		LALParseUnitString ( LALStatus *status,
	LALUnit *output,		LALUnit *output,
	const CHARVector *input );		const CHARVector *input );
	enum { LALUnitNameSize = sizeof("strain") };		#ifndef SWIG /* exclude from SWIG interface */
	enum { LALUnitTextSize = sizeof("10^-32768 m^-32768/32767 kg^-32768/32767 "		enum enumLALUnitNameSize {
	"s^-32768/32767 A^-32768/32767 "		LALUnitNameSize = sizeof("strain")
	"K^-32768/32767 strain^-32768/32767 "		};
	"count^-32768/32767") };		enum enumLALUnitTextSize {
			LALUnitTextSize = sizeof("10^-32768 m^-32768/32767 kg^-32768/32767 "
			"s^-32768/32767 A^-32768/32767 "
			"K^-32768/32767 strain^-32768/32767 "
			"count^-32768/32767")
			};
	extern const CHAR lalUnitName[LALNumUnits][LALUnitNameSize];		extern const CHAR lalUnitName[LALNumUnits][LALUnitNameSize];
			#endif /* SWIG */
	/*********************************************************		/*********************************************************
	* *		* *
	* Predefined units *		* Predefined units *
	* *		* *
	*********************************************************/		*********************************************************/
	/* Predefined constant units make it easier for programmers to specify		/* Predefined constant units make it easier for programmers to specify
	* and compare (using LALUnitCompare) units more easily. Those given		* and compare (using LALUnitCompare) units more easily. Those given
	* here are an example; more can be added.		* here are an example; more can be added.
End of changes. 50 change blocks.
	162 lines changed or deleted		125 lines changed or added

	VectorIndexRange.h		VectorIndexRange.h
	/* -*- C -*- */		/* -*- C -*- */
	/******** <lalVerbatim file="VectorIndexRangeHV"> ********		/**
	Author: David Chin <dwchin@umich.edu> +1-734-709-9119		* \author David Chin <dwchin@umich.edu> +1-734-709-9119
	$Id$		* \addtogroup VectorIndexRange_h
	********* </lalVerbatim> ********/
	/**** <lalLaTeX>
	*
	* \section{Header \texttt{VectorIndexRange.h}}
	*		*
	* Routines to slice up vectors/sequences by		* \section TODOref Header \ref VectorIndexRange.h
	* specifying starting and ending indices, inclusive.
	* \texttt{VectorIndexHole()}
	* is "complementary" to \texttt{VectorIndexRange()}, in the sense that
	* it returns the two segments of the vector that would remain after
	* \texttt{VectorIndexRange()} acts.
	*		*
	* \subsection*{Synopsis}		* \brief Routines to slice up vectors/sequences by specifying starting and
	* \begin{verbatim}		ending indices, inclusive.
	* #include <lal/VectorIndexRange.h>
	* \end{verbatim}
	*		*
	* \subsection*{Error conditions}		* VectorIndexHole() is "complementary" to VectorIndexRange(), in the sense
	* \input{VectorIndexRangeHE}		that
			* it returns the two segments of the vector that would remain after Vector
			IndexRange() acts.
	*		*
	* \vfill{\footnotesize\input{VectorIndexRangeHV}}		* \heading{Synopsis}
	* \newpage\input{VectorIndexRangeC}		* \code
			* #include <lal/VectorIndexRange.h>
			* \endcode
	*		*
	***** </lalLaTeX> */		* @{
			*/
	#include <math.h>		#include <math.h>
	#include <lal/LALRCSID.h>		#include <lal/LALRCSID.h>
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#include <lal/SeqFactories.h>		#include <lal/SeqFactories.h>
	#include <lal/AVFactories.h>		#include <lal/AVFactories.h>
	#ifndef __LALVECTORINDEXRANGE_H__		#ifndef __LALVECTORINDEXRANGE_H__
	#define __LALVECTORINDEXRANGE_H__		#define __LALVECTORINDEXRANGE_H__
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT
			#endif
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif /* C++ */		#endif /* C++ */
	NRCSID( VECTORINDEXRANGEH, "$Id$" );		/**\name Error Codes */ /*@{*/
			#define VECTORINDEXRANGEH_EARG 1 /**< Error parsing command-line argu
			ments */
			#define VECTORINDEXRANGEH_ECHK 2 /**< Error checking failed to catch
			bad data */
			#define VECTORINDEXRANGEH_EFLS 3 /**< Incorrect answer for valid data
			*/
			#define VECTORINDEXRANGEH_EUSE 4 /**< Bad user-entered data */
			#define VECTORINDEXRANGEH_ENULL 5 /**< Null Pointer */
			#define VECTORINDEXRANGEH_EALOC 6 /**< Memory Allocation Error */
			#define VECTORINDEXRANGEH_EFPMS 7 /**< Filter Parameter Structure Erro
			r */
			#define VECTORINDEXRANGEH_ENUMZ 8 /**< Incorrect number of command lin
			e arguments */
			#define VECTORINDEXRANGEH_ELNTH 9 /**< Vector/Array of Improper Length
			*/
			#define VECTORINDEXRANGEH_ENNUL 10 /**< Non-Null Pointer that should be
			NULL */
			/** @}*/
			/** @}*/
	/**** <lalErrTable file="VectorIndexRangeHE"> ****/
	#define VECTORINDEXRANGEH_EARG 1
	#define VECTORINDEXRANGEH_ECHK 2
	#define VECTORINDEXRANGEH_EFLS 3
	#define VECTORINDEXRANGEH_EUSE 4
	#define VECTORINDEXRANGEH_ENULL 5
	#define VECTORINDEXRANGEH_EALOC 6
	#define VECTORINDEXRANGEH_EFPMS 7
	#define VECTORINDEXRANGEH_ENUMZ 8
	#define VECTORINDEXRANGEH_ELNTH 9
	#define VECTORINDEXRANGEH_ENNUL 10
	#define VECTORINDEXRANGEH_MSGEARG "Error parsing command-line arguments"		#define VECTORINDEXRANGEH_MSGEARG "Error parsing command-line arguments"
	#define VECTORINDEXRANGEH_MSGECHK "Error checking failed to catch bad data"		#define VECTORINDEXRANGEH_MSGECHK "Error checking failed to catch bad data"
	#define VECTORINDEXRANGEH_MSGEFLS "Incorrect answer for valid data"		#define VECTORINDEXRANGEH_MSGEFLS "Incorrect answer for valid data"
	#define VECTORINDEXRANGEH_MSGEUSE "Bad user-entered data"		#define VECTORINDEXRANGEH_MSGEUSE "Bad user-entered data"
	#define VECTORINDEXRANGEH_MSGENULL "Null Pointer."		#define VECTORINDEXRANGEH_MSGENULL "Null Pointer."
	#define VECTORINDEXRANGEH_MSGEALOC "Memory Allocation Error"		#define VECTORINDEXRANGEH_MSGEALOC "Memory Allocation Error"
	#define VECTORINDEXRANGEH_MSGEFPMS "Filter Parameter Structure Error"		#define VECTORINDEXRANGEH_MSGEFPMS "Filter Parameter Structure Error"
	#define VECTORINDEXRANGEH_MSGENUMZ "Incorrect number of command line argume nts"		#define VECTORINDEXRANGEH_MSGENUMZ "Incorrect number of command line argume nts"
	#define VECTORINDEXRANGEH_MSGELNTH "Vector/Array of Improper Length"		#define VECTORINDEXRANGEH_MSGELNTH "Vector/Array of Improper Length"
	#define VECTORINDEXRANGEH_MSGENNUL "Non-Null Pointer that should be NULL"		#define VECTORINDEXRANGEH_MSGENNUL "Non-Null Pointer that should be NULL"
	/**** </lalErrTable> ****/
	/* typedefs */
	/*		NRCSID( VECTORINDEXRANGEH, "$Id$" );
	*/		/* typedefs */
			/* CHAR */
	typedef struct		typedef struct
	tagCHARVectorPair {		tagCHARVectorPair {
			SWIGLAL_STRUCT(CHARVectorPair);
	CHARVector **head;		CHARVector **head;
	CHARVector **tail;		CHARVector **tail;
	} CHARVectorPair;		} CHARVectorPair;
	/*		/* INT2 */
	*/
	typedef struct		typedef struct
	tagINT2VectorPair {		tagINT2VectorPair {
			SWIGLAL_STRUCT(INT2VectorPair);
	INT2Vector **head;		INT2Vector **head;
	INT2Vector **tail;		INT2Vector **tail;
	} INT2VectorPair;		} INT2VectorPair;
	/*		/* INT4 */
	*/
	typedef struct		typedef struct
	tagINT4VectorPair {		tagINT4VectorPair {
			SWIGLAL_STRUCT(INT4VectorPair);
	INT4Vector **head;		INT4Vector **head;
	INT4Vector **tail;		INT4Vector **tail;
	} INT4VectorPair;		} INT4VectorPair;
	/*		/* INT8 */
	*/
	typedef struct		typedef struct
	tagINT8VectorPair {		tagINT8VectorPair {
			SWIGLAL_STRUCT(INT8VectorPair);
	INT8Vector **head;		INT8Vector **head;
	INT8Vector **tail;		INT8Vector **tail;
	} INT8VectorPair;		} INT8VectorPair;
	/*		/* UINT2 */
	*/
	typedef struct		typedef struct
	tagUINT2VectorPair {		tagUINT2VectorPair {
			SWIGLAL_STRUCT(UINT2VectorPair);
	UINT2Vector **head;		UINT2Vector **head;
	UINT2Vector **tail;		UINT2Vector **tail;
	} UINT2VectorPair;		} UINT2VectorPair;
	/*		/* UINT4 */
	*/
	typedef struct		typedef struct
	tagUINT4VectorPair {		tagUINT4VectorPair {
			SWIGLAL_STRUCT(UINT4VectorPair);
	UINT4Vector **head;		UINT4Vector **head;
	UINT4Vector **tail;		UINT4Vector **tail;
	} UINT4VectorPair;		} UINT4VectorPair;
	/*		/* UINT8 */
	*/
	typedef struct		typedef struct
	tagUINT8VectorPair {		tagUINT8VectorPair {
			SWIGLAL_STRUCT(UINT8VectorPair);
	UINT8Vector **head;		UINT8Vector **head;
	UINT8Vector **tail;		UINT8Vector **tail;
	} UINT8VectorPair;		} UINT8VectorPair;
	/*		/* REAL4 */
	*/
	typedef struct		typedef struct
	tagREAL4VectorPair {		tagREAL4VectorPair {
			SWIGLAL_STRUCT(REAL4VectorPair);
	REAL4Vector **head;		REAL4Vector **head;
	REAL4Vector **tail;		REAL4Vector **tail;
	} REAL4VectorPair;		} REAL4VectorPair;
	/*		/* REAL8 */
	*/
	typedef struct		typedef struct
	tagREAL8VectorPair {		tagREAL8VectorPair {
			SWIGLAL_STRUCT(REAL8VectorPair);
	REAL8Vector **head;		REAL8Vector **head;
	REAL8Vector **tail;		REAL8Vector **tail;
	} REAL8VectorPair;		} REAL8VectorPair;
	/*		/* COMPLEX8 */
	*/
	typedef struct		typedef struct
	tagCOMPLEX8VectorPair {		tagCOMPLEX8VectorPair {
			SWIGLAL_STRUCT(COMPLEX8VectorPair);
	COMPLEX8Vector **head;		COMPLEX8Vector **head;
	COMPLEX8Vector **tail;		COMPLEX8Vector **tail;
	} COMPLEX8VectorPair;		} COMPLEX8VectorPair;
	/*		/* COMPLEX16 */
	*/
	typedef struct		typedef struct
	tagCOMPLEX16VectorPair {		tagCOMPLEX16VectorPair {
			SWIGLAL_STRUCT(COMPLEX16VectorPair);
	COMPLEX16Vector **head;		COMPLEX16Vector **head;
	COMPLEX16Vector **tail;		COMPLEX16Vector **tail;
	} COMPLEX16VectorPair;		} COMPLEX16VectorPair;
	/* Function protos */		/* Function protos */
	/*		/* CHAR */
	*/
	void LALCHARVectorIndexRange ( LALStatus *status,		void LALCHARVectorIndexRange ( LALStatus *status,
	CHARVector **result,		CHARVector **result,
	CHARVector *v,		CHARVector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALCHARVectorIndexHole ( LALStatus *status,		void LALCHARVectorIndexHole ( LALStatus *status,
	CHARVectorPair *result_pair,		CHARVectorPair *result_pair,
	CHARVector *v,		CHARVector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* INT2 */
	*/
	void LALI2VectorIndexRange ( LALStatus *status,		void LALI2VectorIndexRange ( LALStatus *status,
	INT2Vector **result,		INT2Vector **result,
	INT2Vector *v,		INT2Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALI2VectorIndexHole ( LALStatus *status,		void LALI2VectorIndexHole ( LALStatus *status,
	INT2VectorPair *result_pair,		INT2VectorPair *result_pair,
	INT2Vector *v,		INT2Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* INT4 */
	*/
	void LALI4VectorIndexRange ( LALStatus *status,		void LALI4VectorIndexRange ( LALStatus *status,
	INT4Vector **result,		INT4Vector **result,
	INT4Vector *v,		INT4Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALI4VectorIndexHole ( LALStatus *status,		void LALI4VectorIndexHole ( LALStatus *status,
	INT4VectorPair *result_pair,		INT4VectorPair *result_pair,
	INT4Vector *v,		INT4Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* INT8 */
	*/
	void LALI8VectorIndexRange ( LALStatus *status,		void LALI8VectorIndexRange ( LALStatus *status,
	INT8Vector **result,		INT8Vector **result,
	INT8Vector *v,		INT8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALI8VectorIndexHole ( LALStatus *status,		void LALI8VectorIndexHole ( LALStatus *status,
	INT8VectorPair *result_pair,		INT8VectorPair *result_pair,
	INT8Vector *v,		INT8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* UINT2 */
	*/
	void LALU2VectorIndexRange ( LALStatus *status,		void LALU2VectorIndexRange ( LALStatus *status,
	UINT2Vector **result,		UINT2Vector **result,
	UINT2Vector *v,		UINT2Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALU2VectorIndexHole ( LALStatus *status,		void LALU2VectorIndexHole ( LALStatus *status,
	UINT2VectorPair *result_pair,		UINT2VectorPair *result_pair,
	UINT2Vector *v,		UINT2Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* UINT4 */
	*/
	void LALU4VectorIndexRange ( LALStatus *status,		void LALU4VectorIndexRange ( LALStatus *status,
	UINT4Vector **result,		UINT4Vector **result,
	UINT4Vector *v,		UINT4Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALU4VectorIndexHole ( LALStatus *status,		void LALU4VectorIndexHole ( LALStatus *status,
	UINT4VectorPair *result_pair,		UINT4VectorPair *result_pair,
	UINT4Vector *v,		UINT4Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* UINT8 */
	*/
	void LALU8VectorIndexRange ( LALStatus *status,		void LALU8VectorIndexRange ( LALStatus *status,
	UINT8Vector **result,		UINT8Vector **result,
	UINT8Vector *v,		UINT8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALU8VectorIndexHole ( LALStatus *status,		void LALU8VectorIndexHole ( LALStatus *status,
	UINT8VectorPair *result_pair,		UINT8VectorPair *result_pair,
	UINT8Vector *v,		UINT8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* REAL4 */
	*/
	void LALSVectorIndexRange ( LALStatus *status,		void LALSVectorIndexRange ( LALStatus *status,
	REAL4Vector **result,		REAL4Vector **result,
	REAL4Vector *v,		REAL4Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALSVectorIndexHole ( LALStatus *status,		void LALSVectorIndexHole ( LALStatus *status,
	REAL4VectorPair *result_pair,		REAL4VectorPair *result_pair,
	REAL4Vector *v,		REAL4Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* REAL8 */
	*/
	void LALDVectorIndexRange ( LALStatus *status,		void LALDVectorIndexRange ( LALStatus *status,
	REAL8Vector **result,		REAL8Vector **result,
	REAL8Vector *v,		REAL8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALDVectorIndexHole ( LALStatus *status,		void LALDVectorIndexHole ( LALStatus *status,
	REAL8VectorPair *result_pair,		REAL8VectorPair *result_pair,
	REAL8Vector *v,		REAL8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* COMPLEX8 */
	*/
	void LALCVectorIndexRange ( LALStatus *status,		void LALCVectorIndexRange ( LALStatus *status,
	COMPLEX8Vector **result,		COMPLEX8Vector **result,
	COMPLEX8Vector *v,		COMPLEX8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALCVectorIndexHole ( LALStatus *status,		void LALCVectorIndexHole ( LALStatus *status,
	COMPLEX8VectorPair *result_pair,		COMPLEX8VectorPair *result_pair,
	COMPLEX8Vector *v,		COMPLEX8Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	/*		/* COMPLEX16 */
	*/
	void LALZVectorIndexRange ( LALStatus *status,		void LALZVectorIndexRange ( LALStatus *status,
	COMPLEX16Vector **result,		COMPLEX16Vector **result,
	COMPLEX16Vector *v,		COMPLEX16Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	void LALZVectorIndexHole ( LALStatus *status,		void LALZVectorIndexHole ( LALStatus *status,
	COMPLEX16VectorPair *result_pair,		COMPLEX16VectorPair *result_pair,
	COMPLEX16Vector *v,		COMPLEX16Vector *v,
	const UINT4Vector *indexVector );		const UINT4Vector *indexVector );
	#ifdef __cplusplus		#ifdef __cplusplus
	}		}
	#endif /* C++ */		#endif /* C++ */
	#endif /* __LALVECTORINDEXRANGE_H__ */		#endif /* __LALVECTORINDEXRANGE_H__ */
End of changes. 56 change blocks.
	135 lines changed or deleted		77 lines changed or added

	VectorOps.h		VectorOps.h
	skipping to change at line 20		skipping to change at line 20
	* but WITHOUT ANY WARRANTY; without even the implied warranty of		* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.		* GNU General Public License for more details.
	*		*
	* You should have received a copy of the GNU General Public License		* You should have received a copy of the GNU General Public License
	* along with with program; see the file COPYING. If not, write to the		* along with with program; see the file COPYING. If not, write to the
	* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,		* Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	* MA 02111-1307 USA		* MA 02111-1307 USA
	*/		*/
	/**** <lalVerbatim file="VectorOpsHV">		/**
	* Author: J. D. E. Creighton, T. D. Creighton, A. M. Sintes		* \addtogroup VectorOps_h
	* $Id$		* \author J. D. E. Creighton, T. D. Creighton, A. M. Sintes
	**** </lalVerbatim> */
	/**** <lalLaTeX>
	*
	* \section{Header \texttt{VectorOps.h}}
	*		*
	* Basic vector manipulation operations.		* \brief Basic vector manipulation operations.
	*		*
	* \subsection*{Synopsis}		* \heading{Synopsis}
	* \begin{verbatim}		* \code
	* #include <lal/VectorOps.h>		* #include <lal/VectorOps.h>
	* \end{verbatim}		* \endcode
	*
	* \subsection*{Error conditions}
	* \input{VectorOpsHE}
	*		*
	* \vfill{\footnotesize\input{VectorOpsHV}}		* @{
	* \newpage\input{VectorMultiplyC}		* \defgroup VectorMultiply_c Module VectorMultiply.c
	* \newpage\input{VectorPolarC}		* \defgroup VectorPolar_c Module VectorPolar.c
	* \newpage\input{VectorOpsTestC}
	*		*
	**** </lalLaTeX> */		*/
	#ifndef _VECTOROPS_H		#ifndef _VECTOROPS_H
	#define _VECTOROPS_H		#define _VECTOROPS_H
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID (VECTOROPSH, "$Id$");		/** \name Error Codes
			* @{*/
	/**** <lalErrTable file="VectorOpsHE"> */		#define VECTOROPSH_ENULL 1 /**< Null pointer */
	#define VECTOROPSH_ENULL 1		#define VECTOROPSH_ESIZE 2 /**< Invalid input size */
	#define VECTOROPSH_ESIZE 2		#define VECTOROPSH_ESZMM 4 /**< Size mismatch */
	#define VECTOROPSH_ESZMM 4		#define VECTOROPSH_ESAME 8 /**< Input/Output data vectors are the same
	#define VECTOROPSH_ESAME 8		*/
			/** @}*/
			/** @}*/
	#define VECTOROPSH_MSGENULL "Null pointer"		#define VECTOROPSH_MSGENULL "Null pointer"
	#define VECTOROPSH_MSGESIZE "Invalid input size"		#define VECTOROPSH_MSGESIZE "Invalid input size"
	#define VECTOROPSH_MSGESZMM "Size mismatch"		#define VECTOROPSH_MSGESZMM "Size mismatch"
	#define VECTOROPSH_MSGESAME "Input/Output data vectors are the same"		#define VECTOROPSH_MSGESAME "Input/Output data vectors are the same"
	/**** </lalErrTable> */
			NRCSID (VECTOROPSH, "$Id$");
	/*		/*
	*		*
	* XLAL Routines.		* XLAL Routines.
	*		*
	*/		*/
	/* sigle precision */		/* sigle precision */
	COMPLEX8Vector * XLALCCVectorDivide( COMPLEX8Vector *out, const COMPLEX8Vec tor *in1, const COMPLEX8Vector *in2 );		COMPLEX8Vector * XLALCCVectorDivide( COMPLEX8Vector *out, const COMPLEX8Vec tor *in1, const COMPLEX8Vector *in2 );
	COMPLEX8Vector * XLALCCVectorMultiply( COMPLEX8Vector *out, const COMPLEX8V ector *in1, const COMPLEX8Vector *in2 );		COMPLEX8Vector * XLALCCVectorMultiply( COMPLEX8Vector *out, const COMPLEX8V ector *in1, const COMPLEX8Vector *in2 );
	skipping to change at line 226		skipping to change at line 220
	);		);
	void		void
	LALDDVectorMultiply(		LALDDVectorMultiply(
	LALStatus *,		LALStatus *,
	REAL8Vector *,		REAL8Vector *,
	const REAL8Vector *,		const REAL8Vector *,
	const REAL8Vector *		const REAL8Vector *
	);		);
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _VECTOROPS_H */		#endif /* _VECTOROPS_H */
End of changes. 11 change blocks.
	32 lines changed or deleted		28 lines changed or added

	Window.h		Window.h
	skipping to change at line 24		skipping to change at line 24
	*		*
	* You should have received a copy of the GNU General Public License along		* 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 Free		* with with program; see the file COPYING. If not, write to the Free
	* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA		* Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	* 02111-1307 USA		* 02111-1307 USA
	*/		*/
	#ifndef _WINDOW_H		#ifndef _WINDOW_H
	#define _WINDOW_H		#define _WINDOW_H
			/* remove SWIG interface directives */
			#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
			#define SWIGLAL_STRUCT(...)
			#endif
	#include <lal/LALDatatypes.h>		#include <lal/LALDatatypes.h>
	#ifdef __cplusplus		#ifdef __cplusplus
	extern "C" {		extern "C" {
	#endif		#endif
	NRCSID (WINDOWH, "$Id$");		NRCSID (WINDOWH, "$Id$");
	typedef struct tagREAL4Window {		typedef struct tagREAL4Window {
			SWIGLAL_STRUCT(REAL4Window);
	REAL4Sequence *data;		REAL4Sequence *data;
	REAL8 sumofsquares;		REAL8 sumofsquares;
	REAL8 sum;		REAL8 sum;
	} REAL4Window;		} REAL4Window;
	typedef struct tagREAL8Window {		typedef struct tagREAL8Window {
			SWIGLAL_STRUCT(REAL8Window);
	REAL8Sequence *data;		REAL8Sequence *data;
	REAL8 sumofsquares;		REAL8 sumofsquares;
	REAL8 sum;		REAL8 sum;
	} REAL8Window;		} REAL8Window;
	REAL4Window *XLALCreateREAL4WindowFromSequence(REAL4Sequence *sequence);		REAL4Window *XLALCreateREAL4WindowFromSequence(REAL4Sequence *sequence);
	REAL8Window *XLALCreateREAL8WindowFromSequence(REAL8Sequence *sequence);		REAL8Window *XLALCreateREAL8WindowFromSequence(REAL8Sequence *sequence);
	REAL4Window *XLALCreateRectangularREAL4Window(UINT4 length);		REAL4Window *XLALCreateRectangularREAL4Window(UINT4 length);
	REAL4Window *XLALCreateHannREAL4Window(UINT4 length);		REAL4Window *XLALCreateHannREAL4Window(UINT4 length);
End of changes. 3 change blocks.
	0 lines changed or deleted		7 lines changed or added

	XLALError.h		XLALError.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
	*/		*/
	/** \file		/** \file XLALError.h
	* \ingroup std		* \ingroup std
	* \author Creighton, J. D. E.		* \author Creighton, J. D. E.
	* \date 2005		* \date 2005
	* \brief This header covers routines to provide the XLAL interface error h		* \brief This header covers routines to provide the XLAL interface error
	andling.		* handling.
	*		*
	* \par XLAL Errors		* \par XLAL Errors
	*		*
	* When an XLAL routine fails, the routine should set the <tt>xlalErrno</tt > to		* When an XLAL routine fails, the routine should set the <tt>xlalErrno</tt > to
	* an appropriate error number and return with the appropriate error code. The		* an appropriate error number and return with the appropriate error code. The
	* return value depends on the return type of the XLAL function. Furthermo		* return value depends on the return type of the XLAL function. Furthermo
	re, the		re,
	* XLAL error handler should be invoked.		* the XLAL error handler should be invoked.
	*		*
	* Whenever possible (i.e., always), standard XLAL error macros should be u sed		* Whenever possible (i.e., always), standard XLAL error macros should be u sed
	* when generating an error. These macros (i) invoke the current error han dler,		* when generating an error. These macros (i) invoke the current error han dler,
	* (ii) set the error code to the specified value, and (iii) return with th e		* (ii) set the error code to the specified value, and (iii) return with th e
	* correct return value. The error macros that should be used are:		* correct return value. In addition, these macros may take an optional
			* printf-like format string (along with additional parameters for this for
			mat
			* string) to provide additional information about the nature of the failur
			e.
			* The error macros that should be used are:
	*		*
	* <tt>XLAL_ERROR(func,errnum)</tt> for XLAL routines returning an integer		* <tt>XLAL_ERROR(errnum [, fmt [, ...]])</tt> for XLAL routines returning
	type.		an
			* integer type.
	*		*
	* <tt>XLAL_ERROR_VOID(func,errnum)</tt> for XLAL routines with no return v		* <tt>XLAL_ERROR_VOID(errnum [, fmt [, ...]])</tt> for XLAL routines with
	alue.		no
			* return value.
	*		*
	* <tt>XLAL_ERROR_NULL(func,errnum)</tt> for XLAL routines returning a poin		* <tt>XLAL_ERROR_NULL(errnum [, fmt [, ...]])</tt> for XLAL routines retur
	ter.		ning
			* a pointer.
	*		*
	* <tt>XLAL_ERROR_REAL4(func,errnum)</tt> for XLAL routines returning a <tt		* <tt>XLAL_ERROR_REAL4(errnum [, fmt [, ...]])</tt> for XLAL routines
	>REAL4</tt>		* returning a <tt>REAL4</tt> floating-point value.
	* floating-point value.
	*		*
	* <tt>XLAL_ERROR_REAL8(func,errnum)</tt> for XLAL routines returning a <tt		* <tt>XLAL_ERROR_REAL8(errnum [, fmt [, ...]])</tt> for XLAL routines
	>REAL8</tt>		* returning a <tt>REAL8</tt> floating-point value.
	* floating-point value.
	*		*
	* Additional error, warning, and informational messages can be generated u		* Assert-like error checking can be performed with <tt>XLAL_CHECK</tt>-sty
	sing the		le
	* routines <tt>XLALPrintError()</tt>, <tt>XLALPrintWarning()</tt> and		* macros. Unlike <tt>assert()</tt> statements, <tt>XLAL_CHECK</tt> macros
	* <tt>XLALPrintInfo()</tt>. These routines (which work just like <tt>prin		* do <i>not</i> get removed when the code is not compiled with
	tf()</tt>)		* <tt>NDEBUG</tt> defined.
	* print or suppress the message depending on the value of <tt>lalDebugLeve
	l</tt>.
	*		*
	* On rare occations, you may be prepared for an XLAL routine to fail, and		* Additional error, warning, and informational messages can be generated u
	may want		sing
	* to handle the failure immediately. In these circumstances, the XLAL err		* the routines <tt>XLALPrintError()</tt>, <tt>XLALPrintWarning()</tt> and
	or handler		* <tt>XLALPrintInfo()</tt>. These routines (which work just like
	* needs to be disabled before the routine is called so that the failure ca		* <tt>printf()</tt>) print or suppress the message depending on the value
	n be		of
	* caught. The <tt>XLAL_TRY(statement,errnum)</tt> macro is designed to be		* <tt>lalDebugLevel</tt>. To print error/warning/info messages with a
	used in		* standard format, use the macros
	* these situations. Here is an example:		* <tt>XLAL_PRINT_ERROR(fmt [, ...])</tt>
			* <tt>XLAL_PRINT_WARNING(fmt [, ...])</tt>
			* <tt>XLAL_PRINT_INFO(fmt [, ...])</tt>
			*
			* On rare occations, you may be prepared for an XLAL routine to fail, and
			may
			* want to handle the failure immediately. In these circumstances, the XLA
			L
			* error handler needs to be disabled before the routine is called so that
			the
			* failure can be caught. The <tt>XLAL_TRY(statement,errnum)</tt> macro is
			* designed to be used in these situations. Here is an example:
	* \code		* \code
	* REAL8 XLALLogFactorial( INT4 n )		* REAL8 XLALLogFactorial(INT4 n)
	* {		* {
	* REAL8 y;		* REAL8 y;
	* int errnum;		* int errnum;
	* XLAL_TRY( y = XLALGammaFunction( n + 1 ), errnum );		* XLAL_TRY(y = XLALGammaFunction(n + 1), errnum);
	* if ( XLAL_IS_REAL8_FAIL_NAN( y ) )		* if (XLAL_IS_REAL8_FAIL_NAN(y))
	* switch ( errnum )		* switch (errnum) {
	* {		* case XLAL_ERANGE:
	* case XLAL_ERANGE:		* y = n * (log(n) - 1);
	* y = n * ( log(n) - 1 );		* y += 0.5 * log(2.0 * LAL_PI * n);
	* y += 0.5 * log( 2.0 * LAL_PI * n );		* return y;
	* return y;		* default:
	* default:		* XLALSetErrno(errnum);
	* XLALSetErrno( errnum );		* XLAL_ERROR_REAL8(XLAL_EFUNC);
	* XLAL_ERROR_REAL8( "XLALLogFactorial", XLAL_EFUNC );		* }
	* }		* return log(y);
	* return log( y );
	* }		* }
	* \endcode		* \endcode
	*		*
	* \par XLAL Function Return Codes		* \par XLAL Function Return Codes
	*		*
	* XLAL functions that return an integer-type will return <tt>XLAL_FAILURE< /tt>		* XLAL functions that return an integer-type will return <tt>XLAL_FAILURE< /tt>
	* on failure. XLAL functions that return a pointer will return <tt>NULL</ tt>		* on failure. XLAL functions that return a pointer will return <tt>NULL</ tt>
	* on failure.		* on failure.
	*		*
	* The LAL specification requires that XLAL functions that return a		* The LAL specification requires that XLAL functions that return a
	* floating-point type (either <tt>REAL4</tt> or <tt>REAL8</tt>) should ret		* floating-point type (either <tt>REAL4</tt> or <tt>REAL8</tt>) should ret
	urn a particular		urn
	* value to indicate an error. These values are given by the macros		* a particular value to indicate an error. These values are given by the
	* <tt>XLAL_REAL4_FAIL_NAN</tt> and <tt>XLAL_REAL8_FAIL_NAN</tt> (they are		* macros <tt>XLAL_REAL4_FAIL_NAN</tt> and <tt>XLAL_REAL8_FAIL_NAN</tt> (th
	Not a Number		ey
	* or NaN values). To implement these we choose hexadecimal representation		* are Not a Number or NaN values). To implement these we choose hexadecim
	s		al
	* and then provide static functions that return the equivalent <tt>REAL4</		* representations and then provide static functions that return the equiva
	tt> or		lent
	* <tt>REAL8</tt> values. The macros then invoke these functions. This is		* <tt>REAL4</tt> or <tt>REAL8</tt> values. The macros then invoke these
	done		* functions. This is done so that the compiler can easily inline the
	* so that the compiler can easily inline the functions (or eliminate them		* functions (or eliminate them if they are not used). Conversion from the
	* if they are not used). Conversion from the hexadecimal representation		* hexadecimal representation to the floating-point representation is done
	* to the floating-point representation is done using a union.		* using a union.
	*		*
	* The LAL specification also requires that there be two macros,		* The LAL specification also requires that there be two macros,
	* <tt>XLAL_IS_REAL4_FAIL_NAN(val)</tt> and <tt>XLAL_IS_REAL8_FAIL_NAN(val)		* <tt>XLAL_IS_REAL4_FAIL_NAN(val)</tt> and
	</tt> that will		* <tt>XLAL_IS_REAL8_FAIL_NAN(val)</tt> that will test if val is one of the
	* test if val is one of these XLAL-specific fail NaNs. Again these macros		se
	* invoke static functions that return the result of the comparison. The		* XLAL-specific fail NaNs. Again these macros invoke static functions tha
	* cmparison itself is done with the hexadecimal representation.		t
			* return the result of the comparison. The cmparison itself is done with
			the
			* hexadecimal representation.
	*		*
	* \par XLAL Error Codes		* \par XLAL Error Codes
	*		*
	* The LAL specification requires particular return code and error values.		* The LAL specification requires particular return code and error values.
	* These are implemented here as enumeration constants in the <tt>XLALError		* These are implemented here as enumeration constants in the
	Value</tt>		* <tt>XLALErrorValue</tt> enumeration.
	* enumeration.
	*
	*/		*/
	#ifndef XLALERROR_H		#ifndef XLALERROR_H
	#define XLALERROR_H		#define XLALERROR_H
			#include <stdarg.h>
	#include <stddef.h>		#include <stddef.h>
	#include <lal/LALAtomicDatatypes.h>		#include <lal/LALAtomicDatatypes.h>
	NRCSID( XLALERRORH, "$Id$" );		NRCSID( XLALERRORH, "$Id$" );
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	/*		/*
	*		*
	* Use these functions to print arbitrary messages as errors or warnings.		* Use these functions to print arbitrary messages as errors or warnings.
	*		*
	*/		*/
	/** Prints an error message if error printing is enabled by lalDebugLevel. */		/** Prints an error message if error printing is enabled by lalDebugLevel. */
	int XLALPrintError( const char *fmt, ... );		int XLALPrintError(const char *fmt, ...);
	/** Prints a warning message if warning printing is enabled by lalDebugLeve l. */		/** Prints a warning message if warning printing is enabled by lalDebugLeve l. */
	int XLALPrintWarning( const char *fmt, ... );		int XLALPrintWarning(const char *fmt, ...);
	/** Prints an info message if info printing is enabled by lalDebugLevel. */		/** Prints an info message if info printing is enabled by lalDebugLevel. */
	int XLALPrintInfo( const char *fmt, ... );		int XLALPrintInfo(const char *fmt, ...);
			#ifndef SWIG /* exclude from SWIG interface */
			/** Prints an error message if error printing is enabled by lalDebugLevel.
			*/
			int XLALVPrintError(const char *fmt, va_list ap);
			/** Prints a warning message if warning printing is enabled by lalDebugLeve
			l. */
			int XLALVPrintWarning(const char *fmt, va_list ap);
			/** Prints an info message if info printing is enabled by lalDebugLevel. */
			int XLALVPrintInfo(const char *fmt, va_list ap);
			#endif /* SWIG */
			/*
			*
			* Miscelaneous routines to print information with standard formatting.
			*
			*/
			/** Print an error message with standard XLAL formatting (if error messages
			* are enabled by lalDebugLevel). */
			void XLALPrintErrorMessage(const char *func, const char *file, int line, co
			nst char *fmt, ...);
			/** Print an warning message with standard XLAL formatting (if warning mess
			ages
			* are enabled by lalDebugLevel). */
			void XLALPrintWarningMessage(const char *func, const char *file, int line,
			const char *fmt, ...);
			/** Print an info message with standard XLAL formatting (if info messages
			* are enabled by lalDebugLevel). */
			void XLALPrintInfoMessage(const char *func, const char *file, int line, con
			st char *fmt, ...);
			#ifndef SWIG /* exclude from SWIG interface */
			/** Print an error message with standard XLAL formatting (if error messages
			* are enabled by lalDebugLevel). */
			void XLALVPrintErrorMessage(const char *func, const char *file, int line, c
			onst char *fmt, va_list ap);
			/** Print an warning message with standard XLAL formatting (if warning mess
			ages
			* are enabled by lalDebugLevel). */
			void XLALVPrintWarningMessage(const char *func, const char *file, int line,
			const char *fmt, va_list ap);
			/** Print an error message with standard XLAL formatting (if error messages
			* are enabled by lalDebugLevel). */
			void XLALVPrintInfoMessage(const char *func, const char *file, int line, co
			nst char *fmt, va_list ap);
			#endif /* SWIG */
	/** Prints a progress bar at the "info" verbosity level. */		/** Prints a progress bar at the "info" verbosity level. */
	int XLALPrintProgressBar( double );		int XLALPrintProgressBar(double);
	/** Prints a deprecation warning at the "warning" verbosity level. */		/** Prints a deprecation warning at the "warning" verbosity level. */
	int XLALPrintDeprecationWarning( const char *old, const char *replacement )		int XLALPrintDeprecationWarning(const char *old, const char *replacement);
	;
			/*
			*
			* Macros that will print error/warning/info messages with a standard forma
			t.
			*
			*/
			/** \def XLAL_PRINT_ERROR(fmt [, ...])
			* \brief Macro that will print an error message with a standard format.
			* \params fmt A printf-like format string.
			* \params ... (Optional) Arguments to the format string.
			*/
			#define XLAL_PRINT_ERROR(...) \
			XLALPrintErrorMessage(__func__, __FILE__, __LINE__, __VA_ARGS__)
			/** \def XLAL_PRINT_WARNING(fmt [, ...])
			* \brief Macro that will print a warning message with a standard format.
			* \params fmt A printf-like format string.
			* \params ... (Optional) Arguments to the format string.
			*/
			#define XLAL_PRINT_WARNING(...) \
			XLALPrintWarningMessage(__func__, __FILE__, __LINE__, __VA_ARGS__)
			/** \def XLAL_PRINT_INFO(fmt [, ...])
			* \brief Macro that will print an info message with a standard format.
			* \params fmt A printf-like format string.
			* \params ... (Optional) Arguments to the format string.
			*/
			#define XLAL_PRINT_INFO(...) \
			XLALPrintInfoMessage(__func__, __FILE__, __LINE__, __VA_ARGS__)
	/* silence gcc warnings about certain (possibly) unused symbols */		/* silence gcc warnings about certain (possibly) unused symbols */
	#ifdef __GNUC__		#ifdef __GNUC__
	#define UNUSED __attribute__ ((unused))		#define UNUSED __attribute__ ((unused))
	#else		#else
	#define UNUSED		#define UNUSED
	#endif		#endif
	/*		/*
	*		*
	* The LAL specification requires that XLAL functions that return a		* The LAL specification requires that XLAL functions that return a
	* floating-point type (either <tt>REAL4</tt> or <tt>REAL8</tt>) should ret		* floating-point type (either <tt>REAL4</tt> or <tt>REAL8</tt>) should ret
	urn a particular		urn
	* value to indicate an error. These values are given by the macros		* a particular value to indicate an error. These values are given by the
	* <tt>XLAL_REAL4_FAIL_NAN</tt> and <tt>XLAL_REAL8_FAIL_NAN</tt> (they are		* macros <tt>XLAL_REAL4_FAIL_NAN</tt> and <tt>XLAL_REAL8_FAIL_NAN</tt> (th
	Not a Number		ey
	* or NaN values). To implement these we choose hexadecimal representation		* are Not a Number or NaN values). To implement these we choose hexadecim
	s		al
	* and then provide static functions that return the equivalent <tt>REAL4</		* representations and then provide static functions that return the equiva
	tt> or		lent
	* <tt>REAL8</tt> values. The macros then invoke these functions. This is		* <tt>REAL4</tt> or <tt>REAL8</tt> values. The macros then invoke these
	done		* functions. This is done so that the compiler can easily inline the
	* so that the compiler can easily inline the functions (or eliminate them		* functions (or eliminate them if they are not used). Conversion from the
	* if they are not used). Conversion from the hexadecimal representation		* hexadecimal representation to the floating-point representation is done
	* to the floating-point representation is done using a union.		* using a union.
	*		*
	* The LAL specification also requires that there be two macros,		* The LAL specification also requires that there be two macros,
	* <tt>XLAL_IS_REAL4_FAIL_NAN(val)</tt> and <tt>XLAL_IS_REAL8_FAIL_NAN(val)		* <tt>XLAL_IS_REAL4_FAIL_NAN(val)</tt> and
	</tt> that will		* <tt>XLAL_IS_REAL8_FAIL_NAN(val)</tt> that will
	* test if val is one of these XLAL-specific fail NaNs. Again these macros		* test if val is one of these XLAL-specific fail NaNs. Again these macros
	* invoke static functions that return the result of the comparison. The		* invoke static functions that return the result of the comparison. The
	* cmparison itself is done with the hexadecimal representation.		* comparison itself is done with the hexadecimal representation.
	*		*
	*/		*/
	/* Hexadecimal representation of the <tt>REAL4</tt> and <tt>REAL8</tt> NaN		/* Hexadecimal representation of the <tt>REAL4</tt> and <tt>REAL8</tt> NaN
	failure bit pattern. */		* failure bit pattern. */
	#define XLAL_REAL4_FAIL_NAN_INT 0x7fc001a1 /**< Hexadecimal representation of <tt>REAL4</tt> NaN failure bit pattern */		#define XLAL_REAL4_FAIL_NAN_INT 0x7fc001a1 /**< Hexadecimal representation of <tt>REAL4</tt> NaN failure bit pattern */
	#define XLAL_REAL8_FAIL_NAN_INT LAL_INT8_C(0x7ff80000000001a1) /**< Hexadec imal representation of <tt>REAL8</tt> NaN failure bit pattern */		#define XLAL_REAL8_FAIL_NAN_INT LAL_INT8_C(0x7ff80000000001a1) /**< Hexadec imal representation of <tt>REAL8</tt> NaN failure bit pattern */
	/*		/*
	* The floating point values themselves are returned by static functions th at		* The floating point values themselves are returned by static functions th at
	* can be easily inlined by the compiler; similarly, the routines to test		* can be easily inlined by the compiler; similarly, the routines to test i
	* if a value is the LAL failure NaN can also be inlined.		f a
			* value is the LAL failure NaN can also be inlined.
	*/		*/
	/** Returns the value of the XLAL <tt>REAL4</tt> failure NaN. */		/** Returns the value of the XLAL <tt>REAL4</tt> failure NaN. */
	static REAL4 UNUSED XLALREAL4FailNaN( void )		static REAL4 UNUSED XLALREAL4FailNaN(void)
	{		{
	volatile const union { INT4 i; REAL4 x; } val = { XLAL_REAL4_FAIL_NAN_INT		volatile const union { INT4 i; REAL4 x; } val = { XLAL_REAL4_FAIL_NA
	} ;		N_INT } ;
	return val.x;		return val.x;
	}		}
	/** Returns the value of the XLAL <tt>REAL8</tt> failure NaN. */		/** Returns the value of the XLAL <tt>REAL8</tt> failure NaN. */
	static REAL8 UNUSED XLALREAL8FailNaN( void )		static REAL8 UNUSED XLALREAL8FailNaN(void)
	{		{
	volatile const union { INT8 i; REAL8 x; } val = { XLAL_REAL8_FAIL_NAN_INT		volatile const union { INT8 i; REAL8 x; } val = { XLAL_REAL8_FAIL_NA
	} ;		N_INT } ;
	return val.x;		return val.x;
	}		}
	/** Tests if a value is an XLAL <tt>REAL4</tt> failure NaN. */		/** Tests if a value is an XLAL <tt>REAL4</tt> failure NaN. */
	static int UNUSED XLALIsREAL4FailNaN( REAL4 val )		static int UNUSED XLALIsREAL4FailNaN(REAL4 val)
	{		{
	volatile const union { INT4 i; unsigned char s[4]; } a = { XLAL_REAL4_FAI		volatile const union { INT4 i; unsigned char s[4]; } a = { XLAL_REAL
	L_NAN_INT } ;		4_FAIL_NAN_INT } ;
	volatile union { REAL4 x; unsigned char s[4]; } b;		volatile union { REAL4 x; unsigned char s[4]; } b;
	size_t n;		size_t n;
	b.x = val;		b.x = val;
	for ( n = 0; n < sizeof( val ); ++n )		for (n = 0; n < sizeof(val); ++n)
	if ( a.s[n] != b.s[n] )		if (a.s[n] != b.s[n])
	return 0;		return 0;
	return 1;		return 1;
	}		}
	/** Tests if a value is an XLAL <tt>REAL8</tt> failure NaN. */		/** Tests if a value is an XLAL <tt>REAL8</tt> failure NaN. */
	static int UNUSED XLALIsREAL8FailNaN( REAL8 val )		static int UNUSED XLALIsREAL8FailNaN(REAL8 val)
	{		{
	volatile const union { INT8 i; unsigned char s[8]; } a = { XLAL_REAL8_FAI		volatile const union { INT8 i; unsigned char s[8]; } a = { XLAL_REAL
	L_NAN_INT } ;		8_FAIL_NAN_INT } ;
	volatile union { REAL8 x; unsigned char s[8]; } b;		volatile union { REAL8 x; unsigned char s[8]; } b;
	size_t n;		size_t n;
	b.x = val;		b.x = val;
	for ( n = 0; n < sizeof( val ); ++n )		for (n = 0; n < sizeof(val); ++n)
	if ( a.s[n] != b.s[n] )		if (a.s[n] != b.s[n])
	return 0;		return 0;
	return 1;		return 1;
	}		}
	#undef UNUSED		#undef UNUSED
	/* Here are the macro constants for the fail NaNs. */		/* Here are the macro constants for the fail NaNs. */
	#define XLAL_REAL4_FAIL_NAN ( XLALREAL4FailNaN() ) /**< Floating-point valu e of the XLAL <tt>REAL4</tt> failure NaN. */		#define XLAL_REAL4_FAIL_NAN ( XLALREAL4FailNaN() ) /**< Floating-point valu e of the XLAL <tt>REAL4</tt> failure NaN. */
	#define XLAL_REAL8_FAIL_NAN ( XLALREAL8FailNaN() ) /**< Floating-point valu e of the XLAL <tt>REAL8</tt> failure NaN. */		#define XLAL_REAL8_FAIL_NAN ( XLALREAL8FailNaN() ) /**< Floating-point valu e of the XLAL <tt>REAL8</tt> failure NaN. */
	/* Here are the macros to test for fail NaNs. */		/* Here are the macros to test for fail NaNs. */
	#define XLAL_IS_REAL4_FAIL_NAN(val) XLALIsREAL4FailNaN(val) /**< Tests if < tt>val</tt> is a XLAL <tt>REAL4</tt> failure NaN. */		#define XLAL_IS_REAL4_FAIL_NAN(val) XLALIsREAL4FailNaN(val) /**< Tests if < tt>val</tt> is a XLAL <tt>REAL4</tt> failure NaN. */
	#define XLAL_IS_REAL8_FAIL_NAN(val) XLALIsREAL8FailNaN(val) /**< Tests if < tt>val</tt> is a XLAL <tt>REAL8</tt> failure NaN. */		#define XLAL_IS_REAL8_FAIL_NAN(val) XLALIsREAL8FailNaN(val) /**< Tests if < tt>val</tt> is a XLAL <tt>REAL8</tt> failure NaN. */
	/** XLAL error numbers and return values. */		/** XLAL error numbers and return values. */
	enum XLALErrorValue {		enum XLALErrorValue {
	XLAL_SUCCESS = 0, /**< Success return value (not an error number) */		XLAL_SUCCESS = 0, /**< Success return value (not an error number) *
	XLAL_FAILURE = -1, /**< Failure return value (not an error number) */		/
			XLAL_FAILURE = -1, /**< Failure return value (not an error number) *
			/
	/* these are standard error numbers */		/* these are standard error numbers */
	XLAL_EIO = 5, /**< I/O error */		XLAL_EIO = 5, /**< I/O error */
	XLAL_ENOMEM = 12, /**< Memory allocation error */		XLAL_ENOMEM = 12, /**< Memory allocation error */
	XLAL_EFAULT = 14, /**< Invalid pointer */		XLAL_EFAULT = 14, /**< Invalid pointer */
	XLAL_EINVAL = 22, /**< Invalid argument */		XLAL_EINVAL = 22, /**< Invalid argument */
	XLAL_EDOM = 33, /**< Input domain error */		XLAL_EDOM = 33, /**< Input domain error */
	XLAL_ERANGE = 34, /**< Output range error */		XLAL_ERANGE = 34, /**< Output range error */
	/* extended error numbers start at 128 ... should be beyond normal errnos		/* extended error numbers start at 128 ...
	*/		* should be beyond normal errnos */
	/* these are common errors for XLAL functions */		/* these are common errors for XLAL functions */
	XLAL_EFAILED = 128, /**< Generic failure */		XLAL_EFAILED = 128, /**< Generic failure */
	XLAL_EBADLEN = 129, /**< Inconsistent or invalid length */		XLAL_EBADLEN = 129, /**< Inconsistent or invalid length */
	XLAL_ESIZE = 130, /**< Wrong size */		XLAL_ESIZE = 130, /**< Wrong size */
	XLAL_EDIMS = 131, /**< Wrong dimensions */		XLAL_EDIMS = 131, /**< Wrong dimensions */
	XLAL_ETYPE = 132, /**< Wrong or unknown type */		XLAL_ETYPE = 132, /**< Wrong or unknown type */
	XLAL_ETIME = 133, /**< Invalid time */		XLAL_ETIME = 133, /**< Invalid time */
	XLAL_EFREQ = 134, /**< Invalid freqency */		XLAL_EFREQ = 134, /**< Invalid freqency */
	XLAL_EUNIT = 135, /**< Invalid units */		XLAL_EUNIT = 135, /**< Invalid units */
	XLAL_ENAME = 136, /**< Wrong name */		XLAL_ENAME = 136, /**< Wrong name */
	XLAL_EDATA = 137, /**< Invalid data */		XLAL_EDATA = 137, /**< Invalid data */
	/* user-defined errors */		/* user-defined errors */
	XLAL_EUSR0 = 200, /**< User-defined error 0 */		XLAL_EUSR0 = 200, /**< User-defined error 0 */
	XLAL_EUSR1 = 201, /**< User-defined error 1 */		XLAL_EUSR1 = 201, /**< User-defined error 1 */
	XLAL_EUSR2 = 202, /**< User-defined error 2 */		XLAL_EUSR2 = 202, /**< User-defined error 2 */
	XLAL_EUSR3 = 203, /**< User-defined error 3 */		XLAL_EUSR3 = 203, /**< User-defined error 3 */
	XLAL_EUSR4 = 204, /**< User-defined error 4 */		XLAL_EUSR4 = 204, /**< User-defined error 4 */
	XLAL_EUSR5 = 205, /**< User-defined error 5 */		XLAL_EUSR5 = 205, /**< User-defined error 5 */
	XLAL_EUSR6 = 206, /**< User-defined error 6 */		XLAL_EUSR6 = 206, /**< User-defined error 6 */
	XLAL_EUSR7 = 207, /**< User-defined error 7 */		XLAL_EUSR7 = 207, /**< User-defined error 7 */
	XLAL_EUSR8 = 208, /**< User-defined error 8 */		XLAL_EUSR8 = 208, /**< User-defined error 8 */
	XLAL_EUSR9 = 209, /**< User-defined error 9 */		XLAL_EUSR9 = 209, /**< User-defined error 9 */
	/* external or internal errors */		/* external or internal errors */
	XLAL_ESYS = 254, /**< System error */		XLAL_ESYS = 254, /**< System error */
	XLAL_EERR = 255, /**< Internal error */		XLAL_EERR = 255, /**< Internal error */
	/* specific mathematical and numerical errors start at 256 */		/* specific mathematical and numerical errors start at 256 */
	/* IEEE floating point errors */		/* IEEE floating point errors */
	XLAL_EFPINVAL = 256, /**< IEEE Invalid floating point operation, eg sqrt		XLAL_EFPINVAL = 256, /**< IEEE Invalid floating point operation, eg
	(-1), 0/0 */		sqrt(-1), 0/0 */
	XLAL_EFPDIV0 = 257, /**< IEEE Division by zero floating point error */		XLAL_EFPDIV0 = 257, /**< IEEE Division by zero floating point erro
	XLAL_EFPOVRFLW = 258, /**< IEEE Floating point overflow error */		r */
	XLAL_EFPUNDFLW = 259, /**< IEEE Floating point underflow error */		XLAL_EFPOVRFLW = 258, /**< IEEE Floating point overflow error */
	XLAL_EFPINEXCT = 260, /**< IEEE Floating point inexact error */		XLAL_EFPUNDFLW = 259, /**< IEEE Floating point underflow error */
			XLAL_EFPINEXCT = 260, /**< IEEE Floating point inexact error */
	/* numerical algorithm errors */		/* numerical algorithm errors */
	XLAL_EMAXITER = 261, /**< Exceeded maximum number of iterations */		XLAL_EMAXITER = 261, /**< Exceeded maximum number of iterations */
	XLAL_EDIVERGE = 262, /**< Series is diverging */		XLAL_EDIVERGE = 262, /**< Series is diverging */
	XLAL_ESING = 263, /**< Apparent singularity detected */		XLAL_ESING = 263, /**< Apparent singularity detected */
	XLAL_ETOL = 264, /**< Failed to reach specified tolerance */		XLAL_ETOL = 264, /**< Failed to reach specified tolerance */
	XLAL_ELOSS = 265, /**< Loss of accuracy */		XLAL_ELOSS = 265, /**< Loss of accuracy */
	/* failure from within a function call: "or" error number with this */		/* failure from within a function call: "or" error number with this
	XLAL_EFUNC = 1024 /**< Internal function call failed bit: "or" this w		*/
	ith existing error number */		XLAL_EFUNC = 1024 /**< Internal function call failed bit: "or" t
			his with existing error number */
	};		};
	/*		/*
	*		*
	* These functions provide message associated with an error code and print		* These functions provide message associated with an error code and print
	* an error message associated with the error code. The macro XLAL_PERROR		* an error message associated with the error code. The macro XLAL_PERROR
	* fills in the current file and line information and uses the current		* fills in the current file and line information and uses the current
	* value of xlalErrno as the error number.		* value of xlalErrno as the error number.
	*		*
	*/		*/
	/** Returns the error message associated with an error number. */		/** Returns the error message associated with an error number. */
	const char * XLALErrorString( int errnum );		const char * XLALErrorString(int errnum);
	/** Prints an error message for a particular error code in a standard forma t. */		/** Prints an error message for a particular error code in a standard forma t. */
	void XLALPerror( const char *func, const char *file, int line, int errnum ) ;		void XLALPerror(const char *func, const char *file, int line, int errnum);
	/** Prints an error message for the current value of <tt>xlalErrno</tt>. */		/** Prints an error message for the current value of <tt>xlalErrno</tt>. */
	#define XLAL_PERROR( func ) XLALPerror( func, __FILE__, __LINE__, xlalErrno )		#define XLAL_PERROR( ) XLALPerror(__func__, __FILE__, __LINE__, xlalErrno)
	/*		/*
	*		*
	* Here is the XLAL error handler type and the routines that set it.		* Here is the XLAL error handler type and the routines that set it.
	* Also provide is the default error handler.		* Also provide is the default error handler.
	*		*
	*/		*/
			#ifndef SWIG /* exclude from SWIG interface */
	/** The XLAL error handler type. */		/** The XLAL error handler type. */
	typedef void XLALErrorHandlerType( const char *func, const char *file, int line, int errnum );		typedef void XLALErrorHandlerType(const char *func, const char *file, int l ine, int errnum);
	/** The default XLAL error handler. */		/** The default XLAL error handler. */
	void XLALDefaultErrorHandler( const char *func, const char *file, int line, int errnum );		void XLALDefaultErrorHandler(const char *func, const char *file, int line, int errnum);
	/** A silent XLAL error handler. */		/** A silent XLAL error handler. */
	void XLALSilentErrorHandler( const char *func, const char *file, int line, int errnum );		void XLALSilentErrorHandler(const char *func, const char *file, int line, i nt errnum);
	/* Other useful XLAL error handlers. */		/* Other useful XLAL error handlers. */
	/** The XLAL error handler that raises SIGABRT. */		/** The XLAL error handler that raises SIGABRT. */
	void XLALAbortErrorHandler( const char *func, const char *file, int line, i nt errnum );		void XLALAbortErrorHandler(const char *func, const char *file, int line, in t errnum);
	/** The XLAL error handler that calls exit. */		/** The XLAL error handler that calls exit. */
	void XLALExitErrorHandler( const char *func, const char *file, int line, in t errnum );		void XLALExitErrorHandler(const char *func, const char *file, int line, int errnum);
	/** The XLAL error handler that prints a function call backtrace then raise s SIGABRT. */		/** The XLAL error handler that prints a function call backtrace then raise s SIGABRT. */
	void XLALBacktraceErrorHandler( const char *func, const char *file, int lin		void XLALBacktraceErrorHandler(const char *func, const char *file, int line
	e, int errnum );		, int errnum);
			/** Function to return pointer to the XLAL error handler function pointer.
			*/
			XLALErrorHandlerType ** XLALGetErrorHandlerPtr( void );
	/** Sets the error handler to a new handler and returns the old handler. */		/** Sets the error handler to a new handler and returns the old handler. */
	XLALErrorHandlerType * XLALSetErrorHandler( XLALErrorHandlerType *newHandle r );		XLALErrorHandlerType * XLALSetErrorHandler(XLALErrorHandlerType *newHandler );
	/** Sets the error handler to the default handler and returns the old handl er. */		/** Sets the error handler to the default handler and returns the old handl er. */
	XLALErrorHandlerType * XLALSetDefaultErrorHandler( void );		XLALErrorHandlerType * XLALSetDefaultErrorHandler(void);
	/** Sets the error handler to a silent handler and returns the old handler. */		/** Sets the error handler to a silent handler and returns the old handler. */
	XLALErrorHandlerType * XLALSetSilentErrorHandler( void );		XLALErrorHandlerType * XLALSetSilentErrorHandler(void);
			#endif /* SWIG */
	/*		/*
	*		*
	* Here are the routines that set or clear the XLAL error number.		* Here are the routines that set or clear the XLAL error number.
	*		*
	*/		*/
	/** Sets the XLAL error number to errnum, returns the new value. */		/** Sets the XLAL error number to errnum, returns the new value. */
	int XLALSetErrno( int errnum );		int XLALSetErrno(int errnum);
	/** Gets the XLAL base error number ignoring the internal-function-failed f lag. */		/** Gets the XLAL base error number ignoring the internal-function-failed f lag. */
	int XLALGetBaseErrno( void );		int XLALGetBaseErrno(void);
	/** Clears the XLAL error number, returns the old value. */		/** Clears the XLAL error number, returns the old value. */
	int XLALClearErrno( void );		int XLALClearErrno(void);
	/*		/*
	*		*
	* The LAL specifiation requires that the XLAL error number be a modifiable		* The LAL specifiation requires that the XLAL error number be a modifiable
	* lvalue. Similarly, the function pointer to the XLAL error handler is		* lvalue. Similarly, the function pointer to the XLAL error handler is
	* a modifiable lvalue. These are implemented as macros that dereference		* a modifiable lvalue. These are implemented as macros that dereference
	* pointers to the current value (in the current thread). The pointer is		* pointers to the current value (in the current thread). The pointer is
	* returned by the functions XLALGetErrnoPtr and XLALGetErrorHandlerPtr.		* returned by the functions XLALGetErrnoPtr and XLALGetErrorHandlerPtr.
	* Here these functions and macros are defined.		* Here these functions and macros are defined.
	*		*
	*/		*/
	/** Function to return pointer to the XLAL error number. */		/** Function to return pointer to the XLAL error number. */
	int * XLALGetErrnoPtr( void );		int * XLALGetErrnoPtr(void);
	/** Function to return pointer to the XLAL error handler function pointer.
	*/
	XLALErrorHandlerType ** XLALGetErrorHandlerPtr( void );
	/* these are the modifiable lvalues for xlalErrno and XLALErrorHandler */		/* these are the modifiable lvalues for xlalErrno and XLALErrorHandler */
	#define xlalErrno ( * XLALGetErrnoPtr() ) /**< Modifiable lvalue containing the XLAL error number */		#define xlalErrno ( * XLALGetErrnoPtr() ) /**< Modifiable lvalue containing the XLAL error number */
	#define XLALErrorHandler ( * XLALGetErrorHandlerPtr() ) /**< Modifiable lva lue containing the XLAL error handler */		#define XLALErrorHandler ( * XLALGetErrorHandlerPtr() ) /**< Modifiable lva lue containing the XLAL error handler */
	/**		/**
	*		*
	* A macro to (i) disable the XLAL error handling and preserve the		* A macro to (i) disable the XLAL error handling and preserve the
	* current value of xlalErrno (ii) perform a statement that involves an		* current value of xlalErrno (ii) perform a statement that involves an
	* XLAL function call and (iii) restore the XLAL error handler and value of		* XLAL function call and (iii) restore the XLAL error handler and value of
	* xlalErrno while setting variable errnum to the xlalErrno set by the		* xlalErrno while setting variable errnum to the xlalErrno set by the
	* statement.		* statement.
	*		*
	*/		*/
	#define XLAL_TRY( statement, errnum ) \		#define XLAL_TRY( statement, errnum ) \
	do { \		do { \
	XLALErrorHandlerType *xlalSaveErrorHandler; \		XLALErrorHandlerType *xlalSaveErrorHandler; \
	int xlalSaveErrno; \		int xlalSaveErrno; \
	xlalSaveErrorHandler = XLALSetSilentErrorHandler(); \		xlalSaveErrorHandler = XLALSetSilentErrorHandler(); \
	xlalSaveErrno = xlalErrno; \		xlalSaveErrno = xlalErrno; \
	XLALClearErrno(); \		XLALClearErrno(); \
	statement ; \		statement ; \
	errnum = xlalErrno; \		errnum = xlalErrno; \
	xlalErrno = xlalSaveErrno; \		xlalErrno = xlalSaveErrno; \
	XLALSetErrorHandler( xlalSaveErrorHandler ); \		XLALSetErrorHandler(xlalSaveErrorHandler); \
	} while ( 0 )		} while (0)
	/*		/*
	*		*
	* Here are the routines and macros that are used to report errors when		* Here are the routines and macros that are used to report errors when
	* an XLAL function fails. They (i) set the XLAL error number and (ii)		* an XLAL function fails. They (i) set the XLAL error number and (ii)
	* invoke the XLAL error handler. The macros also (iii) return the		* invoke the XLAL error handler. The macros also (iii) return the
	* appropriate failure codes. The macros should be used to report all		* appropriate failure codes. The macros should be used to report all
	* failures.		* failures.
	*		*
	*/		*/
	/** Routine to set the XLAL error number and invoke the XLAL error handler.		/** Routine to set the XLAL error number and invoke the XLAL error handler.
	* It is used by the error macros. */		* It is used by the error macros. */
	void XLALError(		void XLALError(
	const char *func, /**< name of function where the error occurs */		const char *func, /**< name of function where the error occurs */
	const char *file, /**< source file name (use the __FILE__ macro) */		const char *file, /**< source file name (use the __FILE__ macro) */
	int line, /**< source line number (use the __LINE__ macro) */		int line, /**< source line number (use the __LINE__ macro) *
	int errnum /**< error code */		/
	);		int errnum /**< error code */
			);
	/** Macro to invoke the <tt>XLALError()</tt> function and return with code		/** \def XLAL_ERROR_VAL(val, errnum [, fmt [, ...]])
	val (it should not		* \brief Macro to invoke the <tt>XLALError()</tt> function and return
	* really be used itself, but forms the basis for other macros). */		* with code val (it should not really be used itself, but forms the basis
	#define XLAL_ERROR_VAL( func, errnum, val ) \		for
	do { \		* other macros).
	XLALError( func, __FILE__, __LINE__, errnum ); \		*
	return val; \		* \param val The value to return.
	} while (0)		* \param errnum The XLAL error number to set.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_ERROR_VAL(val, ...) XLAL_ERROR_VAL_(val, __VA_ARGS__, NULL, NU
			LL)
	/** Macro to invoke a failure from a XLAL routine returning an integer. */		/* Helper macro for internal use only */
	#define XLAL_ERROR( func, errnum ) \		#define XLAL_ERROR_VAL_(val, errnum, fmt, ...) \
	XLAL_ERROR_VAL( func, errnum, XLAL_FAILURE )		do { \
			if (fmt) XLAL_PRINT_ERROR(fmt, __VA_ARGS__); \
			XLALError(__func__, __FILE__, __LINE__, errnum); \
			return val; \
			} while (0)
	/** Macro to invoke a failure from a XLAL routine returning a pointer. */		/** \def XLAL_ERROR(errnum [, fmt [, ...]])
	#define XLAL_ERROR_NULL( func, errnum ) \		* \brief Macro to invoke a failure from a XLAL routine returning an intege
	XLAL_ERROR_VAL( func, errnum, NULL )		r.
			*
			* \param errnum The XLAL error number to set.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_ERROR(...) XLAL_ERROR_VAL(XLAL_FAILURE, __VA_ARGS__)
	/** Macro to invoke a failure from a XLAL routine returning void. */		/** \def XLAL_ERROR_NULL(errnum [, fmt [, ...]])
	#define XLAL_ERROR_VOID( func, errnum ) \		* \brief Macro to invoke a failure from a XLAL routine returning a pointer
	XLAL_ERROR_VAL( func, errnum, /* void */ )		.
			*
			* \param errnum The XLAL error number to set.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_ERROR_NULL(...) XLAL_ERROR_VAL(NULL, __VA_ARGS__)
	/** Macro to invoke a failure from a XLAL routine returning a <tt>REAL4</tt		/** \def XLAL_ERROR_VOID(errnum [, fmt [, ...]])
	> */		* \brief Macro to invoke a failure from a XLAL routine returning void.
	#define XLAL_ERROR_REAL4( func, errnum ) \		*
	XLAL_ERROR_VAL( func, errnum, XLAL_REAL4_FAIL_NAN )		* \param errnum The XLAL error number to set.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_ERROR_VOID(...) XLAL_ERROR_VAL(/* void */, __VA_ARGS__)
	/** Macro to invoke a failure from a XLAL routine returning a <tt>REAL8</tt		/** \def XLAL_ERROR_REAL4(errnum [, fmt [, ...]])
	> */		* \brief Macro to invoke a failure from a XLAL routine returning a
	#define XLAL_ERROR_REAL8( func, errnum ) \		* <tt>REAL4</tt>.
	XLAL_ERROR_VAL( func, errnum, XLAL_REAL8_FAIL_NAN )		*
			* \param errnum The XLAL error number to set.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_ERROR_REAL4(...) XLAL_ERROR_VAL(XLAL_REAL4_FAIL_NAN, __VA_ARGS
			__)
	#ifdef __cplusplus		/** \def XLAL_ERROR_REAL8(errnum [, fmt [, ...]])
	#pragma {		* \brief Macro to invoke a failure from a XLAL routine returning a
			* <tt>REAL8</tt>.
			*
			* \param errnum The XLAL error number to set.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_ERROR_REAL8(...) XLAL_ERROR_VAL(XLAL_REAL8_FAIL_NAN, __VA_ARGS
			__)
			/** \def XLAL_CHECK_VAL(val, assertion, errnum [, fmt [, ...]])
			* \brief Macro to test an assertion; if it is not true, invoke the
			* <tt>XLALError()</tt> function and return with code val (it should not re
			ally
			* be used itself, but forms the basis for other macros).
			*
			* \param val The value to return.
			* \param assertion The assertion to test.
			* \param errnum The XLAL error number to set if the assertion is false.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_CHECK_VAL(val, assertion, ...) \
			do { \
			if (!(assertion)) { \
			XLAL_PRINT_ERROR("Check ("#assertion") failed"); \
			XLAL_ERROR_VAL(val, __VA_ARGS__); \
			} \
			} while (0)
			/** \def XLAL_CHECK(assertion, errnum [, fmt [, ...]])
			* \brief Macro to test an assertion and invoke a failure if it is not true
			* in a function that returns an integer.
			*
			* \param assertion The assertion to test.
			* \param errnum The XLAL error number to set if the assertion is false.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_CHECK(assertion, ...) \
			XLAL_CHECK_VAL(XLAL_FAILURE, assertion, __VA_ARGS__)
			/** \def XLAL_CHECK_NULL(assertion, errnum [, fmt [, ...]])
			* \brief Macro to test an assertion and invoke a failure if it is not true
			* in a function that returns a pointer.
			*
			* \param assertion The assertion to test.
			* \param errnum The XLAL error number to set if the assertion is false.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_CHECK_NULL(assertion, ...) \
			XLAL_CHECK_VAL(NULL, assertion, __VA_ARGS__)
			/** \def XLAL_CHECK_VOID(assertion, errnum [, fmt [, ...]])
			* \brief Macro to test an assertion and invoke a failure if it is not true
			* in a function that returns void.
			*
			* \param assertion The assertion to test.
			* \param errnum The XLAL error number to set if the assertion is false.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_CHECK_VOID(assertion, ...) \
			XLAL_CHECK_VAL(/* void */, assertion, __VA_ARGS__)
			/** \def XLAL_CHECK_REAL4(assertion, errnum [, fmt [, ...]])
			* \brief Macro to test an assertion and invoke a failure if it is not true
			* in a function that returns a <tt>REAL4</tt>.
			*
			* \param assertion The assertion to test.
			* \param errnum The XLAL error number to set if the assertion is false.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_CHECK_REAL4(assertion, ...) \
			XLAL_CHECK_VAL(XLAL_REAL4_FAIL_NAN, assertion, __VA_ARGS__)
			/** \def XLAL_CHECK_REAL8(assertion, errnum [, fmt [, ...]])
			* \brief Macro to test an assertion and invoke a failure if it is not true
			* in a function that returns a <tt>REAL8</tt>.
			*
			* \param assertion The assertion to test.
			* \param errnum The XLAL error number to set if the assertion is false.
			* \param fmt (Optional) Format string for additional error information.
			* \param ... (Optional) Additional arguments for printf-like format.
			*/
			#define XLAL_CHECK_REAL8(assertion, ...) \
			XLAL_CHECK_VAL(XLAL_REAL4_FAIL_NAN, assertion, __VA_ARGS__)
			#if 0
			{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* XLALERROR_H */		#endif /* XLALERROR_H */
End of changes. 73 change blocks.
	247 lines changed or deleted		484 lines changed or added

	ZPGFilter.h		ZPGFilter.h
	skipping to change at line 84		skipping to change at line 84
	\verb@<datatype>ZPGFilter@ data types should document which complex		\verb@<datatype>ZPGFilter@ data types should document which complex
	variable is assumed.		variable is assumed.
	******************************************************* </lalLaTeX> */		******************************************************* </lalLaTeX> */
	#ifndef _ZPGFILTER_H		#ifndef _ZPGFILTER_H
	#define _ZPGFILTER_H		#define _ZPGFILTER_H
	#include <lal/LALStdlib.h>		#include <lal/LALStdlib.h>
	#ifdef __cplusplus		#if defined(__cplusplus)
	extern "C" {		extern "C" {
	#pragma }		#elif 0
			} /* so that editors will match preceding brace */
	#endif		#endif
	NRCSID(ZPGFILTERH,"$Id$");		NRCSID(ZPGFILTERH,"$Id$");
	/********************************************************** <lalLaTeX>		/********************************************************** <lalLaTeX>
	\subsection*{Error conditions}		\subsection*{Error conditions}
	****************************************** </lalLaTeX><lalErrTable> */		****************************************** </lalLaTeX><lalErrTable> */
	#define ZPGFILTERH_ENUL 1		#define ZPGFILTERH_ENUL 1
	#define ZPGFILTERH_EOUT 2		#define ZPGFILTERH_EOUT 2
	#define ZPGFILTERH_EMEM 3		#define ZPGFILTERH_EMEM 3
	skipping to change at line 160		skipping to change at line 161
	\newpage\input{BilinearTransformC}		\newpage\input{BilinearTransformC}
	</lalLaTeX> */		</lalLaTeX> */
	void		void
	LALWToZCOMPLEX8ZPGFilter( LALStatus *status,		LALWToZCOMPLEX8ZPGFilter( LALStatus *status,
	COMPLEX8ZPGFilter *filter );		COMPLEX8ZPGFilter *filter );
	void		void
	LALWToZCOMPLEX16ZPGFilter( LALStatus *status,		LALWToZCOMPLEX16ZPGFilter( LALStatus *status,
	COMPLEX16ZPGFilter *filter );		COMPLEX16ZPGFilter *filter );
	#ifdef __cplusplus		#if 0
	#pragma {		{ /* so that editors will match succeeding brace */
			#elif defined(__cplusplus)
	}		}
	#endif		#endif
	#endif /* _ZPGFILTER_H */		#endif /* _ZPGFILTER_H */
End of changes. 3 change blocks.
	4 lines changed or deleted		6 lines changed or added

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