AVFactories.h   AVFactories.h 
skipping to change at line 17 skipping to change at line 17
#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$");
/** /**
\defgroup AVFactories_h AVFactories_h \defgroup AVFactories_h AVFactories_h
\ingroup factories \ingroup factories
\brief Provides prototype and status code information for use of CreateVect or, \brief Provides prototype and status code information for use of CreateVect or,
CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/AVFactories.h> #include <lal/AVFactories.h>
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 Audio.h   Audio.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 * 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
*/ */
/* vim: set noet ts=4 sw=4: */ /* vim: set noet ts=4 sw=4: */
/** \file /** \file
* \ingroup std * \ingroup std
* \author Creighton, J. D. E. * \author Creighton, J. D. E.
* \date $Date$
* \brief Routines for exporting time series data as sound files. * \brief Routines for exporting time series data as sound files.
* *
* Supported formats are AU and WAVE. AIFF is not supported at this time. * Supported formats are AU and WAVE. AIFF is not supported at this time.
* *
* This code is based on code written by Paul Bourke. See: * This code is based on code written by Paul Bourke. See:
* http://local.wasp.uwa.edu.au/~pbourke/dataformats/au/ * http://local.wasp.uwa.edu.au/~pbourke/dataformats/au/
* http://local.wasp.uwa.edu.au/~pbourke/dataformats/wave/ * http://local.wasp.uwa.edu.au/~pbourke/dataformats/wave/
* *
*/ */
#ifndef AUDIO_H #ifndef AUDIO_H
#define AUDIO_H #define AUDIO_H
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
NRCSID( AUDIOH, "$Id$" );
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** 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 */
 End of changes. 2 change blocks. 
3 lines changed or deleted 0 lines changed or added


 BandPassTimeSeries.h   BandPassTimeSeries.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="BandPassTimeSeriesHV">
Author: Creighton, T. D.
$Id$
**************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX>
\section{Header \texttt{BandPassTimeSeries.h}}
\label{s:BandPassTimeSeries.h}
Provides routines to low- or high-pass filter a time series.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/BandPassTimeSeries.h>
\end{verbatim}
\noindent This header covers routines that apply a time-domain low- or
high-pass filter to a data series of type \verb@<datatype>TimeSeries@.
Further documentation is given in the individual routines' modules.
******************************************************* </lalLaTeX> */
#ifndef _BANDPASSTIMESERIES_H #ifndef _BANDPASSTIMESERIES_H
#define _BANDPASSTIMESERIES_H #define _BANDPASSTIMESERIES_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
#include <lal/ZPGFilter.h> #include <lal/ZPGFilter.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
NRCSID(BANDPASSTIMESERIESH,"$Id$"); /**
\author Creighton, T. D.
/********************************************************** <lalLaTeX> \addtogroup BandPassTimeSeries_h
\subsection*{Error conditions}
****************************************** </lalLaTeX><lalErrTable> */
#define BANDPASSTIMESERIESH_ENUL 1
#define BANDPASSTIMESERIESH_EBAD 2
#define BANDPASSTIMESERIESH_MSGENUL "Unexpected null pointer in arguments"
#define BANDPASSTIMESERIESH_MSGEBAD "Bad filter parameters"
/******************************************** </lalErrTable><lalLaTeX>
\subsection*{Types}
\subsubsection*{Structure \texttt{PassBandParamStruc}}
\idx[Type]{PassBandParamStruc}
This structure stores data used for constructing a low- or high-pass \brief Provides routines to low- or high-pass filter a time series.
filter: either the order and characteristic frequency of the filter,
or the frequencies and desired attenuations at the ends of some
transition band. In the latter case, a nonzero filter order parameter
\verb@n@ indicates a maximum allowed order. The fields are:
\begin{description} \heading{Synopsis}
\item[\texttt{CHAR *name}] A user-assigned name. \code
#include <lal/BandPassTimeSeries.h>
\endcode
\item[\texttt{INT4 n}] The maximum desired filter order (actual order This header covers routines that apply a time-domain low- or
may be less if specified attenuations do not require a high order). high-pass filter to a data series of type <tt>\<datatype\>TimeSeries</tt>.
Further documentation is given in the individual routines' modules.
\item[\texttt{REAL8 f1}, \texttt{f2}] The reference frequencies of the */
transition band. /*@{*/
\item[\texttt{REAL8 a1}, \texttt{a2}] The minimal desired attenuation /** \name Error Codes */
factors at the reference frequencies. /*@{*/
\end{description} #define BANDPASSTIMESERIESH_ENUL 1 /**< Unexpected null pointer in argu
ments */
#define BANDPASSTIMESERIESH_EBAD 2 /**< Bad filter parameters */
/*@}*/
******************************************************* </lalLaTeX> */ /** \cond DONT_DOXYGEN */
#define BANDPASSTIMESERIESH_MSGENUL "Unexpected null pointer in arguments"
#define BANDPASSTIMESERIESH_MSGEBAD "Bad filter parameters"
/** \endcond */
/** This structure stores data used for constructing a low- or high-pass
* filter: either the order and characteristic frequency of the filter,
* or the frequencies and desired attenuations at the ends of some
* transition band. In the latter case, a nonzero filter order parameter
* \c n indicates a maximum allowed order
*/
typedef struct tagPassBandParamStruc{ typedef struct tagPassBandParamStruc{
SWIGLAL_STRUCT(PassBandParamStruc); SWIGLAL_STRUCT(PassBandParamStruc);
CHAR *name; CHAR *name; /**< A user-assigned name */
INT4 nMax; INT4 nMax; /**< The maximum desired filter order (actual order may be l
REAL8 f1; ess if specified attenuations do not require a high order) */
REAL8 f2; REAL8 f1; /**< The reference frequencies of the transition band */
REAL8 a1; REAL8 f2; /**< The reference frequencies of the transition band */
REAL8 a2; REAL8 a1; /**< The minimal desired attenuation factors at the referenc
e frequencies */
REAL8 a2; /**< The minimal desired attenuation factors at the referenc
e frequencies */
} PassBandParamStruc; } PassBandParamStruc;
/* <lalLaTeX> /*@}*/
\vfill{\footnotesize\input{BandPassTimeSeriesHV}}
</lalLaTeX> */
/* Function prototypes. */ /* Function prototypes. */
/* <lalLaTeX>
\newpage\input{ButterworthTimeSeriesC}
</lalLaTeX> */
int XLALButterworthREAL4TimeSeries( REAL4TimeSeries *series, PassBandParamS truc *params ); int XLALButterworthREAL4TimeSeries( REAL4TimeSeries *series, PassBandParamS truc *params );
int XLALButterworthREAL8TimeSeries( REAL8TimeSeries *series, PassBandParamS truc *params ); int XLALButterworthREAL8TimeSeries( REAL8TimeSeries *series, PassBandParamS truc *params );
int XLALLowPassREAL4TimeSeries( REAL4TimeSeries *series, int XLALLowPassREAL4TimeSeries( REAL4TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder ); REAL8 frequency, REAL8 amplitude, INT4 filtorder );
int XLALLowPassREAL8TimeSeries( REAL8TimeSeries *series, int XLALLowPassREAL8TimeSeries( REAL8TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder ); REAL8 frequency, REAL8 amplitude, INT4 filtorder );
int XLALHighPassREAL4TimeSeries( REAL4TimeSeries *series, int XLALHighPassREAL4TimeSeries( REAL4TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder ); REAL8 frequency, REAL8 amplitude, INT4 filtorder );
int XLALHighPassREAL8TimeSeries( REAL8TimeSeries *series, int XLALHighPassREAL8TimeSeries( REAL8TimeSeries *series,
REAL8 frequency, REAL8 amplitude, INT4 filtorder ); REAL8 frequency, REAL8 amplitude, INT4 filtorder );
skipping to change at line 148 skipping to change at line 115
PassBandParamStruc *params ); PassBandParamStruc *params );
void void
LALDButterworthREAL4TimeSeries( LALStatus *status, LALDButterworthREAL4TimeSeries( LALStatus *status,
REAL4TimeSeries *series, REAL4TimeSeries *series,
PassBandParamStruc *params ); PassBandParamStruc *params );
/* 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. */
/* <lalLaTeX>
\newpage\input{BandPassTestC}
</lalLaTeX> */
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _BANDPASSTIMESERIES_H */ #endif /* _BANDPASSTIMESERIES_H */
 End of changes. 13 change blocks. 
74 lines changed or deleted 39 lines changed or added


 BitField.h   BitField.h 
skipping to change at line 31 skipping to change at line 31
* \author Karl Wette * \author Karl Wette
* \file * \file
* \brief Macros for manipulating integers as bit fields * \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$");
/** /**
* Return a mask where the (zero-based) ith bit is set * Return a mask where the (zero-based) ith bit is set
*/ */
#define ONE_BIT(T, i) (((T)1) << (i)) #define ONE_BIT(T, i) (((T)1) << (i))
/** /**
* Return a mask where all bits from 0 to n-1 are set * Return a mask where all bits from 0 to n-1 are set
*/ */
#define ALL_BITS(T, n) ((((T)1) << (n)) - ((T)1)) #define ALL_BITS(T, n) ((((T)1) << (n)) - ((T)1))
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 Calibration.h   Calibration.h 
skipping to change at line 31 skipping to change at line 31
#define _CALIBRATION_H #define _CALIBRATION_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/BandPassTimeSeries.h> #include <lal/BandPassTimeSeries.h>
NRCSID (CALIBRATIONH,"$Id$");
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
/** /**
* \author P. R. Brady, J. D. E. Creighton * \author P. R. Brady, J. D. E. Creighton
* \addtogroup Calibration_h * \addtogroup Calibration_h
* *
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 CoarseGrainFrequencySeries.h   CoarseGrainFrequencySeries.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="CoarseGrainFrequencySeriesHV">
Author: UTB Relativity Group; contact whelan@phys.utb.edu (original by S. D
rasco)
$Id$
*********************************************************** </lalVerbatim>
*/
/********************************************************** <lalLaTeX>
\section{Header \texttt{CoarseGrainFrequencySeries.h}}
\label{utilities:s:CoarseGrainFrequencySeries.h}
Provides prototype, structure and error code information for routines
which coarse-grain a frequency series.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/CoarseGrainFrequencySeries.h>
\end{verbatim}
\noindent
\subsection*{Error conditions}
\input{CoarseGrainFrequencySeriesHE}
\subsection*{Structures}
*********************************************************** </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 */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( COARSEGRAINFREQUENCYSERIESH, /**
"$Id$" ); \addtogroup CoarseGrainFrequencySeries_h
\author UTB Relativity Group; contact whelan@phys.utb.edu (original by S
. Drasco)
/****************** <lalErrTable file="CoarseGrainFrequencySeriesHE"> */ \brief Provides prototype, structure and error code information for rout ines which coarse-grain a frequency series.
#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1 \heading{Synopsis}
#define COARSEGRAINFREQUENCYSERIESH_ESAMEPTR 2 \code
#define COARSEGRAINFREQUENCYSERIESH_EZEROLEN 3 #include <lal/CoarseGrainFrequencySeries.h>
#define COARSEGRAINFREQUENCYSERIESH_ENONPOSDELTAF 4 \endcode
#define COARSEGRAINFREQUENCYSERIESH_ENEGFMIN 5
#define COARSEGRAINFREQUENCYSERIESH_EMMHETERO 7 \heading{Description}
#define COARSEGRAINFREQUENCYSERIESH_EMMFMIN 8
#define COARSEGRAINFREQUENCYSERIESH_EMMDELTAF 9
#define COARSEGRAINFREQUENCYSERIESH_EMMLEN 10
#define COARSEGRAINFREQUENCYSERIESH_EOORCOARSE 16
These functions are designed to facilitate approximation of integrals
such as
\f[
\int g(f)\,h(f)\,df
\f]
when \f$g(f)\f$ and \f$h(f)\f$ are sampled with different frequency
resolutions. If the frequency resolution were the same for both
functions, e.g., a frequency spacing of \f$\delta f\f$ and a start
frequency of \f$f_0\f$, so that the \f$k\f$th element corresponded to a
frequency \f$f_k = f_0 + k\delta f\f$, the approximation would be defined
as
\f[
\int g(f)\,h(f)\,df \approx \delta f \sum_k g_k h_k
\f]
whose contribution from the \f$k\f$th element is [It is
important to make the limits of integration symmetric about \f$f_k\f$ to
maintain reality conditions when dealing with Fourier transforms of
real quantities.]
\f[
\int_{f_k-\delta f/2}^{f_k+\delta f/2} g(f)\,h(f)\,df \approx
\delta f g_k h_k
\ .
\f]
The central idea in our definitions of coarse graining will thus be
the correspondence
\anchor utilities_e_coarse \f{equation}{
\label{utilities_e_coarse}
h_k \approx \frac{1}{\delta f}
\int_{f_k-\delta f/2}^{f_k+\delta f/2} h(f)\,df
\f}
The purpose of this function is to obtain a frequency series \f$\{h_k\}\f$
with start frequency \f$f_0\f$ and frequency spacing \f$\delta f\f$ from a
finer-grained frequency series \f$\{h'_\ell\}\f$ with start frequency
\f$f'_0\f$ and frequency spacing \f$\delta f'\f$. Focussing on the \f$k\f$
th
element of the coarse-grained series, which represents a frequency
range from \f$f_k-\delta f/2\f$ to \f$f_k+\delta f/2\f$, we consider the
elements of the fine-grained series whose frequency ranges overlap
with this. (Fig.\figref{utilities_f_coarse}
\floatfig{htbp,utilities_f_coarse}
\image html utilitiesCoarseGrain.png "Fig. [utilities_f_coarse]: Coarse gr
aining a frequency series"
\image latex utilitiesCoarseGrain.pdf "Coarse graining a frequency series"
We define \f$\ell^{\scriptstyle\textrm{min}}_k\f$ and \f$\ell^{\scriptstyle
{\rm min}}_k\f$
to be the indices of the first and last elements of
\f$h'_\ell\f$ which overlap \e completely with the frequency range
corresponding to \f$h_k\f$. These are most easily defined in terms of
non-integer indices \f$\lambda^{\scriptstyle\textrm{min}}_k\f$ and
\f$\lambda^{\scriptstyle\textrm{max}}_k\f$ which correspond to the location
s
of fine-grained elements which would exactly reach the edges of the
coarse-grained element with index \f$k\f$. These are defined by
\f{eqnarray*}{
f_0 + \left(k-\frac{1}{2}\right) \delta f
&=& f'_0 + \left(\lambda^{\scriptstyle\textrm{min}}_k-\frac{1}{2}\right)
\delta f' \\
f_0 + \left(k+\frac{1}{2}\right) \delta f
&=& f'_0 + \left(\lambda^{\scriptstyle\textrm{max}}_k+\frac{1}{2}\right)
\delta f'
\f}
or, defining the offset \f$\Omega=(f_0-f'_0)/\delta f'\f$ and the coarse
graining ratio \f$\rho = \delta f / \delta f'\f$,
\f{eqnarray*}{
\lambda^{\scriptstyle\textrm{min}}_k &=&
\Omega + \left(k-\frac{1}{2}\right) \rho + \frac{1}{2}\\
\lambda^{\scriptstyle\textrm{max}}_k &=&
\Omega + \left(k+\frac{1}{2}\right) \rho - \frac{1}{2}
\ .
\f}
Examination of Fig.\figref{utilities_f_coarse} shows that
\f$\ell^{\scriptstyle\textrm{min}}_k\f$ is the smallest integer not less th
an
\f$\lambda^{\scriptstyle\textrm{min}}_k\f$ and \f$\ell^{\scriptstyle{\rm
min}}_k\f$ is the largest integer not greater than
\f$\lambda^{\scriptstyle\textrm{min}}_k\f$.
With these definitions, approximating the integral in
\eqref{utilities_e_coarse} gives
\anchor utilities_e_coarseapprox \f{equation}{\label{utilities_e_coarseappr
ox}
h_k = \frac{1}{\rho}
\left(
(\ell^{\scriptstyle\textrm{min}}_k - \lambda^{\scriptstyle\textrm{min}}_k
)
h'_{\ell^{\scriptscriptstyle\textrm{min}}_k-1}
+ \sum_{\ell=\ell^{\scriptscriptstyle\textrm{min}}_k}
^{\ell^{\scriptscriptstyle\textrm{max}}_k}
h'_\ell
+ (\lambda^{\scriptstyle\textrm{max}}_k - \ell^{\scriptstyle\textrm{max}}
_k)
h'_{\ell^{\scriptscriptstyle\textrm{max}}_k+1}
\right)
\f}
In the special case \f$f_0=f'_0\f$, we assume both frequency series
represent the independent parts of larger frequency series
\f$\{h_k|k=-(N-1)\ldots(N-1)\}\f$ and \f$\{h'_\ell|\ell=-(N-1)\ldots(N-1)\}
\f$
which obey \f$h_{-k}=h_k^*\f$ and \f$h'_{-\ell}{}=h'_\ell{}^*\f$ (e.g.,
fourier transforms of real data). In that case, the DC element of the
coarse-grained series can be built out of both positive- and implied
negative-frequency elements in the fine-grained series.
\f{equation}{
h_0 = \frac{1}{\rho}
\left[
h'_0
+ 2\ \mathrm{Re}
\left(
\sum_{\ell=1}^{\ell^{\scriptscriptstyle\textrm{max}}_0}
h'_\ell
+ (\lambda^{\scriptstyle\textrm{max}}_0 - \ell^{\scriptstyle\textrm{m
ax}}_0)
h'_{\ell^{\scriptscriptstyle\textrm{max}}_0+1}
\right)
\right]
\f}
\heading{Algorithm}
These routines move through the output series, using
\eqref{utilities_e_coarseapprox} to add up the contributions from the
bins in the fine-grained series.
\heading{Notes}
<ul>
<li> The coarse graining ratio must obey \f$\rho\ge 1\f$ (so the
coarse-grained frequency spacing must be less than the fine-grained
one). Additionally, the bins in the fine-grained frequency series
must \e completely overlap those in the coarse-grained frequency
series. In particular, since the lowest frequency in the first bin
of the coarse-grained series is \f$f_{\scriptstyle{\rm min}}=f_0-\delta f
/2\f$
and the last is \f$f_{\scriptstyle{\rm max}}=f_0 + (N-1) \delta f +\delta
f/2\f$
(taking into account the width of the bins), the conitions are
\f{eqnarray*}{
f_0 - \frac{\delta f}{2} &\ge& f'_0 - \frac{\delta f'}{2}\\
f_0 + \left(N-\frac{1}{2}\right)\,\delta f &\le&
f'_0 + \left(N'-\frac{1}{2}\right)\,\delta f'
\f}
(The special case \f$f_0=f'_0=0\f$ is an
exception to the condition on the minimum frequency.)</li>
<li> The routines return an error if either minimum frequency
(\f$f_{\scriptstyle\textrm{min}}\f$ or \f$f'_{\scriptstyle\textrm{min}}\f
$) is
negative (unless \f$f_0=0\f$ or \f$f'_0=0\f$, respectively).</li>
</ul>
*/
/*@{*/
/**\name Error Codes */ /*@{*/
#define COARSEGRAINFREQUENCYSERIESH_ENULLPTR 1 /**< Null po
inter */
#define COARSEGRAINFREQUENCYSERIESH_ESAMEPTR 2 /**< Input a
nd Output pointers the same */
#define COARSEGRAINFREQUENCYSERIESH_EZEROLEN 3 /**< Zero le
ngth for data member of series */
#define COARSEGRAINFREQUENCYSERIESH_ENONPOSDELTAF 4 /**< Negativ
e or zero frequency spacing */
#define COARSEGRAINFREQUENCYSERIESH_ENEGFMIN 5 /**< Negativ
e start frequency */
#define COARSEGRAINFREQUENCYSERIESH_EMMHETERO 7 /**< Mismatc
h in heterodyning frequencies */
#define COARSEGRAINFREQUENCYSERIESH_EMMFMIN 8 /**< Mismatc
h in start frequencies */
#define COARSEGRAINFREQUENCYSERIESH_EMMDELTAF 9 /**< Mismatc
h in frequency spacings */
#define COARSEGRAINFREQUENCYSERIESH_EMMLEN 10 /**< Mismatc
h in sequence lengths */
#define COARSEGRAINFREQUENCYSERIESH_EOORCOARSE 16 /**< Coarse-
graining paramaters out of range */
/*@}*/
/** \cond DONT_DOXYGEN */
#define COARSEGRAINFREQUENCYSERIESH_MSGENULLPTR "Null pointer" #define COARSEGRAINFREQUENCYSERIESH_MSGENULLPTR "Null pointer"
#define COARSEGRAINFREQUENCYSERIESH_MSGESAMEPTR "Input and Output pointe rs the same" #define COARSEGRAINFREQUENCYSERIESH_MSGESAMEPTR "Input and Output pointe rs the same"
#define COARSEGRAINFREQUENCYSERIESH_MSGEZEROLEN "Zero length for data me mber of series" #define COARSEGRAINFREQUENCYSERIESH_MSGEZEROLEN "Zero length for data me mber of series"
#define COARSEGRAINFREQUENCYSERIESH_MSGENONPOSDELTAF "Negative or zero freq uency spacing" #define COARSEGRAINFREQUENCYSERIESH_MSGENONPOSDELTAF "Negative or zero freq uency spacing"
#define COARSEGRAINFREQUENCYSERIESH_MSGENEGFMIN "Negative start frequency" #define COARSEGRAINFREQUENCYSERIESH_MSGENEGFMIN "Negative start frequency"
#define COARSEGRAINFREQUENCYSERIESH_MSGEMMHETERO "Mismatch in heterodynin g frequencies" #define COARSEGRAINFREQUENCYSERIESH_MSGEMMHETERO "Mismatch in heterodynin g frequencies"
#define COARSEGRAINFREQUENCYSERIESH_MSGEMMFMIN "Mismatch in start frequ encies" #define COARSEGRAINFREQUENCYSERIESH_MSGEMMFMIN "Mismatch in start frequ encies"
#define COARSEGRAINFREQUENCYSERIESH_MSGEMMDELTAF "Mismatch in frequency s pacings" #define COARSEGRAINFREQUENCYSERIESH_MSGEMMDELTAF "Mismatch in frequency s pacings"
#define COARSEGRAINFREQUENCYSERIESH_MSGEMMLEN "Mismatch in sequence le ngths" #define COARSEGRAINFREQUENCYSERIESH_MSGEMMLEN "Mismatch in sequence le ngths"
#define COARSEGRAINFREQUENCYSERIESH_MSGEOORCOARSE "Coarse-graining paramat ers out of range" #define COARSEGRAINFREQUENCYSERIESH_MSGEOORCOARSE "Coarse-graining paramat ers out of range"
/** \endcond */
/************************************ </lalErrTable> */ /* ***********************************************************
/*************************************************************
* * * *
* Structures and prototypes associated with * * Structures and prototypes associated with *
* CoarseGrainFrequencySeries.c * * CoarseGrainFrequencySeries.c *
* * * *
*************************************************************/ *************************************************************/
/********************************************************** <lalLaTeX> /** Contains the parameters needed to specify the sampling of a frequency s
eries */
\subsubsection*{\texttt{struct FrequencySamplingParams}}
\idx[Type]{FrequencySamplingParams}
\noindent
Contains the parameters needed to specify the sampling of a
frequency series:
\begin{description}
\item[\texttt{UINT4 length}]
The number of points in the frequency series.
\item[\texttt{REAL8 f0}]
The start frequency of the frequency series.
\item[\texttt{REAL8 deltaF}]
The frequency spacing of the frequency series.
\end{description}
*********************************************************** </lalLaTeX> */
typedef struct typedef struct
tagFrequencySamplingParams tagFrequencySamplingParams
{ {
SWIGLAL_STRUCT(FrequencySamplingParams); SWIGLAL_STRUCT(FrequencySamplingParams);
REAL8 f0; REAL8 f0; /**< The start frequency of the frequency se
REAL8 deltaF; ries */
UINT4 length; REAL8 deltaF; /**< The frequency spacing of the fr
equency series */
UINT4 length; /**< The number of points in the fre
quency series */
} }
FrequencySamplingParams; FrequencySamplingParams;
/** \see See \ref CoarseGrainFrequencySeries_h for documetation */
void void
LALSCoarseGrainFrequencySeries(LALStatus *status, LALSCoarseGrainFrequencySeries(LALStatus *status,
REAL4FrequencySeries *output, REAL4FrequencySeries *output,
const REAL4FrequencySeries *input, const REAL4FrequencySeries *input,
const FrequencySamplingParams *params); const FrequencySamplingParams *params);
/** \see See \ref CoarseGrainFrequencySeries_h for documetation */
void void
LALDCoarseGrainFrequencySeries(LALStatus *status, LALDCoarseGrainFrequencySeries(LALStatus *status,
REAL8FrequencySeries *output, REAL8FrequencySeries *output,
const REAL8FrequencySeries *input, const REAL8FrequencySeries *input,
const FrequencySamplingParams *params); const FrequencySamplingParams *params);
/** \see See \ref CoarseGrainFrequencySeries_h for documetation */
void void
LALCCoarseGrainFrequencySeries(LALStatus *status, LALCCoarseGrainFrequencySeries(LALStatus *status,
COMPLEX8FrequencySeries *output, COMPLEX8FrequencySeries *output,
const COMPLEX8FrequencySeries *input, const COMPLEX8FrequencySeries *input,
const FrequencySamplingParams *params); const FrequencySamplingParams *params);
/** \see See \ref CoarseGrainFrequencySeries_h for documetation */
void void
LALZCoarseGrainFrequencySeries(LALStatus *status, LALZCoarseGrainFrequencySeries(LALStatus *status,
COMPLEX16FrequencySeries *output, COMPLEX16FrequencySeries *output,
const COMPLEX16FrequencySeries *input, const COMPLEX16FrequencySeries *input,
const FrequencySamplingParams *params); const FrequencySamplingParams *params);
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection */ #endif /* C++ protection */
/********************************************************** <lalLaTeX>
\vfill{\footnotesize\input{CoarseGrainFrequencySeriesHV}}
\newpage\input{CoarseGrainFrequencySeriesC}
\newpage\input{SCoarseGrainFrequencySeriesTestC}
\newpage\input{DCoarseGrainFrequencySeriesTestC}
\newpage\input{CCoarseGrainFrequencySeriesTestC}
\newpage\input{ZCoarseGrainFrequencySeriesTestC}
*********************************************************** </lalLaTeX> */
#endif /* _COARSEGRAINFREQUENCYSERIES_H */ #endif /* _COARSEGRAINFREQUENCYSERIES_H */
 End of changes. 15 change blocks. 
81 lines changed or deleted 206 lines changed or added


 CoherentEstimation.h   CoherentEstimation.h 
skipping to change at line 39 skipping to change at line 39
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/IIRFilter.h> #include <lal/IIRFilter.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
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
#define COHERENTESTIMATIONH_EUIMP 7 #define COHERENTESTIMATIONH_EUIMP 7
#define COHERENTESTIMATIONH_MSGEMEM "Memory allocation error" #define COHERENTESTIMATIONH_MSGEMEM "Memory allocation error"
#define COHERENTESTIMATIONH_MSGENULL "NULL pointer" #define COHERENTESTIMATIONH_MSGENULL "NULL pointer"
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 ComplexFFT.h   ComplexFFT.h 
skipping to change at line 41 skipping to change at line 41
#ifdef __cplusplus #ifdef __cplusplus
#ifdef __GNUC__ #ifdef __GNUC__
#define RESTRICT __restrict__ #define RESTRICT __restrict__
#else #else
#define RESTRICT #define RESTRICT
#endif #endif
#else #else
#define RESTRICT restrict #define RESTRICT restrict
#endif #endif
NRCSID( COMPLEXFFTH, "$Id$" );
/** /**
* \addtogroup ComplexFFT_h * \addtogroup ComplexFFT_h
* *
* \brief Performs complex-to-complex FFTs. * \brief Performs complex-to-complex FFTs.
* *
* \heading{Synopsis} * \heading{Synopsis}
* \code * \code
* #include <lal/ComplexFFT.h> * #include <lal/ComplexFFT.h>
* \endcode * \endcode
* *
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 ComputeDataQualityVector.h   ComputeDataQualityVector.h 
skipping to change at line 26 skipping to change at line 26
* 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 _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$");
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
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,
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 ConfigFile.h   ConfigFile.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 ConfigFile Config-File reading module
* \ingroup support
* \author Reinhard Prix
* \date $Date$
* \brief Module for general parsing of simple ASCII-based config-files.
*
*/
/** \file
* \ingroup ConfigFile
* \author Reinhard Prix
* \date $Date$
* \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 */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#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$"); /** \addtogroup ConfigFile_h
* \author Reinhard Prix
* \brief Module for general parsing of simple ASCII-based config-files.
\heading{Description}
This module provides routines for reading formatted
config-files containing definitions of the form <tt>variable = value</tt>.
The general syntax is somewhat similar to the one provided by the
perl-module <tt>ConfigParser</tt> (cf.
http://www.python.org/doc/current/lib/module-ConfigParser.html)
Comments are allowed using either '<tt>\#</tt>', '<tt>;</tt>' or <tt>\%</tt
>.
You can also use line-continuation using a '<tt>\\</tt>' at the end of the
line.
Also note that comment-signs '<tt>\#;\%</tt>' within double-quotes &quot;..
.&quot;
are <em>not</em> treated as comment-characters. The general syntax is best
illustrated
using a simple example:
\code
# comment line
var1 = 1.0 ; you can also comment using semi-colons
somevar = some text.\
You can also use\
line-continuation
var3 = 4 # whatever that means
note = "this is also possible, and # here does nothing"
a_switch = true #possible values: 0,1,true,false,yes,no, case insensitive
...
\endcode
Note that TABS generally get replaced by a single space, which can be
useful in the case of line-continuation (see example). All leading and
trailing spaces in are ignore (except within double-quotes).
The general approach of reading from such a config-file, is to first
call XLALParseDataFile() which loads and pre-parses the contents of the
config-file into the structure LALParsedDataFile. Then one can read in
config-variables either using one of the type-strict custom-wrappers
<tt>XLALReadConfig<TYPE>Variable()</tt> or the general-purpose reading func
tion
XLALReadConfigVariable().
A boolean variable read by XLALReadConfigBOOLVariable() can have any of the
values
<tt>{1, 0, yes, no, true, false}</tt>, where the comparison is done
<em>case-insensitively</em>, i.e. you can also use 'True' or 'FALSE'....
If one wishes a tight sytnax for the config-file, one can check
that there are no illegal entries in the config-file. This is done
by checking at the end that all config-file entries have been
successfully parsed, using:
XLALCheckConfigReadComplete(), where \a strictness is either
CONFIGFILE_WARN or CONFIGFILE_ERROR.
In the first case only a warning is issued, while in the second it is
treated as a LAL-error if some config-file entries have not been
read-in. (The use of this function is optional).
The configfile-data should be freed at the end using
XLALDestroyParsedDataFile().
\par Notes
XLALReadConfigSTRINGVariable() and XLALReadConfigSTRINGVariable() are not
the same as using <tt>%quot;\%s&quot;</tt> as a format string, as they read
the
<em>rest</em> of the logical line (excluding comments) as a string.
In the case of XLALReadConfigSTRINGVariable(), the required
memory is allocated and has to be freed by the caller, while for
XLALReadConfigSTRINGVariable() the caller has to provide a
CHARVector of length N, which defines the maximum length of
string to be read.
\note instead of using these functions directly, it might be
more convenient to use the \ref UserInput_h.
*/
/*@{*/
/** 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
skipping to change at line 77 skipping to change at line 135
#endif /* SWIG */ #endif /* SWIG */
typedef struct tagLALConfigVar { typedef struct tagLALConfigVar {
SWIGLAL_STRUCT(LALConfigVar); 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 tagLALParsedDataFile { typedef struct tagLALParsedDataFile {
SWIGLAL_STRUCT(LALParsedDataFile); 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);
skipping to change at line 143 skipping to change at line 201
int XLALCheckConfigReadComplete (const LALParsedDataFile *cfgdata, ConfigSt rictness strict); int XLALCheckConfigReadComplete (const LALParsedDataFile *cfgdata, ConfigSt rictness strict);
int XLALLowerCaseString (CHAR *string); int XLALLowerCaseString (CHAR *string);
/* ========== DEPRECATED LAL INTERFACE FUNCTIONS, which have been replaced by XLAL functions, /* ========== DEPRECATED LAL INTERFACE FUNCTIONS, which have been replaced by XLAL functions,
* These functions are just wrappers around the XLAL functions * These functions are just wrappers around the XLAL functions
*/ */
/** \name Error codes */ /** \name Error codes */
/*@{*/ /*@{*/
#define CONFIGFILEH_ENULL 1 #define CONFIGFILEH_ENULL 1 /**< Arguments contained an
#define CONFIGFILEH_EFILE 2 unexpected null pointer. */
#define CONFIGFILEH_EVAR 3 #define CONFIGFILEH_EFILE 2 /**< File error. */
#define CONFIGFILEH_EFMT 4 #define CONFIGFILEH_EVAR 3 /**< Config variable not fo
#define CONFIGFILEH_ETOKENS 5 und. */
#define CONFIGFILEH_ENONULL 6 #define CONFIGFILEH_EFMT 4 /**< Config variable not re
#define CONFIGFILEH_EUNKNOWN 8 adable using given format-string. */
#define CONFIGFILEH_EMEM 9 #define CONFIGFILEH_ETOKENS 5 /**< The input ConfigData s
#define CONFIGFILEH_EBOOL 10 eems corrupted. */
#define CONFIGFILEH_ESTRING 11 #define CONFIGFILEH_ENONULL 6 /**< Output pointer is not
#define CONFIGFILEH_EXLAL 12 NULL */
#define CONFIGFILEH_EUNKNOWN 8 /**< Unknown config-file en
try found */
#define CONFIGFILEH_EMEM 9 /**< Out of memory */
#define CONFIGFILEH_EBOOL 10 /**< Illegal BOOLEAN entry
*/
#define CONFIGFILEH_ESTRING 11 /**< Malformed quoted strin
g */
#define CONFIGFILEH_EXLAL 12 /**< Failure in XLAL functi
on */
/*@}*/
/** \cond DONT_DOXYGEN */
#define CONFIGFILEH_MSGENULL "Arguments contained an unexpected n ull pointer." #define CONFIGFILEH_MSGENULL "Arguments contained an unexpected n ull pointer."
#define CONFIGFILEH_MSGEFILE "File error." #define CONFIGFILEH_MSGEFILE "File error."
#define CONFIGFILEH_MSGEVAR "Config variable not found." #define CONFIGFILEH_MSGEVAR "Config variable not found."
#define CONFIGFILEH_MSGEFMT "Config variable not readable using given format-string." #define CONFIGFILEH_MSGEFMT "Config variable not readable using given format-string."
#define CONFIGFILEH_MSGETOKENS "The input ConfigData seems corrupte d." #define CONFIGFILEH_MSGETOKENS "The input ConfigData seems corrupte d."
#define CONFIGFILEH_MSGENONULL "Output pointer is not NULL" #define CONFIGFILEH_MSGENONULL "Output pointer is not NULL"
#define CONFIGFILEH_MSGEUNKNOWN "Unknown config-file entry f ound" #define CONFIGFILEH_MSGEUNKNOWN "Unknown config-file entry f ound"
#define CONFIGFILEH_MSGEMEM "Out of memory" #define CONFIGFILEH_MSGEMEM "Out of memory"
#define CONFIGFILEH_MSGEBOOL "Illegal BOOLEAN entry" #define CONFIGFILEH_MSGEBOOL "Illegal BOOLEAN entry"
#define CONFIGFILEH_MSGESTRING "Malformed quoted string" #define CONFIGFILEH_MSGESTRING "Malformed quoted string"
#define CONFIGFILEH_MSGEXLAL "Failure in XLAL function" #define CONFIGFILEH_MSGEXLAL "Failure in XLAL function"
/*@}*/ /** \endcond */
/* Function prototypes */ /** \name Deprecated LAL-interface
* These functions are deprecated, and you should user their XLAL-equivalen
ts instead.
*/ /*@{*/
void LALParseDataFile (LALStatus *, LALParsedDataFile **cfgdata, const CHAR *fname); void LALParseDataFile (LALStatus *, LALParsedDataFile **cfgdata, const CHAR *fname);
void LALDestroyParsedDataFile (LALStatus *, LALParsedDataFile **cfgdata); void LALDestroyParsedDataFile (LALStatus *, LALParsedDataFile **cfgdata);
void void LALReadConfigBOOLVariable (LALStatus *, BOOLEAN *varp, const LALParsed
LALReadConfigBOOLVariable (LALStatus *, DataFile *cfgdata, const CHAR *varName, BOOLEAN *wasRead);
BOOLEAN *varp, void LALReadConfigINT4Variable (LALStatus *, INT4 *varp, const LALParsedDat
const LALParsedDataFile *cfgdata, aFile *cfgdata, const CHAR *varName, BOOLEAN *wasRead);
const CHAR *varName, void LALReadConfigREAL8Variable (LALStatus *, REAL8 *varp, const LALParsedD
BOOLEAN *wasRead); ataFile *cfgdata, const CHAR *varName, BOOLEAN *wasRead);
void LALReadConfigSTRINGVariable (LALStatus *, CHAR **varp, const LALParsed
void DataFile *cfgdata, const CHAR *varName, BOOLEAN *wasRead);
LALReadConfigINT4Variable (LALStatus *, void LALReadConfigSTRINGNVariable (LALStatus *, CHARVector *varp, const LAL
INT4 *varp, ParsedDataFile *cfgdata, const CHAR *varName, BOOLEAN *wasRead);
const LALParsedDataFile *cfgdata, void LALReadConfigVariable (LALStatus *, void *varp, const LALParsedDataFil
const CHAR *varName, e *cfgdata, const LALConfigVar *param, BOOLEAN *wasRead);
BOOLEAN *wasRead);
void
LALReadConfigREAL8Variable (LALStatus *,
REAL8 *varp,
const LALParsedDataFile *cfgdata,
const CHAR *varName,
BOOLEAN *wasRead);
void
LALReadConfigSTRINGVariable (LALStatus *,
CHAR **varp,
const LALParsedDataFile *cfgdata,
const CHAR *varName,
BOOLEAN *wasRead);
void
LALReadConfigSTRINGNVariable (LALStatus *,
CHARVector *varp,
const LALParsedDataFile *cfgdata,
const CHAR *varName,
BOOLEAN *wasRead);
void
LALReadConfigVariable (LALStatus *,
void *varp,
const LALParsedDataFile *cfgdata,
const LALConfigVar *param,
BOOLEAN *wasRead);
void LALCheckConfigReadComplete (LALStatus *, const LALParsedDataFile *cfgd ata, ConfigStrictness strict); void LALCheckConfigReadComplete (LALStatus *, const LALParsedDataFile *cfgd ata, ConfigStrictness strict);
/*@}*/
/*@}*/
/* C++ protection. */ /* C++ protection. */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* Double-include protection. */ #endif /* Double-include protection. */
 End of changes. 10 change blocks. 
73 lines changed or deleted 125 lines changed or added


 Date.h   Date.h 
/* /*
* Copyright (C) 2012 Karl Wette
* Copyright (C) 2007 Duncan Brown, David Chin, Jolien Creighton, Kipp Cann on, Reinhard Prix, Stephen Fairhurst * Copyright (C) 2007 Duncan Brown, David Chin, Jolien Creighton, Kipp Cann on, Reinhard Prix, Stephen Fairhurst
* *
* 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
skipping to change at line 123 skipping to change at line 124
#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, INT8 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 );
skipping to change at line 175 skipping to change at line 176
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 in a broken down time structure.*/ /* Returns the Modified Julian Day (MJD) corresponding to the date given in a broken down time structure.*/
INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br oken down time structure. */ ); INT4 XLALModifiedJulianDay( const struct tm *utc /**< [In] UTC time in a br oken down time structure. */ );
/** Fill in missing fields of a C 'tm' broken-down time struct. */
int XLALFillBrokenDownTime(struct tm *tm);
/* Returns the Greenwich mean or aparent sideral time in radians. */ /* Returns the Greenwich mean or aparent sideral time in radians. */
REAL8 XLALGreenwichSiderealTime( REAL8 XLALGreenwichSiderealTime(
const LIGOTimeGPS *gpstime, const LIGOTimeGPS *gpstime,
REAL8 equation_of_equinoxes REAL8 equation_of_equinoxes
); );
/* Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS time. */ /* Returns the Greenwich Mean Sidereal Time in RADIANS for a specified GPS time. */
REAL8 XLALGreenwichMeanSiderealTime( REAL8 XLALGreenwichMeanSiderealTime(
const LIGOTimeGPS *gpstime const LIGOTimeGPS *gpstime
); );
skipping to change at line 200 skipping to change at line 204
); );
/* Returns the GPS time for the given Greenwich sidereal time (in radians). */ /* Returns the GPS time for the given Greenwich sidereal time (in radians). */
LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS( LIGOTimeGPS *XLALGreenwichSiderealTimeToGPS(
REAL8 gmst, REAL8 gmst,
REAL8 equation_of_equinoxes, REAL8 equation_of_equinoxes,
LIGOTimeGPS *gps LIGOTimeGPS *gps
); );
/** \ingroup Date_h /** \ingroup Date_h
* This structure is just the standard Unix \c tm structure, described
* in the man page for <tt>ctime(3)</tt>. We shall
* {\em always} ignore the daylight savings time field, \c tm_isdst.
*/
typedef struct
tm
LALUnixDate;
/** \ingroup Date_h
* This structure stores pointers to a ::LALDetector and a * This structure stores pointers to a ::LALDetector and a
* ::LIGOTimeGPS. Its sole purpose is to aggregate these * ::LIGOTimeGPS. Its sole purpose is to aggregate these
* structures for passing to functions. * structures for passing to functions.
*/ */
typedef struct typedef struct
tagLALPlaceAndGPS tagLALPlaceAndGPS
{ {
SWIGLAL_STRUCT(LALPlaceAndGPS); SWIGLAL_STRUCT(LALPlaceAndGPS);
LALDetector *p_detector; /**< pointer to a detector */ LALDetector *p_detector; /**< pointer to a detector */
LIGOTimeGPS *p_gps; /**< Pointer to a GPS time structure */ LIGOTimeGPS *p_gps; /**< Pointer to a GPS time structure */
 End of changes. 4 change blocks. 
10 lines changed or deleted 5 lines changed or added


 DetResponse.h   DetResponse.h 
skipping to change at line 40 skipping to change at line 40
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#include <lal/SkyCoordinates.h> #include <lal/SkyCoordinates.h>
#include <lal/Date.h> #include <lal/Date.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" extern "C"
{ {
#endif #endif
NRCSID( DETRESPONSEH, "$Id$" );
/** /**
\author David Chin <dwchin@umich.edu>, Kipp Cannon <kipp@gravity.phys.uwm.e du> \author David Chin <dwchin@umich.edu>, Kipp Cannon <kipp@gravity.phys.uwm.e du>
\addtogroup DetResponse_h \addtogroup DetResponse_h
\brief Provides routines to compute gravitational wave detector response to \brief Provides routines to compute gravitational wave detector response to
polarized planar gravitational wave originating from a given source, polarized planar gravitational wave originating from a given source,
detected at a given time. detected at a given time.
\heading{Synopsis} \heading{Synopsis}
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


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


 Dirichlet.h   Dirichlet.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="DirichletHV">
Author: UTB Relativity Group; contact whelan@phys.utb.edu
$Id$
*********************************************************** </lalVerbatim>
*/
/********************************************************** <lalLaTeX>
\section{Header \texttt{Dirichlet.h}}
\label{utilities:s:Dirichlet.h}
Provides prototype and error code information for \texttt{LALDirichlet()},
a routine which calculates the values of the Dirichlet kernel
${\cal D}_N(x)$.
\subsection*{Synopsis}
\begin{verbatim}
#include "Dirichlet.h"
\end{verbatim}
\noindent
% Add more information here, if necessary.
\subsection*{Error conditions}
\input{DirichletHErrTable}
\subsection*{Structures}
\begin{verbatim}
struct DirichletParameters
\end{verbatim}
\idx[Type]{DirichletParameters}
\noindent
Contains parameters that specify the Dirichlet kernel $\mathcal{D}_N(x)$.
The fields are:
\begin{description}
\item[\texttt{UINT4 n}] Dirichlet parameter $N$.
\item[\texttt{UINT4 length}] Specified length of output vector.
\item[\texttt{REAL8 deltaX}] Spacing of $x$ values.
\end{description}
\vfill{\footnotesize\input{DirichletHV}}
\newpage\input{DirichletC}
\newpage\input{DirichletTestC}
*********************************************************** </lalLaTeX> */
#ifndef _DIRICHLET_H #ifndef _DIRICHLET_H
#define _DIRICHLET_H #define _DIRICHLET_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (DIRICHLETH, "$Id$"); /**
\addtogroup Dirichlet_h
\author UTB Relativity Group; contact whelan@phys.utb.edu
/******************************** <lalErrTable file="DirichletHErrTable"> * \brief Provides prototype and error code information for <tt>LALDirichle
/ t()</tt>,
a routine which calculates the values of the Dirichlet kernel
\f${\cal D}_N(x)\f$.
#define DIRICHLETH_ENULLPIN 1 \heading{Synopsis}
#define DIRICHLETH_ENVALUE 2 \code
#define DIRICHLETH_ESIZE 3 #include "Dirichlet.h"
#define DIRICHLETH_EDELTAX 4 \endcode
#define DIRICHLETH_ENULLPOUT 5
#define DIRICHLETH_ESIZEMM 6 */
#define DIRICHLETH_ENULLPDOUT 7 /*@{*/
/**\name Error Codes */
/*@{*/
#define DIRICHLETH_ENULLPIN 1 /**< Null pointer to input p
arameters */
#define DIRICHLETH_ENVALUE 2 /**< Dirichlet parameter N l
ess than or equal to zero */
#define DIRICHLETH_ESIZE 3 /**< Length parameter less t
han or equal to zero */
#define DIRICHLETH_EDELTAX 4 /**< Spacing of x values les
s than or equal to zero */
#define DIRICHLETH_ENULLPOUT 5 /**< Null pointer to ouput v
ector */
#define DIRICHLETH_ESIZEMM 6 /**< Length of data member o
f output vector does not equal length specified in input parameters */
#define DIRICHLETH_ENULLPDOUT 7 /**< Null pointer to data me
mber of output vector */
/*@}*/
/** \cond DONT_DOXYGEN */
#define DIRICHLETH_MSGENULLPIN "Null pointer to input parameters" #define DIRICHLETH_MSGENULLPIN "Null pointer to input parameters"
#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"
/** \endcond */
/************************************ </lalErrTable> */ /** Contains parameters that specify the Dirichlet kernel \f$\mathcal{D}_N(
x)\f$ */
typedef struct tagDirichletParameters{ typedef struct tagDirichletParameters{
SWIGLAL_STRUCT(DirichletParameters); SWIGLAL_STRUCT(DirichletParameters);
UINT4 n; /* LALDirichlet parameter N */ UINT4 n; /**< Dirichlet parameter \f$N\f$ */
UINT4 length; /* specified length of output vector */ UINT4 length; /**< Specified length of output vector */
REAL8 deltaX; /* spacing of x values */ REAL8 deltaX; /**< Spacing of \f$x\f$ values */
} DirichletParameters; } DirichletParameters;
void void
LALDirichlet(LALStatus*, LALDirichlet(LALStatus*,
REAL4Vector*, REAL4Vector*,
const DirichletParameters*); const DirichletParameters*);
/*@}*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* C++ protection */ #endif /* C++ protection */
#endif /* _DIRICHLET_H */ #endif /* _DIRICHLET_H */
 End of changes. 9 change blocks. 
65 lines changed or deleted 41 lines changed or added


 EllipsoidOverlapTools.h   EllipsoidOverlapTools.h 
skipping to change at line 26 skipping to change at line 26
* 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 Name: EllipsoidOverlapTools.h * File Name: EllipsoidOverlapTools.h
* *
* Author: Robinson, C. A., and Sengupta, A. * Author: Robinson, C. A., and Sengupta, A.
* *
* Revision: $Id$
* *
*----------------------------------------------------------------------- *-----------------------------------------------------------------------
*/ */
#if 0 #if 0
Author: Robinson, C. A. and Sengupta, A. S. Author: Robinson, C. A. and Sengupta, A. S.
#endif #endif
#ifndef _ELLIPSOIDOVERLAPTOOLS_H #ifndef _ELLIPSOIDOVERLAPTOOLS_H
#define _ELLIPSOIDOVERLAPTOOLS_H #define _ELLIPSOIDOVERLAPTOOLS_H
skipping to change at line 60 skipping to change at line 59
#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>
#include <gsl/gsl_blas.h> #include <gsl/gsl_blas.h>
#include <gsl/gsl_linalg.h> #include <gsl/gsl_linalg.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( ELLIPSOIDOVERLAPTOOLSH, "$Id$" );
typedef struct tagfContactWorkSpace typedef struct tagfContactWorkSpace
{ {
SWIGLAL_STRUCT(fContactWorkSpace); 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;
 End of changes. 2 change blocks. 
3 lines changed or deleted 0 lines changed or added


 FFTWMutex.h   FFTWMutex.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 * 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 _FFTWMUTEX_H #ifndef _FFTWMUTEX_H
#define _FFTWMUTEX_H #define _FFTWMUTEX_H
#include <lal/LALConfig.h> #include <lal/LALConfig.h>
#include <lal/LALRCSID.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( FFTWMUTEXH, "$Id$" );
#ifdef LAL_PTHREAD_LOCK #ifdef LAL_PTHREAD_LOCK
# include <pthread.h> # include <pthread.h>
extern pthread_mutex_t lalFFTWMutex; extern pthread_mutex_t lalFFTWMutex;
# define LAL_FFTW_PTHREAD_MUTEX_LOCK pthread_mutex_lock( &lalFFTWMutex ) # define LAL_FFTW_PTHREAD_MUTEX_LOCK pthread_mutex_lock( &lalFFTWMutex )
# define LAL_FFTW_PTHREAD_MUTEX_UNLOCK pthread_mutex_unlock( &lalFFTWMutex ) # define LAL_FFTW_PTHREAD_MUTEX_UNLOCK pthread_mutex_unlock( &lalFFTWMutex )
#else #else
# define LAL_FFTW_PTHREAD_MUTEX_LOCK # define LAL_FFTW_PTHREAD_MUTEX_LOCK
# define LAL_FFTW_PTHREAD_MUTEX_UNLOCK # define LAL_FFTW_PTHREAD_MUTEX_UNLOCK
#endif #endif
 End of changes. 2 change blocks. 
3 lines changed or deleted 0 lines changed or added


 FileIO.h   FileIO.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="FileIOHV">
$Id$
</lalVerbatim> */
/* <lalLaTeX>
\section{Header \texttt{FileIO.h}}
\label{s:FileIO.h}
Provides standard LAL support IO functions.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/LALStdio.h>
#include <lal/FileIO.h>
\end{verbatim}
\noindent Only use \texttt{FileIO.h} in test code that links to
the \texttt{lalsupport} library.
\vfill{\footnotesize\input{FileIOHV}}
\newpage\input{FileIOC}
</lalLaTeX> */
#ifndef _FILEIO_H #ifndef _FILEIO_H
#define _FILEIO_H #define _FILEIO_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <lal/LALRCSID.h>
#include <lal/LALStdio.h> #include <lal/LALStdio.h>
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
/**
\addtogroup FileIO_h
\brief Provides standard LAL support IO functions.
\heading{Synopsis}
\code
#include <lal/LALStdio.h>
#include <lal/FileIO.h>
\endcode
Only use \ref FileIO.h in test code that links to the \c lalsupport libr
ary.
*/
/*@{*/
FILE * FILE *
LALOpenDataFile( const char * ); LALOpenDataFile( const char * );
typedef struct tagLALFILE { typedef struct tagLALFILE {
SWIGLAL_STRUCT(LALFILE); SWIGLAL_STRUCT(LALFILE);
int compression; int compression;
void *fp; void *fp;
} LALFILE; } LALFILE;
LALFILE *lalstdin(void); LALFILE *lalstdin(void);
LALFILE *lalstdout(void); LALFILE *lalstdout(void);
skipping to change at line 101 skipping to change at line 91
#ifndef SWIG /* exclude from SWIG interface */ #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 */ #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
#endif /* _FILEIO_H */ #endif /* _FILEIO_H */
 End of changes. 5 change blocks. 
25 lines changed or deleted 18 lines changed or added


 FindRoot.h   FindRoot.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
*/ */
#if 0 /* autodoc block */
<lalVerbatim file="FindRootHV">
$Id$
</lalVerbatim>
<lalLaTeX>
\section{Header \texttt{FindRoot.h}}
\label{s:FindRoot.h}
Root finding routines.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/FindRoot.h>
\end{verbatim}
\noindent This header covers the routines for root finding.
</lalLaTeX>
#endif /* autodoc block */
#ifndef _FINDROOT_H #ifndef _FINDROOT_H
#define _FINDROOT_H #define _FINDROOT_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (FINDROOTH, "$Id$"); /**
\addtogroup FindRoot_h
#if 0 /* autodoc block */
<lalLaTeX> \brief Root finding routines.
\subsection*{Error conditions}
\input{FindRootHErrTab}
</lalLaTeX>
<lalErrTable file="FindRootHErrTab"> \heading{Synopsis}
\code
#include <lal/FindRoot.h>
\endcode
#endif /* autodoc block */ This header covers the routines for root finding.
#define FINDROOTH_ENULL 1 \heading{Description}
#define FINDROOTH_EIDOM 2
#define FINDROOTH_EMXIT 4
#define FINDROOTH_EBRKT 8
#define FINDROOTH_MSGENULL "Null pointer" The routine <tt>LALSBracketRoot()</tt> expands the specified domain until a
#define FINDROOTH_MSGEIDOM "Invalid initial domain" root
#define FINDROOTH_MSGEMXIT "Maximum iterations exceeded" is contained. The routine <tt>LALDBracketRoot()</tt> is the same but for a
#define FINDROOTH_MSGEBRKT "Root not bracketed" double-precision function.
#if 0 /* autodoc block */ The routine <tt>LALSBisectionFindRoot()</tt> bisects the domain (which must
contain one
root) until the root is found with the desired accuracy. The routine
<tt>LALDBisectionFindRoot()</tt> is the same but for a double-precision fun
ction.
</lalErrTable> \heading{Operating Instructions}
<lalLaTeX> Suppose we want to find the root of the function \f$y = F(x;y_0) = y_0 + x^
2\f$.
Define the function:
\code
static void F( LALStatus *status, REAL4 *y, REAL4 x, void *y0 )
{
INITSTATUS(status);
ASSERT( y0, status, 1, "Null pointer" );
*y = *(REAL4 *)y0 + x*x;
RETURN( status );
}
\endcode
\subsection*{Structures} Then use the following code to bracket and find the root \f$x_0=1\f$ where
\f$F(x_0;y_0=-1)=0\f$:
\code
static LALStatus status;
SFindRootIn input;
REAL4 y0;
REAL4 x0;
\begin{verbatim} y0 = -1;
typedef void (REAL4LALFunction) (LALStatus *s, REAL4 *y, REAL4 x, void *p); input.function = F;
typedef void (REAL8LALFunction) (LALStatus *s, REAL8 *y, REAL8 x, void *p); input.xmin = 0.1;
\end{verbatim} input.xmax = 0.2;
input.xacc = 1e-5;
These are function pointers to functions that map real numbers to real numb /\* expand domain until a root is bracketed *\/
ers. LALSBracketRoot( &status, &input, &y0 );
\begin{verbatim} /\* bisect domain until root is found *\/
typedef struct LALSBisectionFindRoot( &status, &x0, &input, &y0 );
tagSFindRootIn \endcode
{
void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p);
REAL4 xmax;
REAL4 xmin;
REAL4 xacc;
}
SFindRootIn;
typedef struct \heading{Algorithm}
tagDFindRootIn
{
void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p);
REAL8 xmax;
REAL8 xmin;
REAL8 xacc;
}
DFindRootIn;
\end{verbatim}
These are the input structures to the root finding routines. The fields ar This is an implementation of the root bracketing and bisection finding
e: routines \c zbrac and \c rtbis in Numerical Recipes [\ref ptvf1992].
\begin{description} */
\item[\texttt{function}] The function to find the root of. /*@{*/
\item[\texttt{xmax}] The maximum value of the domain interval to look for t
he root.
\item[\texttt{xmax}] The minimum value of the domain interval to look for t
he root.
\item[\texttt{xacc}] The accuracy desired for the root.
\end{description}
</lalLaTeX> /** \name Error Codes */
/*@{*/
#define FINDROOTH_ENULL 1 /**< Null pointer */
#define FINDROOTH_EIDOM 2 /**< Invalid initial domain */
#define FINDROOTH_EMXIT 4 /**< Maximum iterations exceeded */
#define FINDROOTH_EBRKT 8 /**< Root not bracketed */
/*@}*/
#endif /* autodoc block */ /** \cond DONT_DOXYGEN */
#define FINDROOTH_MSGENULL "Null pointer"
#define FINDROOTH_MSGEIDOM "Invalid initial domain"
#define FINDROOTH_MSGEMXIT "Maximum iterations exceeded"
#define FINDROOTH_MSGEBRKT "Root not bracketed"
/** \endcond */
/** These are function pointers to functions that map REAL4 numbers to REAL
4 numbers.
*/
typedef struct typedef struct
tagSFindRootIn tagSFindRootIn
{ {
SWIGLAL_STRUCT(SFindRootIn); SWIGLAL_STRUCT(SFindRootIn);
void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); /**< The fun
REAL4 xmax; ction to find the root of */
REAL4 xmin; REAL4 xmax; /**< The maximum value of the domain interval to look for th
REAL4 xacc; e root */
REAL4 xmin; /**< The minimum value of the domain interval to look for th
e root */
REAL4 xacc; /**< The accuracy desired for the root */
} }
SFindRootIn; SFindRootIn;
/** These are function pointers to functions that map REAL8 numbers to REAL
8 numbers.
*/
typedef struct typedef struct
tagDFindRootIn tagDFindRootIn
{ {
SWIGLAL_STRUCT(DFindRootIn); SWIGLAL_STRUCT(DFindRootIn);
void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); /**< The fun
REAL8 xmax; ction to find the root of */
REAL8 xmin; REAL8 xmax; /**< The maximum value of the domain interval to look for th
REAL8 xacc; e root */
REAL8 xmin; /**< The minimum value of the domain interval to look for th
e root */
REAL8 xacc; /**< The accuracy desired for the root */
} }
DFindRootIn; DFindRootIn;
#if 0 /* autodoc block */ /* ----- FindRoot.c ----- */
<lalLaTeX>
\newpage\input{FindRootC}
</lalLaTeX>
#endif /* autodoc block */
void void
LALSBracketRoot ( LALSBracketRoot (
LALStatus *status, LALStatus *status,
SFindRootIn *inout, SFindRootIn *inout,
void *params void *params
); );
int int
XLALDBracketRoot( XLALDBracketRoot(
REAL8 (*y)(REAL8, void *), REAL8 (*y)(REAL8, void *),
skipping to change at line 208 skipping to change at line 188
); );
void void
LALDBisectionFindRoot ( LALDBisectionFindRoot (
LALStatus *status, LALStatus *status,
REAL8 *root, REAL8 *root,
DFindRootIn *input, DFindRootIn *input,
void *params void *params
); );
#if 0 /* autodoc block */ /*@}*/
<lalLaTeX>
\newpage\input{FindRootTestC}
</lalLaTeX>
#endif /* autodoc block */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _FINDROOT_H */ #endif /* _FINDROOT_H */
 End of changes. 25 change blocks. 
106 lines changed or deleted 88 lines changed or added


 FlatLatticeTiling.h   FlatLatticeTiling.h 
skipping to change at line 37 skipping to change at line 37
#define _FLATLATTICETILING_H #define _FLATLATTICETILING_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#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/LALDatatypes.h> #include <lal/LALDatatypes.h>
#include <lal/Random.h> #include <lal/Random.h>
#include <lal/GSLSupport.h> #include <lal/GSLSupport.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
NRCSID(FLATLATTICETILINGH, "$Id$");
/** /**
* Flat lattice tiling bound * Flat lattice tiling bound
*/ */
typedef BOOLEAN (*FlatLatticeTilingBoundFunc)( typedef BOOLEAN (*FlatLatticeTilingBoundFunc)(
void *data, /**< Arbit rary data describing parameter space */ void *data, /**< Arbit rary data describing parameter space */
INT4 dimension, /**< Dimen sion on which bound applies */ INT4 dimension, /**< Dimen sion on which bound applies */
gsl_vector *point, /**< Point on which to find bounds */ gsl_vector *point, /**< Point on which to find bounds */
REAL8 *lower, /**< Lower bound on point in dimension */ REAL8 *lower, /**< Lower bound on point in dimension */
REAL8 *upper /**< Upper bound on point in dimension */ REAL8 *upper /**< Upper bound on point in dimension */
); );
 End of changes. 2 change blocks. 
3 lines changed or deleted 0 lines changed or added


 FrequencySeries.h   FrequencySeries.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 _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>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
NRCSID(FREQUENCYSERIESH, "$Id:");
/* COMPLEX8 prototypes */ /* COMPLEX8 prototypes */
void XLALDestroyCOMPLEX8FrequencySeries ( void XLALDestroyCOMPLEX8FrequencySeries (
COMPLEX8FrequencySeries *series COMPLEX8FrequencySeries *series
); );
COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries ( COMPLEX8FrequencySeries *XLALCreateCOMPLEX8FrequencySeries (
const CHAR *name, const CHAR *name,
const LIGOTimeGPS *epoch, const LIGOTimeGPS *epoch,
REAL8 f0, REAL8 f0,
 End of changes. 3 change blocks. 
4 lines changed or deleted 0 lines changed or added


 GSLSupport.h   GSLSupport.h 
skipping to change at line 32 skipping to change at line 32
* \file * \file
* \brief Support routines for GSL * \brief Support routines for GSL
*/ */
#ifndef _GSLSUPPORT_H #ifndef _GSLSUPPORT_H
#define _GSLSUPPORT_H #define _GSLSUPPORT_H
#include <gsl/gsl_vector.h> #include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h> #include <gsl/gsl_matrix.h>
#include <lal/LALRCSID.h>
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID(GSLSUPPORTH, "$Id$");
/** /**
* Functions * Functions
*/ */
gsl_vector *XLALGSLVectorFromVAList(INT4, REAL8, ...); gsl_vector *XLALGSLVectorFromVAList(INT4, REAL8, ...);
gsl_vector *XLALGSLVectorFromLALStringVector(LALStringVector*); gsl_vector *XLALGSLVectorFromLALStringVector(LALStringVector*);
gsl_matrix *XLALResizeGSLMatrix(gsl_matrix*, size_t, size_t, double); gsl_matrix *XLALResizeGSLMatrix(gsl_matrix*, size_t, size_t, double);
gsl_vector *XLALResizeGSLVector(gsl_vector*, size_t, double); gsl_vector *XLALResizeGSLVector(gsl_vector*, size_t, double);
gsl_vector_int *XLALResizeGSLVectorInt(gsl_vector_int*, size_t, int); gsl_vector_int *XLALResizeGSLVectorInt(gsl_vector_int*, size_t, int);
#ifdef __cplusplus #ifdef __cplusplus
 End of changes. 2 change blocks. 
3 lines changed or deleted 0 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
*/ */
/**
\author Creighton, T. D.
\file
\brief Provides a structured datatype for a multidimensional rectilinear gr
id.
\heading{Synopsis}
\code
#include <lal/Grid.h>
\endcode
This header provides a new structured datatype storing data
on a multidimensional rectilinear grid. It is in some sense a
generalization of the series datatypes (frequency series, time series,
etc.), representing evenly-sampled data over some physical parameter
space.
*/
#ifndef _GRID_H #ifndef _GRID_H
#define _GRID_H #define _GRID_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID( GRIDH, "$Id$" );
/** /**
\heading{Error conditions} \addtogroup Grid_h
\name Error Codes */ /*@{*/ \author Creighton, T. D.
#define GRIDH_ENUL 1
#define GRIDH_EOUT 2
#define GRIDH_EMEM 3
#define GRIDH_MSGENUL "Unexpected null pointer in arguments" \brief Provides a structured datatype for a multidimensional rectilinear
#define GRIDH_MSGEOUT "Output handle points to a non-null pointer" grid.
#define GRIDH_MSGEMEM "Memory allocation error"
/*@}*//**
\heading{Types} \heading{Synopsis}
\code
#include <lal/Grid.h>
\endcode
This header provides a new structured datatype storing data
on a multidimensional rectilinear grid. It is in some sense a
generalization of the series datatypes (frequency series, time series,
etc.), representing evenly-sampled data over some physical parameter
space.
\heading{Structure <tt>\<datatype\>Grid</tt>} \heading{Structure <tt>\<datatype\>Grid</tt>}
This structure is a generalization of the LAL series types, This structure is a generalization of the LAL series types,
storing data on an \f$m\f$-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 <tt>\<datatype\></tt> parameter space. The values on the grid are of type <tt>\<datatype\></tt>
which can be any LAL primitive \e numerical datatype (\c INT2, which can be any LAL primitive \e numerical datatype (#INT2,
\c INT4, \c INT8, \c UINT2, \c UINT4, \c UINT8, #INT4, #INT8, #UINT2, #UINT4, #UINT8,
\c REAL4, \c REAL8, \c COMPLEX8, \c COMPLEX16). The #REAL4, #REAL8, #COMPLEX8, #COMPLEX16). The
data are stored in an array of dimension \f$M\geq m\f$: if \f$M=m\f$, then the data are stored in an array of dimension \f$M\geq m\f$: if \f$M=m\f$, then the
structure stores a single value for each grid point; if \f$M>m\f$, then 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 \f$m\f$ as the \e grid space'' of each grid point. We refer to \f$m\f$ as the \e grid
dimension and \f$M\f$ as the \e data dimension. The fields of the dimension and \f$M\f$ as the \e data dimension. The fields of the
structure are: structure are:
<dl> <dl>
<dt><tt>CHAR name[LALNameLength]</tt></dt><dd> A name identifying the grid <dt><tt>CHAR name[LALNameLength]</tt></dt><dd> A name identifying the grid
and/or the data being sampled.</dd> and/or the data being sampled.</dd>
skipping to change at line 115 skipping to change at line 97
the grid dimension \f$m=\f$<tt>offset->length</tt>=<tt>interval->length</tt >. the grid dimension \f$m=\f$<tt>offset->length</tt>=<tt>interval->length</tt >.
An index \f$\mathbf{i}=(i_0,\ldots,i_{M-1})\f$, where \f$i_k\f$ are integer s An index \f$\mathbf{i}=(i_0,\ldots,i_{M-1})\f$, where \f$i_k\f$ are integer s
from 0 to <tt>data->dimLength->data</tt>\f${}_k\f$, specifies a grid point from 0 to <tt>data->dimLength->data</tt>\f${}_k\f$, specifies a grid point
located at \f$\mathbf{p}=\mathbf{p}_0+\sum_{k=0}^{n-1}\hat{\mathbf{e}}_k located at \f$\mathbf{p}=\mathbf{p}_0+\sum_{k=0}^{n-1}\hat{\mathbf{e}}_k
i_k \Delta p_k\f$ if \f$M=m\f$, or an array element \f$\mathsf{A}_{i_m\cdot s 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 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 <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
\ref LALDatatypes.h.</dd> \ref LALDatatypes.h.</dd>
</dl> </dl>
\heading{Prototypes}
\code
void
LAL<typecode>CreateGrid( LALStatus *stat,
<datatype>Grid **grid,
UINT4Vector *dimLength,
UINT4 dimension )
void
LAL<typecode>DestroyGrid( LALStatus *stat,
<datatype>Grid **grid )
\endcode
\heading{Description}
These routines create or destroy a <tt>\<datatype\>Grid</tt> structure.
The input vector \c dimLength stores the lengths of each dimension
of the grid \e and of the array at each grid point: in the
notation defined in \ref Grid.h, <tt>dimLength->length</tt>\f$=M\f$. The
parameter \c dimension gives the dimension \f$m\f$ of the physical
grid space; if \f$M>m\f$, then the remaining dimensions refer to a tangent
space at each grid point. When creating a grid, the routines allocate
space for all the internal vectors and arrays, but no data are filled
in, with the exception of the <tt>(*grid)->data->dimLength</tt> vector
(which will contain exactly the same data as the \c dimLength
input parameter). When calling the <tt>LAL\<typecode\>CreateGrid()</tt>
routines, or on returning from the <tt>LAL\<typecode\>DestroyGrid()</tt>
routines, \c grid should be a non-\c NULL handle to a
\c NULL-valued pointer.
For each of these prototype templates there are in fact 10 separate
routines corresponding to all the numerical atomic datatypes
<tt>\<datatype\></tt> referred to by <tt>\<typecode\></tt>:
<table>
<tr><th>\<typecode\></th><th>\<datatype\></th><th>\<typecode\></th><th>\<da
tatype\></th></tr>
<tr><td>I2</td><td> INT2</td><td> U2</td><td> UINT2</td></tr>
<tr><td>I4</td><td> INT4</td><td> U4</td><td> UINT4</td></tr>
<tr><td>I8</td><td> INT8</td><td> U8</td><td> UINT8</td></tr>
<tr><td> S</td><td> REAL4</td><td> C</td><td> COMPLEX8</td></tr>
<tr><td> D</td><td> REAL8</td><td> Z</td><td> COMPLEX16</td></tr>
</table>
*/ */
/*@{*/
/** \name Error Codes */ /*@{*/
#define GRIDH_ENUL 1 /**< Unexpected null pointer in arguments */
#define GRIDH_EOUT 2 /**< Output handle points to a non-null pointer */
#define GRIDH_EMEM 3 /**< Memory allocation error */
/*@}*/
/*@}*/
/** \cond DONT_DOXYGEN */
#define GRIDH_MSGENUL "Unexpected null pointer in arguments"
#define GRIDH_MSGEOUT "Output handle points to a non-null pointer"
#define GRIDH_MSGEMEM "Memory allocation error"
/** \endcond */
typedef struct tagINT2Grid { typedef struct tagINT2Grid {
SWIGLAL_STRUCT(INT2Grid); 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;
skipping to change at line 279 skipping to change at line 320
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 );
/**
%
*/
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _GRID_H */ #endif /* _GRID_H */
 End of changes. 9 change blocks. 
39 lines changed or deleted 77 lines changed or added


 IIRFilter.h   IIRFilter.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="IIRFilterHV"> #ifndef _IIRFILTER_H
Author: Creighton, T. D. #define _IIRFILTER_H
$Id$
**************************************************** </lalVerbatim> */
/********************************************************** <lalLaTeX> /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...)
#endif
\section{Header \texttt{IIRFilter.h}} #include <lal/LALStdlib.h>
\label{s:IIRFilter.h} #include <lal/ZPGFilter.h>
Provides routines to make and apply IIR filters. #if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
\subsection*{Synopsis} /**
\begin{verbatim} \author Creighton, T. D.
#include <lal/IIRFilter.h> \addtogroup IIRFilter_h
\end{verbatim}
\noindent This header covers routines that create, destroy, and apply \brief Provides routines to make and apply IIR filters.
\heading{Synopsis}
\code
#include <lal/IIRFilter.h>
\endcode
This header covers routines that create, destroy, and apply
generic time-domain filters, given by objects of type generic time-domain filters, given by objects of type
\verb@<datatype>IIRFilter@, where \verb@<datatype>@ is either <tt>\<datatype\>IIRFilter</tt>, where <tt>\<datatype\></tt> is either
\verb@REAL4@ or \verb@REAL8@. \c REAL4 or \c REAL8.
An IIR (Infinite Impulse Response) filter is a generalized linear An IIR (Infinite Impulse Response) filter is a generalized linear
causal time-domain filter, in which the filter output $y_n=y(t_n)$ at causal time-domain filter, in which the filter output \f$y_n=y(t_n)\f$ at
any sampled time $t_n=t_0+n\Delta t$ is a linear combination of the any sampled time \f$t_n=t_0+n\Delta t\f$ is a linear combination of the
input $x$ \emph{and} output $y$ at previous sampled times: input \f$x\f$ \e and output \f$y\f$ at previous sampled times:
$$ \f[
y_n = \sum_{k=0}^M c_k x_{n-k} + \sum_{l=1}^N d_l y_{n-l} \; . y_n = \sum_{k=0}^M c_k x_{n-k} + \sum_{l=1}^N d_l y_{n-l} \; .
$$ \f]
The coefficients $c_k$ are called the direct filter coefficients, and The coefficients \f$c_k\f$ are called the direct filter coefficients, and
the coefficients $d_l$ are the recursive filter coefficients. The the coefficients \f$d_l\f$ are the recursive filter coefficients. The
filter order is the larger of $M$ or $N$, and determines how far back filter order is the larger of \f$M\f$ or \f$N\f$, and determines how far ba
ck
in time the filter must look to determine its next output. However, in time the filter must look to determine its next output. However,
the recursive nature of the filter means that the output can depend on the recursive nature of the filter means that the output can depend on
input arbitrarily far in the past; hence the name ``infinite impulse input arbitrarily far in the past; hence the name "infinite impulse
response''. Nonetheless, for a well-designed, stable filter, the response". Nonetheless, for a well-designed, stable filter, the
actual filter response to an impulse should diminish rapidly beyond actual filter response to an impulse should diminish rapidly beyond
some characteristic timescale. some characteristic timescale.
Note that nonrecursive FIR (Finite Impulse Response) filters are Note that nonrecursive FIR (Finite Impulse Response) filters are
considered a subset of IIR filters, having $N=0$. considered a subset of IIR filters, having \f$N=0\f$.
For practical implementation, it is convenient to express the bilinear For practical implementation, it is convenient to express the bilinear
equation above as two linear equations involving an auxiliary sequence equation above as two linear equations involving an auxiliary sequence
$w$: \f$w\f$:
$$ \f[
w_n = x_n + \sum_{l=1}^N d_l w_{n-l} \; , w_n = x_n + \sum_{l=1}^N d_l w_{n-l} \; ,
$$ \f]
$$ \f[
y_n = \sum_{k=0}^M c_k w_{n-k} \; . y_n = \sum_{k=0}^M c_k w_{n-k} \; .
$$ \f]
The equivalence of this to the first expression is not obvious, but The equivalence of this to the first expression is not obvious, but
can be proven by mathematical induction. The advantage of the can be proven by mathematical induction. The advantage of the
auxiliary variable representation is twofold. First, when one is auxiliary variable representation is twofold. First, when one is
feeding data point by point to the filter, the filter needs only feeding data point by point to the filter, the filter needs only
``remember'' the previous $M$ or $N$ (whichever is larger) values of "remember" the previous \f$M\f$ or \f$N\f$ (whichever is larger) values of
$w$, rather than remembering the previous $M$ values of $x$ \emph{and} \f$w\f$, rather than remembering the previous \f$M\f$ values of \f$x\f$ \e
the previous $N$ values of $y$. Second, when filtering a large stored and
the previous \f$N\f$ values of \f$y\f$. Second, when filtering a large sto
red
data vector, the filter response can be computed in place: one first data vector, the filter response can be computed in place: one first
runs forward through the vector replacing $x$ with $w$, and then runs forward through the vector replacing \f$x\f$ with \f$w\f$, and then
backward replacing $w$ with $y$. backward replacing \f$w\f$ with \f$y\f$.
Although the IIR filters in these routines are explicitly real, one Although the IIR filters in these routines are explicitly real, one
can consider formally their complex response. A sinusoidal input can can consider formally their complex response. A sinusoidal input can
thus be written as $x_n=X\exp(2\pi ifn\Delta t)=Xz^n$, where $X$ is a thus be written as \f$x_n=X\exp(2\pi ifn\Delta t)=Xz^n\f$, where \f$X\f$ is
complex amplitude and $z=\exp(2\pi if\Delta t)$ is a complex a
complex amplitude and \f$z=\exp(2\pi if\Delta t)\f$ is a complex
parametrization of the frequency. By linearity, the output must also parametrization of the frequency. By linearity, the output must also
be sinusoidal: $y_m=Y\exp(2\pi ifm\Delta t)=Yz^m$. Putting these into be sinusoidal: \f$y_m=Y\exp(2\pi ifm\Delta t)=Yz^m\f$. Putting these into
the bilinear equation, one can easily compute the filter's complex the bilinear equation, one can easily compute the filter's complex
transfer function: transfer function:
$$ \f[
T(z) = \frac{Y}{X} = \frac{\sum_{k=0}^M c_k z^{-k}} T(z) = \frac{Y}{X} = \frac{\sum_{k=0}^M c_k z^{-k}}
{1 - \sum_{l=1}^N d_l z^{-l}} {1 - \sum_{l=1}^N d_l z^{-l}}
$$ \f]
This can be readily converted to and from the ``zeros, poles, gain'' This can be readily converted to and from the "zeros, poles, gain"
representation of a filter, which expresses $T(z)$ as a factored representation of a filter, which expresses \f$T(z)\f$ as a factored
rational function of $z$. rational function of \f$z\f$.
It should also be noted that, in the routines covered by this header, It should also be noted that, in the routines covered by this header,
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 \f$d_0\f$, in order to make the indexing more intuitive. For
formal correctness $d_0$ should be set to $-1$, although the filtering formal correctness \f$d_0\f$ should be set to \f$-1\f$, although the filter
ing
routines never actually use this coefficient. routines never actually use this coefficient.
******************************************************* </lalLaTeX> */ */
/*@{*/
#ifndef _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/ZPGFilter.h>
#if defined(__cplusplus)
extern "C" {
#elif 0
} /* so that editors will match preceding brace */
#endif
NRCSID(IIRFILTERH,"$Id$"); /**
@{
\defgroup CreateIIRFilter_c Module CreateIIRFilter.c
\defgroup DestroyIIRFilter_c Module DestroyIIRFilter.c
\defgroup IIRFilter_c Module IIRFilter.c
\defgroup IIRFilterVector_c Module IIRFilterVector.c
\defgroup IIRFilterVectorR_c Module IIRFilterVectorR.c
@}
*/
/********************************************************** <lalLaTeX> /** \name Error Codes */ /*@{*/
\subsection*{Error conditions} #define IIRFILTERH_ENUL 1 /**< Unexpected null pointer in arguments */
****************************************** </lalLaTeX><lalErrTable> */ #define IIRFILTERH_EOUT 2 /**< Output handle points to a non-null poin
#define IIRFILTERH_ENUL 1 ter */
#define IIRFILTERH_EOUT 2 #define IIRFILTERH_EMEM 3 /**< Memory allocation error */
#define IIRFILTERH_EMEM 3 #define IIRFILTERH_EPAIR 4 /**< Input has unpaired nonreal poles or zer
#define IIRFILTERH_EPAIR 4 os */
/*@}*/
/** \cond DONT_DOXYGEN */
#define IIRFILTERH_MSGENUL "Unexpected null pointer in arguments" #define IIRFILTERH_MSGENUL "Unexpected null pointer in arguments"
#define IIRFILTERH_MSGEOUT "Output handle points to a non-null pointer" #define IIRFILTERH_MSGEOUT "Output handle points to a non-null pointer"
#define IIRFILTERH_MSGEMEM "Memory allocation error" #define IIRFILTERH_MSGEMEM "Memory allocation error"
#define IIRFILTERH_MSGEPAIR "Input has unpaired nonreal poles or zeros" #define IIRFILTERH_MSGEPAIR "Input has unpaired nonreal poles or zeros"
/******************************************** </lalErrTable><lalLaTeX> /** \endcond */
\subsection*{Types}
\subsubsection*{Structure \texttt{<datatype>IIRFilter}}
\idx[Type]{REAL4IIRFilter}
\idx[Type]{REAL8IIRFilter}
This structure stores the direct and recursive filter coefficients, as
well as the history of the auxiliary sequence $w$. \verb@<datatype>@
may be \verb@REAL4@ or \verb@REAL8@. The length of the history vector
gives the order of the filter. The fields are:
\begin{description}
\item[\texttt{const CHAR *name}] A user-assigned name.
\item[\texttt{REAL8 deltaT}] The sampling time interval of the filter.
If $\leq0$, it will be ignored (i.e.\ it will be taken from the data
stream).
\item[\texttt{<datatype>Vector *directCoef}] The direct filter
coefficients.
\item[\texttt{<datatype>Vector *recursCoef}] The recursive filter
coefficients.
\item[\texttt{<datatype>Vector *history}] The previous values of $w$.
\end{description}
******************************************************* </lalLaTeX> */
/** This structure stores the direct and recursive REAL4 filter coefficient
s, as
* well as the history of the auxiliary sequence \f$w\f$.
* The length of the history vector gives the order of the filter
*/
#ifdef SWIG /* SWIG interface directives */ #ifdef SWIG /* SWIG interface directives */
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL4IIRFilter::name; %warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL4IIRFilter::name;
#endif /* SWIG */ #endif /* SWIG */
typedef struct tagREAL4IIRFilter{ typedef struct tagREAL4IIRFilter{
SWIGLAL_STRUCT(REAL4IIRFilter); 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 of the filter; If \f
REAL4Vector *directCoef; /* The direct filter coefficients. */ $\leq0\f$, it will be ignored (ie it will be taken from the data stream) */
REAL4Vector *recursCoef; /* The recursive filter coefficients. */ REAL4Vector *directCoef; /**< The direct filter coefficients. */
REAL4Vector *history; /* The previous values of w. */ REAL4Vector *recursCoef; /**< The recursive filter coefficients. */
REAL4Vector *history; /**< The previous values of w. */
} REAL4IIRFilter; } REAL4IIRFilter;
/** This structure stores the direct and recursive REAL8 filter coefficient
s, as
* well as the history of the auxiliary sequence \f$w\f$.
* The length of the history vector gives the order of the filter
*/
#ifdef SWIG /* SWIG interface directives */ #ifdef SWIG /* SWIG interface directives */
%warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL8IIRFilter::name; %warnfilter(SWIGWARN_TYPEMAP_CHARLEAK) tagREAL8IIRFilter::name;
#endif /* SWIG */ #endif /* SWIG */
typedef struct tagREAL8IIRFilter{ typedef struct tagREAL8IIRFilter{
SWIGLAL_STRUCT(REAL8IIRFilter); 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 of the filter; If \f
REAL8Vector *directCoef; /* The direct filter coefficients. */ $\leq0\f$, it will be ignored (ie it will be taken from the data stream). *
REAL8Vector *recursCoef; /* The recursive filter coefficients. */ /
REAL8Vector *history; /* The previous values of w. */ REAL8Vector *directCoef; /**< The direct filter coefficients. */
REAL8Vector *recursCoef; /**< The recursive filter coefficients. */
REAL8Vector *history; /**< The previous values of w. */
} REAL8IIRFilter; } REAL8IIRFilter;
/* <lalLaTeX> /*@}*/
\vfill{\footnotesize\input{IIRFilterHV}}
</lalLaTeX> */
/* Function prototypes. */ /* Function prototypes. */
REAL4IIRFilter *XLALCreateREAL4IIRFilter( COMPLEX8ZPGFilter *input ); REAL4IIRFilter *XLALCreateREAL4IIRFilter( COMPLEX8ZPGFilter *input );
REAL8IIRFilter *XLALCreateREAL8IIRFilter( COMPLEX16ZPGFilter *input ); REAL8IIRFilter *XLALCreateREAL8IIRFilter( COMPLEX16ZPGFilter *input );
void XLALDestroyREAL4IIRFilter( REAL4IIRFilter *filter ); void XLALDestroyREAL4IIRFilter( REAL4IIRFilter *filter );
void XLALDestroyREAL8IIRFilter( REAL8IIRFilter *filter ); void XLALDestroyREAL8IIRFilter( REAL8IIRFilter *filter );
int XLALIIRFilterREAL4Vector( REAL4Vector *vector, REAL8IIRFilter *filter ) ; int XLALIIRFilterREAL4Vector( REAL4Vector *vector, REAL8IIRFilter *filter ) ;
int XLALIIRFilterREAL8Vector( REAL8Vector *vector, REAL8IIRFilter *filter ) ; int XLALIIRFilterREAL8Vector( REAL8Vector *vector, REAL8IIRFilter *filter ) ;
int XLALIIRFilterReverseREAL4Vector( REAL4Vector *vector, REAL8IIRFilter *f ilter ); int XLALIIRFilterReverseREAL4Vector( REAL4Vector *vector, REAL8IIRFilter *f ilter );
int XLALIIRFilterReverseREAL8Vector( REAL8Vector *vector, REAL8IIRFilter *f ilter ); int XLALIIRFilterReverseREAL8Vector( REAL8Vector *vector, REAL8IIRFilter *f ilter );
skipping to change at line 215 skipping to change at line 194
int XLALIIRFilterReverseREAL4Vector( REAL4Vector *vector, REAL8IIRFilter *f ilter ); int XLALIIRFilterReverseREAL4Vector( REAL4Vector *vector, REAL8IIRFilter *f ilter );
int XLALIIRFilterReverseREAL8Vector( REAL8Vector *vector, REAL8IIRFilter *f ilter ); int XLALIIRFilterReverseREAL8Vector( REAL8Vector *vector, REAL8IIRFilter *f ilter );
REAL4 XLALIIRFilterREAL4( REAL4 x, REAL8IIRFilter *filter ); REAL4 XLALIIRFilterREAL4( REAL4 x, REAL8IIRFilter *filter );
REAL8 XLALIIRFilterREAL8( REAL8 x, REAL8IIRFilter *filter ); REAL8 XLALIIRFilterREAL8( REAL8 x, REAL8IIRFilter *filter );
/* WARNING: THIS FUNCTION IS OBSOLETE */ /* WARNING: THIS FUNCTION IS OBSOLETE */
REAL4 LALSIIRFilter( REAL4 x, REAL4IIRFilter *filter ); REAL4 LALSIIRFilter( REAL4 x, REAL4IIRFilter *filter );
/* REAL8 LALDIIRFilter( REAL8 x, REAL8IIRFilter *filter ); */ /* REAL8 LALDIIRFilter( REAL8 x, REAL8IIRFilter *filter ); */
#define LALDIIRFilter(x,f) XLALIIRFilterREAL8(x,f) #define LALDIIRFilter(x,f) XLALIIRFilterREAL8(x,f)
/* <lalLaTeX> /* ----- CreateIIRFilter.c ---------- */
\newpage\input{CreateIIRFilterC}
</lalLaTeX> */
void void
LALCreateREAL4IIRFilter( LALStatus *status, LALCreateREAL4IIRFilter( LALStatus *status,
REAL4IIRFilter **output, REAL4IIRFilter **output,
COMPLEX8ZPGFilter *input ); COMPLEX8ZPGFilter *input );
void void
LALCreateREAL8IIRFilter( LALStatus *status, LALCreateREAL8IIRFilter( LALStatus *status,
REAL8IIRFilter **output, REAL8IIRFilter **output,
COMPLEX16ZPGFilter *input ); COMPLEX16ZPGFilter *input );
/* <lalLaTeX> /* ----- DestroyIIRFilter.c ---------- */
\newpage\input{DestroyIIRFilterC}
</lalLaTeX> */
void void
LALDestroyREAL4IIRFilter( LALStatus *status, LALDestroyREAL4IIRFilter( LALStatus *status,
REAL4IIRFilter **input ); REAL4IIRFilter **input );
void void
LALDestroyREAL8IIRFilter( LALStatus *status, LALDestroyREAL8IIRFilter( LALStatus *status,
REAL8IIRFilter **input ); REAL8IIRFilter **input );
/* <lalLaTeX> /* ----- IIRFilter.c ---------- */
\newpage\input{IIRFilterC}
</lalLaTeX> */
void void
LALIIRFilterREAL4( LALStatus *status, LALIIRFilterREAL4( LALStatus *status,
REAL4 *output, REAL4 *output,
REAL4 input, REAL4 input,
REAL4IIRFilter *filter ); REAL4IIRFilter *filter );
void void
LALIIRFilterREAL8( LALStatus *status, LALIIRFilterREAL8( LALStatus *status,
REAL8 *output, REAL8 *output,
REAL8 input, REAL8 input,
REAL8IIRFilter *filter ); REAL8IIRFilter *filter );
/* <lalLaTeX> /* ----- IIRFilterVector.c ---------- */
\newpage\input{IIRFilterVectorC}
</lalLaTeX> */
void void
LALIIRFilterREAL4Vector( LALStatus *status, LALIIRFilterREAL4Vector( LALStatus *status,
REAL4Vector *vector, REAL4Vector *vector,
REAL4IIRFilter *filter ); REAL4IIRFilter *filter );
void void
LALIIRFilterREAL8Vector( LALStatus *status, LALIIRFilterREAL8Vector( LALStatus *status,
REAL8Vector *vector, REAL8Vector *vector,
REAL8IIRFilter *filter ); REAL8IIRFilter *filter );
void void
LALDIIRFilterREAL4Vector( LALStatus *status, LALDIIRFilterREAL4Vector( LALStatus *status,
REAL4Vector *vector, REAL4Vector *vector,
REAL8IIRFilter *filter ); REAL8IIRFilter *filter );
/* <lalLaTeX> /* ----- IIRFilterVectorR.c ---------- */
\newpage\input{IIRFilterVectorRC}
</lalLaTeX> */
void void
LALIIRFilterREAL4VectorR( LALStatus *status, LALIIRFilterREAL4VectorR( LALStatus *status,
REAL4Vector *vector, REAL4Vector *vector,
REAL4IIRFilter *filter ); REAL4IIRFilter *filter );
void void
LALIIRFilterREAL8VectorR( LALStatus *status, LALIIRFilterREAL8VectorR( LALStatus *status,
REAL8Vector *vector, REAL8Vector *vector,
REAL8IIRFilter *filter ); REAL8IIRFilter *filter );
void void
LALDIIRFilterREAL4VectorR( LALStatus *status, LALDIIRFilterREAL4VectorR( LALStatus *status,
REAL4Vector *vector, REAL4Vector *vector,
REAL8IIRFilter *filter ); REAL8IIRFilter *filter );
/* <lalLaTeX>
\newpage\input{IIRFilterTestC}
</lalLaTeX> */
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _IIRFILTER_H */ #endif /* _IIRFILTER_H */
 End of changes. 38 change blocks. 
135 lines changed or deleted 112 lines changed or added


 Inject.h   Inject.h 
skipping to change at line 32 skipping to change at line 32
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/Random.h> #include <lal/Random.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#elif 0 #elif 0
} /* so that editors will match preceding brace */ } /* so that editors will match preceding brace */
#endif #endif
NRCSID( INJECTH, "$Id$" );
/** /**
\author Creighton, T. D. \author Creighton, T. D.
\addtogroup Inject_h \addtogroup Inject_h
\brief Provides routines to inject a signal into detector output. \brief Provides routines to inject a signal into detector output.
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/Inject.h> #include <lal/Inject.h>
\endcode \endcode
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 Integrate.h   Integrate.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
*/ */
#if 0 /* autodoc block */
<lalVerbatim file="IntegrateHV">
$Id$
</lalVerbatim>
<lalLaTeX>
\section{Header \texttt{Integrate.h}}
\label{s:Integrate.h}
Integrates a function.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/Integrate.h>
\end{verbatim}
\noindent This header covers the routines for integrating a function.
</lalLaTeX>
#endif /* autodoc block */
#ifndef _INTEGRATE_H #ifndef _INTEGRATE_H
#define _INTEGRATE_H #define _INTEGRATE_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (INTEGRATEH, "$Id$"); /**
\addtogroup Integrate_h
#if 0 /* autodoc block */
<lalLaTeX>
\subsection*{Error conditions}
\input{IntegrateHErrTab}
</lalLaTeX>
<lalErrTable file="IntegrateHErrTab"> \brief Integrates a function.
#endif /* autodoc block */ \heading{Synopsis}
\code
#include <lal/Integrate.h>
\endcode
#define INTEGRATEH_ENULL 1 This header covers the routines for integrating a function.
#define INTEGRATEH_ETYPE 2
#define INTEGRATEH_EIDOM 4
#define INTEGRATEH_EMXIT 8
#define INTEGRATEH_MSGENULL "Null pointer" \heading{Description}
#define INTEGRATEH_MSGETYPE "Unknown integral type"
#define INTEGRATEH_MSGEIDOM "Invalid domain"
#define INTEGRATEH_MSGEMXIT "Maximum iterations exceeded"
#if 0 /* autodoc block */ The routine \c LALSRombergIntegrate() performs the integral specified by th
e
structure \c input and the result is returned as \c result. Any
additional parameters (other than the integration variable \f$x\f$) can be
passed
as \c params. The routine \c LALSRombergIntegrate() does not use
\c params but just passes it to the integrand. The routine
\c LALDRombergIntegrate() is the same but for double precision.
</lalErrTable> \heading{Operating Instructions}
<lalLaTeX> The following program performs the integral \f$\int_0^2F(x)dx\f$ where
\f$F(x)=x^4\log(x+\sqrt{x^2+1})\f$.
\subsection*{Structures} \code
#include <math.h>
#include <lal/LALStdlib.h>
#include <lal/Integrate.h>
\begin{verbatim} static void F( LALStatus *s, REAL4 *y, REAL4 x, void *p )
typedef enum
{ {
ClosedInterval, REAL4 x2 = x*x;
OpenInterval, REAL4 x4 = x2*x2;
SingularLowerLimit, INITSTATUS(s);
SingularUpperLimit, ASSERT( !p, s, 1, "Non-null pointer" );
InfiniteDomainPow, *y = x4 * log( x + sqrt( x2 + 1 ) );
InfiniteDomainExp RETURN( s );
} }
IntegralType;
typedef struct int main ()
tagSIntegrateIn
{ {
void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); const REAL4 epsilon = 1e-6;
REAL4 xmax; const long double expect = 8.153364119811650205L;
REAL4 xmin; static LALStatus status;
IntegralType type; SIntegrateIn intinp;
} REAL4 result;
SIntegrateIn;
typedef struct intinp.function = F;
tagDIntegrateIn intinp.xmin = 0;
{ intinp.xmax = 2;
void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); intinp.type = ClosedInterval;
REAL8 xmax;
REAL8 xmin; LALSRombergIntegrate( &status, &result, &intinp, NULL );
IntegralType type; if ( fabs( result - expect ) > epsilon * fabs( expect ) )
{
// integration did not achieve desired accuracy --- exit failure
return 1;
}
return 0;
} }
DIntegrateIn; \endcode
\end{verbatim}
These are input structures to the integration routines. The fields are: \heading{Algorithm}
\begin{description}
\item[\texttt{function}] The function to integrate.
\item[\texttt{xmax}] The maximum value of the domain of integration.
\item[\texttt{xmax}] The minimum value of the domain of integration.
\item[\texttt{type}] The type of integration. This is an enumerated type
which can take on one of the following values:
\noindent This is an implementation of the Romberg integrating function \c qromb in
\begin{tabular}{|l|l|} Numerical Recipes [\ref ptvf1992].
\hline
Enumeration constant & Meaning \\
\hline
\verb+ClosedInterval+ & Evaluate integral on a closed interval \\
\verb+OpenInterval+ & Evaluate integral on an open interval \\
\verb+SingularLowerLimit+ & Integrate an inverse square-root singularity
at lower limit \\
\verb+SingularUpperLimit+ & Integrate an inverse square-root singularity
at upper limit \\
\verb+InfiniteDomainPow+ & Integrate an infinite domain with power-law f
alloff \\
\verb+InfiniteDomainExp+ & Integrate an infinite domain with exponential
falloff \\
\hline
\end{tabular}
\noindent */
The types of integration are the following: I.\@ \verb+ClosedInterval+ /*@{*/
/** \name Error Codes */
/*@{*/
#define INTEGRATEH_ENULL 1 /**< Null pointer */
#define INTEGRATEH_ETYPE 2 /**< Unknown integral type */
#define INTEGRATEH_EIDOM 4 /**< Invalid domain */
#define INTEGRATEH_EMXIT 8 /**< Maximum iterations exceeded */
/*@}*/
/** \cond DONT_DOXYGEN */
#define INTEGRATEH_MSGENULL "Null pointer"
#define INTEGRATEH_MSGETYPE "Unknown integral type"
#define INTEGRATEH_MSGEIDOM "Invalid domain"
#define INTEGRATEH_MSGEMXIT "Maximum iterations exceeded"
/** \endcond */
/** Type of integral.
The types of integration are the following:
I. \c #ClosedInterval
indicates that the integral should be computed on equal-spaced domain indicates that the integral should be computed on equal-spaced domain
intervals including the boundary. II.\@ \verb+OpenInterval+ indicates th intervals including the boundary.
at
II. \c #OpenInterval indicates that
the integral should be computed on intervals of the domain not including the the integral should be computed on intervals of the domain not including the
boundary. III.\@ \verb+SingularLowerLimit+ indicates that the integral boundary.
III. \c #SingularLowerLimit indicates that the integral
should be evaluated on an open interval with a transformation so that a should be evaluated on an open interval with a transformation so that a
inverse-square-root singularity at the lower limit can be integrated. IV inverse-square-root singularity at the lower limit can be integrated.
.\@
\verb+SingularUpperLimit+ is the same as above but for a singularity at t
he
upper limit. V.\@ \verb+InfiniteDomainPow+ indicates that the integral
should be evaluated over an semi-infinite domain---appropriate when both
limits have the same sign (though one is very large) and when the integra
nd
vanishes faster than $x^{-1}$ at infinity. VI.\@ \verb+InfiniteDomainExp
+
indicates that the integral should be evaluated over an infinite domain
starting at \verb+xmin+ and going to infinity (\verb+xmax+ is ignored)---
the
integrand should vanish exponentially for large $x$.
\end{description}
</lalLaTeX> IV. \c #SingularUpperLimit is the same as above but for a singularity at
the
upper limit.
#endif /* autodoc block */ V. \c #InfiniteDomainPow indicates that the integral
should be evaluated over an semi-infinite domain---appropriate when both
limits have the same sign (though one is very large) and when the integra
nd
vanishes faster than \f$x^{-1}\f$ at infinity.
VI. \c #InfiniteDomainExp
indicates that the integral should be evaluated over an infinite domain
starting at \c xmin and going to infinity (\c xmax is ignored)---the
integrand should vanish exponentially for large \f$x\f$.
*/
typedef enum typedef enum
{ {
ClosedInterval, /* evaluate integral on a closed interval ClosedInterval, /**< evaluate integral on a closed interval
*/ */
OpenInterval, /* evaluate integral on an open interval OpenInterval, /**< evaluate integral on an open interval
*/ */
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 fallo
*/ ff */
} }
IntegralType; IntegralType;
/** These are input structures to the integration routines. */
typedef struct typedef struct
tagSIntegrateIn tagSIntegrateIn
{ {
SWIGLAL_STRUCT(SIntegrateIn); SWIGLAL_STRUCT(SIntegrateIn);
void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); void (*function)(LALStatus *s, REAL4 *y, REAL4 x, void *p); /**< The fu
REAL4 xmax; nction to integrate */
REAL4 xmin; REAL4 xmax; /**< The maximum value of the domain of integration
IntegralType type; */
REAL4 xmin; /**< The minimum value of the domain of integration
*/
IntegralType type; /**< The type of integration */
} }
SIntegrateIn; SIntegrateIn;
/** These are input structures to the integration routines. */
typedef struct typedef struct
tagDIntegrateIn tagDIntegrateIn
{ {
SWIGLAL_STRUCT(DIntegrateIn); SWIGLAL_STRUCT(DIntegrateIn);
void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); void (*function)(LALStatus *s, REAL8 *y, REAL8 x, void *p); /**< The fu
REAL8 xmax; nction to integrate */
REAL8 xmin; REAL8 xmax; /**< The maximum value of the domain of integration
IntegralType type; */
REAL8 xmin; /**< The minimum value of the domain of integration
*/
IntegralType type; /**< The type of integration */
} }
DIntegrateIn; DIntegrateIn;
#if 0 /* autodoc block */ /* ----- Integrate.c ----- */
/** \see See \ref Integrate_h for documentation */
<lalLaTeX>
\newpage\input{IntegrateC}
</lalLaTeX>
#endif /* autodoc block */
void void
LALSRombergIntegrate ( LALSRombergIntegrate (
LALStatus *status, LALStatus *status,
REAL4 *result, REAL4 *result,
SIntegrateIn *input, SIntegrateIn *input,
void *params void *params
); );
/** \see See \ref Integrate_h for documentation */
void void
LALDRombergIntegrate ( LALDRombergIntegrate (
LALStatus *status, LALStatus *status,
REAL8 *result, REAL8 *result,
DIntegrateIn *input, DIntegrateIn *input,
void *params void *params
); );
/** \see See \ref Integrate_h for documentation */
REAL8 REAL8
XLALREAL8RombergIntegrate ( XLALREAL8RombergIntegrate (
REAL8 (*f)(REAL8 x, void *params), REAL8 (*f)(REAL8 x, void *params),
void *params, void *params,
REAL8 xmin, REAL8 xmin,
REAL8 xmax, REAL8 xmax,
IntegralType type IntegralType type
); );
#if 0 /* autodoc block */ /*@}*/
<lalLaTeX>
\newpage\input{IntegrateTestC}
</lalLaTeX>
#endif /* autodoc block */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _INTEGRATE_H */ #endif /* _INTEGRATE_H */
 End of changes. 35 change blocks. 
153 lines changed or deleted 129 lines changed or added


 Interpolate.h   Interpolate.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
*/ */
#if 0 /* autodoc block */
<lalVerbatim file="InterpolateHV">
$Id$
</lalVerbatim>
<lalLaTeX>
\section{Header \texttt{Interpolate.h}}
\label{s:Interpolate.h}
Generates random numbers.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/Interpolate.h>
\end{verbatim}
\noindent This header covers the routines for interpolation.
</lalLaTeX>
#endif /* autodoc block */
#ifndef _INTERPOLATE_H #ifndef _INTERPOLATE_H
#define _INTERPOLATE_H #define _INTERPOLATE_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (INTERPOLATEH, "$Id: Interpolate.h"); /**
\addtogroup Interpolate_h
#if 0 /* autodoc block */
<lalLaTeX>
\subsection*{Error conditions}
\input{InterpolateHErrTab}
</lalLaTeX>
<lalErrTable file="InterpolateHErrTab">
#endif /* autodoc block */
#define INTERPOLATEH_ENULL 1 \brief This header covers the routines for interpolation.
#define INTERPOLATEH_ESIZE 2
#define INTERPOLATEH_EZERO 4
#define INTERPOLATEH_MSGENULL "Null pointer" \heading{Synopsis}
#define INTERPOLATEH_MSGESIZE "Invalid size" \code
#define INTERPOLATEH_MSGEZERO "Zero divide" #include <lal/Interpolate.h>
\endcode
#if 0 /* autodoc block */ \heading{Description}
</lalErrTable> The routine <tt>LALSPolynomialInterpolation()</tt> computes the interpolate
d \f$y\f$
value \c output at the \f$x\f$ value \c target by fitting a polynomial of
order <tt>params.n-1</tt> to the data. The result \c output is of type
\c SInterpolateOut, which contains the value <tt>output.y</tt> as well as
an estimate of the error <tt>output.dy</tt>. The routine
<tt>LALDPolynomialInterpolation()</tt> is the same but for double precision
.
<lalLaTeX> \heading{Operating Instructions}
\subsection*{Structures} The following program fits a fourth-order polynomial to the five data point
s
\f$\{(0,0),(1,1),(2,3),(3,4),(4,3)\}\f$, and interpolates the value at \f$x
=2.4\f$.
\begin{verbatim} \code
typedef struct #include <lal/LALStdlib.h>
tagSInterpolateOut #include <lal/Interpolate.h>
{
REAL4 y;
REAL4 dy;
}
SInterpolateOut;
typedef struct int main ()
tagDInterpolateOut
{ {
REAL8 y; enum { ArraySize = 5 };
REAL8 dy; static LALStatus status;
} REAL4 x[ArraySize] = {0,1,2,3,4};
DInterpolateOut; REAL4 y[ArraySize] = {0,1,3,4,3};
\end{verbatim} REAL4 target = 2.4;
SInterpolatePar intpar = {ArraySize, x, y};
SInterpolateOut intout;
These structures contain the output of the interpolation. The two fields a LALSPolynomialInterpolation( &status, &intout, target, &intpar );
re:
\begin{description}
\item[\texttt{y}] The interpolated value.
\item[\texttt{dy}] The estimated error in the interpolated value.
\end{description}
\begin{verbatim} return 0;
typedef struct
tagSInterpolatePar
{
UINT4 n;
REAL4 *x;
REAL4 *y;
} }
SInterpolatePar; \endcode
typedef struct \heading{Algorithm}
tagDInterpolatePar
{
UINT4 n;
REAL8 *x;
REAL8 *y;
}
DInterpolatePar;
\end{verbatim}
These structures contain the interpolation parameters. These are the array This is an implementation of the Neville algroithm, see \c polint in
s Numerical Recipes [\ref ptvf1992].
of \verb+n+ domain values \verb+x[0]+\ldots\verb+x[n-1]+ and their
corresponding values \verb+y[0]+\ldots\verb+y[n-1]+. The fields are:
\begin{description}
\item[\texttt{n}] The number of points in the arrays to use in the
interpolation.
\item[\texttt{x}] The array of domain values.
\item[\texttt{y}] The array of values to interpolate.
\end{description}
</lalLaTeX> */
/*@{*/
#endif /* autodoc block */ /** \name Error Codes */
/*@{*/
#define INTERPOLATEH_ENULL 1 /**< Null pointer */
#define INTERPOLATEH_ESIZE 2 /**< Invalid size */
#define INTERPOLATEH_EZERO 4 /**< Zero divide */
/*@}*/
/** \cond DONT_DOXYGEN */
#define INTERPOLATEH_MSGENULL "Null pointer"
#define INTERPOLATEH_MSGESIZE "Invalid size"
#define INTERPOLATEH_MSGEZERO "Zero divide"
/** \endcond */
/** These structures contain the output of the interpolation */
typedef struct typedef struct
tagSInterpolateOut tagSInterpolateOut
{ {
SWIGLAL_STRUCT(SInterpolateOut); SWIGLAL_STRUCT(SInterpolateOut);
REAL4 y; REAL4 y; /**< The interpolated value */
REAL4 dy; REAL4 dy; /**< The estimated error in the interpolated value */
} }
SInterpolateOut; SInterpolateOut;
/** These structures contain the output of the interpolation */
typedef struct typedef struct
tagDInterpolateOut tagDInterpolateOut
{ {
SWIGLAL_STRUCT(DInterpolateOut); SWIGLAL_STRUCT(DInterpolateOut);
REAL8 y; REAL8 y; /**< The interpolated value */
REAL8 dy; REAL8 dy; /**< The estimated error in the interpolated value */
} }
DInterpolateOut; DInterpolateOut;
/** These structures contain the interpolation parameters; These are the ar
rays
* of \c n domain values \f$x[0] \ldots x[n-1]\f$ and their
* corresponding values \f$y[0] \ldots y[n-1]\f$
*/
typedef struct typedef struct
tagSInterpolatePar tagSInterpolatePar
{ {
SWIGLAL_STRUCT(SInterpolatePar); SWIGLAL_STRUCT(SInterpolatePar);
UINT4 n; UINT4 n; /**< The number of points in the arrays to use in the interp
REAL4 *x; olation */
REAL4 *y; REAL4 *x; /**< The array of domain values */
REAL4 *y; /**< The array of values to interpolate */
} }
SInterpolatePar; SInterpolatePar;
/** These structures contain the interpolation parameters; These are the ar
rays
* of \c n domain values \f$x[0]\ldotsx[n-1]\f$ and their
* corresponding values \f$y[0]\ldotsy[n-1]\f$
*/
typedef struct typedef struct
tagDInterpolatePar tagDInterpolatePar
{ {
SWIGLAL_STRUCT(DInterpolatePar); SWIGLAL_STRUCT(DInterpolatePar);
UINT4 n; UINT4 n; /**< The number of points in the arrays to use in the interp
REAL8 *x; olation */
REAL8 *y; REAL8 *x; /**< The array of domain values */
REAL8 *y; /**< The array of values to interpolate */
} }
DInterpolatePar; DInterpolatePar;
#if 0 /* autodoc block */ /* ----- Interpolate.c ----- */
/** \see See \ref Interpolate_h for documentation */
<lalLaTeX>
\newpage\input{InterpolateC}
</lalLaTeX>
#endif /* autodoc block */
void void
LALSPolynomialInterpolation ( LALSPolynomialInterpolation (
LALStatus *status, LALStatus *status,
SInterpolateOut *output, SInterpolateOut *output,
REAL4 target, REAL4 target,
SInterpolatePar *params SInterpolatePar *params
); );
/** \see See \ref Interpolate_h for documentation */
void void
LALDPolynomialInterpolation ( LALDPolynomialInterpolation (
LALStatus *status, LALStatus *status,
DInterpolateOut *output, DInterpolateOut *output,
REAL8 target, REAL8 target,
DInterpolatePar *params DInterpolatePar *params
); );
/** \see See \ref Interpolate_h for documentation */
REAL8 REAL8
XLALREAL8PolynomialInterpolation ( XLALREAL8PolynomialInterpolation (
REAL8 *yout, REAL8 *yout,
REAL8 xtarget, REAL8 xtarget,
REAL8 *y, REAL8 *y,
REAL8 *x, REAL8 *x,
UINT4 n UINT4 n
); );
#if 0 /* autodoc block */ /*@}*/
<lalLaTeX>
\newpage\input{InterpolateTestC}
</lalLaTeX>
#endif /* autodoc block */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _INTERPOLATE_H */ #endif /* _INTERPOLATE_H */
 End of changes. 30 change blocks. 
121 lines changed or deleted 81 lines changed or added


 LALAdaptiveRungeKutta4.h   LALAdaptiveRungeKutta4.h 
skipping to change at line 51 skipping to change at line 51
int (* dydt) (double t, const double y[], double dydt[], void * params); int (* dydt) (double t, const double y[], double dydt[], void * params);
int (* stop) (double t, const double y[], double dydt[], void * params); int (* stop) (double t, const double y[], double dydt[], void * params);
int retries; /* retries with smaller step when derivatives encoun ter singularity */ int retries; /* retries with smaller step when derivatives encoun ter singularity */
int stopontestonly; /* stop only on test, use tend to size buffers only */ int stopontestonly; /* stop only on test, use tend to size buffers only */
int returncode; int returncode;
} ark4GSLIntegrator; } ark4GSLIntegrator;
/**
\c ark4GSLIntegrator
*/
ark4GSLIntegrator *XLALAdaptiveRungeKutta4Init( int dim, ark4GSLIntegrator *XLALAdaptiveRungeKutta4Init( int dim,
int (* dydt) (double t, const double y[], doub le dydt[], void * params), int (* dydt) (double t, const double y[], doub le dydt[], void * params),
int (* stop) (double t, const double y[], doub le dydt[], void * params), int (* stop) (double t, const double y[], doub le dydt[], void * params),
double eps_abs, double eps_rel double eps_abs, double eps_rel
); );
void XLALAdaptiveRungeKutta4Free( ark4GSLIntegrator *integrator ); void XLALAdaptiveRungeKutta4Free( ark4GSLIntegrator *integrator );
int XLALAdaptiveRungeKutta4( ark4GSLIntegrator *integrator, int XLALAdaptiveRungeKutta4( ark4GSLIntegrator *integrator,
void *params, void *params,
REAL8 *yinit, REAL8 *yinit,
REAL8 tinit, REAL8 tend, REAL8 deltat, REAL8 tinit, REAL8 tend, REAL8 deltat,
REAL8Array **yout REAL8Array **yout
); );
/**
* Fourth-order Runge-Kutta ODE integrator using Runge-Kutta-Fehlberg (RKF4
5)
* steps with adaptive step size control. Intended for use in various
* waveform generation routines such as SpinTaylorT4 and various EOB models
.
*
* The method is described in
*
* Abramowitz & Stegun, Handbook of Mathematical Functions, Tenth Printing,
* National Bureau of Standards, Washington, DC, 1972
* (available online at http://people.math.sfu.ca/~cbm/aands/ )
*
* This function also includes "on-the-fly" interpolation of the
* differential equations at regular intervals in-between integration
* steps. This "on-the-fly" interpolation method is derived and
* described in the Mathematica notebook "RKF_with_interpolation.nb";
* see
* https://www.lsc-group.phys.uwm.edu/ligovirgo/cbcnote/InspiralPipelineDev
elopment/120312111836InspiralPipelineDevelopmentImproved%20Adaptive%20Runge
-Kutta%20integrator
*
* This method is functionally equivalent to XLALAdaptiveRungeKutta4,
* but is nearly always faster due to the improved interpolation.
*/
int XLALAdaptiveRungeKutta4Hermite( ark4GSLIntegrator *integrator, /**< str
uct holding dydt, stopping test, stepper, etc. */
void *params, /**< params struct used t
o compute dydt and stopping test */
REAL8 *yinit, /**< pass in initial valu
es of all variables - overwritten to final values */
REAL8 tinit, /**< integration start tim
e */
REAL8 tend_in, /**< maximum integration
time */
REAL8 deltat, /**< step size for evenly
sampled output */
REAL8Array **yout /**< array holding th
e evenly sampled output */
);
#if 0 #if 0
{ /* so that editors will match succeeding brace */ { /* so that editors will match succeeding brace */
#elif defined(__cplusplus) #elif defined(__cplusplus)
} }
#endif #endif
#endif /* _LALADAPTIVERUNGEKUTTA4_H */ #endif /* _LALADAPTIVERUNGEKUTTA4_H */
 End of changes. 2 change blocks. 
3 lines changed or deleted 40 lines changed or added


 LALAtomicDatatypes.h   LALAtomicDatatypes.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 // ---------- SEE LALDatatypes.dox for doxygen documentation ----------
* \ingroup std
* \author Creighton, J. D. E., and Creighton, T. D.
* \date $Id$
* \brief The primative LAL datatypes.
*
* This header defines the primative LAL datatypes. These datatypes
* are: CHAR, INT2, INT4, INT8 (signed integer types); UCHAR, UINT2
* UINT4, UINT8 (unsigned integer types); REAL4, REAL8 (single- and
* double-precision floating point types); and COMPLEX8 and COMPLEX16
* (single- and double-precision floating point complex types).
* Note that the complex types are implemented as structures. This is
* because LAL conforms to the C89 standard rather than the C99
* standard. The non-complex datatypes are known as <em>atomic</em>
* datatypes: these may be passed directly to functions or used as
* the return value of XLAL functions.
*
* The number in the name of each of these types (other than
* CHAR and UCHAR) is the number of 8-bit bytes that the datatype
* occupies. E.g., INT4 is a four-byte integer. In C99 it would be
* called <tt>int32_t</tt>. While the size of types such as <tt>int</tt> an
d
* <tt>long int</tt> are platform dependent, the sizes of INT4 and INT8
* is always 4- and 8-bytes respectively (platform independent).
* REAL4 and REAL8 are always type <tt>float</tt> and <tt>double</tt>
* but LAL is only supported on platforms in which these types conform
* to the IEEE 754 standard.
*
* This documentation shows how the datatypes are defined on today's
* most common (32-bit) platform. Be careful in particular about
* the integer type INT8. On 64-bit platforms it will usually be
* equivalent to type <tt>long int</tt> rather than type
* <tt>long long int</tt>.
*/
/*************************** <lalVerbatim file="LALAtomicDatatypesHV">
Author: J. D. E. Creighton, T. D. Creighton
$Id$
**************************** </lalVerbatim> */
/* <lalLaTeX>
\subsection{Primitive datatypes}
\label{ss:LALAtomicDatatypes.h}
The primitive datatypes are defined in a separate header
\verb@LALAtomicDatatypes.h@, which is included by
\verb@LALDatatypes.h@. This is done in order to facilitate the
interface between LAL and non-LAL modules. By including just
\verb@LALAtomicDatatypes.h@, a non-LAL module can ensure that it is
using the same arithmetic standard as LAL, without being burdened by
LAL's more specialized structures.
Primitive datatypes are those that conceptually store a single number
or quantity. They include both the \emph{atomic} datatypes and the
complex datatypes.
\subsubsection*{Atomic datatypes}
Atomic LAL datatypes are platform-independent datatypes corresponding
to the basic types in the C/C++ language. However, since the C/C++
types are not necessarily the same across platforms, the actual
mapping between LAL and C/C++ datatypes may be different on different
platforms. The following table lists the LAL atomic datatypes, their
size and range, and the C/C++ datatype to which they \emph{usually}
correspond.
\begin{center}
\begin{tabular}{|lccc|}
\hline
Type & Bytes & Range & Usual C/C++ type \\
\hline
\tt CHAR & 1 & \verb@'\0'@ to \verb@'\255'@ & \tt char \\
\tt UCHAR & 1 & \verb@'\0'@ to \verb@'\255'@ & \tt unsigned char \\
\tt BOOLEAN & 1 & 0 or positive & \tt unsigned char \\
\hline
\tt INT2 & 2 & $-2^{-15}$ to $2^{15}-1$ & \tt short \\
\tt INT4 & 4 & $-2^{-31}$ to $2^{31}-1$ & {\tt int} or
{\tt long} \\
\tt INT8 & 8 & $-2^{-63}$ to $2^{63}-1$ & \tt long long \\
\tt UINT2 & 2 & 0 to $2^{16}-1$ & \tt unsigned short \\
\tt UINT4 & 4 & 0 to $2^{32}-1$ & {\tt unsigned int} or
{\tt long} \\
\tt UINT8 & 8 & 0 to $2^{64}-1$ & \tt unsigned long long \\
\hline
\tt REAL4 & 4 & $-3.4\times10^{38}$ to $3.4\times10^{38}$ & \tt float
\\
\tt REAL8 & 8 & $-1.8\times10^{308}$ to $1.8\times10^{308}$ & \tt double
\\
\hline
\end{tabular}
\end{center}
The unsigned character and integer datatypes store their values
according to the usual binary system. For signed characters and
integers, setting the most-significant bit indicates that the number
formed from the remaining bits should be added to the lower value of
the range. The \verb@REAL4@ and \verb@REAL8@ datatypes should store
values according to the IEEE Standard 754 for Binary Floating-Point
Arithmetic, which gives them the following precisions and dynamic
ranges:
\begin{center}
\begin{tabular}{|l|cc|}
\hline
& \tt REAL4 & \tt REAL8
\\
\hline
Minimum positive subnormal & $1.4\times10^{-45}$ & $4.9\times10^{-324}$
\\
Minimum positive normal & $1.2\times10^{-38}$ & $2.2\times10^{-308}$
\\
Maximum finite normal & $3.4\times10^{38}$ & $1.8\times10^{308}$
\\
Minimum fractional difference & $6.0\times10^{-8}$ & $1.1\times10^{-16}$
\\
Significant decimal digits & 6--9 & 15--17
\\
\hline
\end{tabular}
\end{center}
The minimum positive subnormal is the smallest positive representable
number. The minimum positive normal is the smallest positive number
that can be represented with full precision; that is, one whose
mantissa lies in the range [0.5,1). The maximum finite normal is the
largest representable number other than the reserved code for
$+\infty$. The minimum fractional difference is the smallest
fractional difference between consecutive representable numbers, or
\emph{half} the difference between 1 and the next representable
number. Significant decimal digits gives the number of decimal digits
used to represent the binary number in decimal notation: the first is
the maximum number of digits that are guaranteed not to change upon
conversion to binary, the second is the number of digits required to
represent a unique binary quantity.
</lalLaTeX> */
/** \var typedef char CHAR
* \brief One-byte signed integer.
*/
/** \var typedef unsigned char UCHAR
* \brief One-byte unsigned integer.
*/
/** \var typedef short INT2
* \brief Two-byte signed integer.
*/
/** \var typedef short UINT2
* \brief Two-byte unsigned integer.
*/
/** \var typedef int INT4
* \brief Four-byte signed integer.
*/
/** \var typedef int UINT4
* \brief Four-byte unsigned integer.
*/
/** \var typedef long long INT8
* \brief Eight-byte signed integer.
*
* On some platforms this is equivalent to <tt>long int</tt> instead.
*/
/** \var typedef long long UINT8
* \brief Eight-byte unsigned integer.
*
* On some platforms this is equivalent to <tt>unsigned long int</tt> inste
ad.
*/
/** \var typedef float REAL4
* \brief Single precision real floating-point number (4 bytes).
*/
/** \var typedef double REAL8
* \brief Double precision real floating-point number (8 bytes).
*/
/** \def LAL_INT8_C(v) (v ## LL)
* \brief Macro for use in defining \a v as an INT8 constant.
*
* This macro affixes the appropriate qualifier to form an INT8 constant.
* For example:
* \code
* const INT8 jan_1_2000_gps_nanosec = LAL_INT8_C(63072001300000000)
* \endcode
*/
/** \def LAL_UINT8_C(v) (v ## ULL)
* \brief Macro for use in defining \a v as an UINT8 constant.
*
* This macro affixes the appropriate qualifier to form an UINT8 constant.
* For example:
* \code
* const UINT8 jan_1_2000_gps_nanosec = LAL_UINT8_C(63072001300000000)
* \endcode
*/
#ifndef _LALATOMICDATATYPES_H #ifndef _LALATOMICDATATYPES_H
#define _LALATOMICDATATYPES_H #define _LALATOMICDATATYPES_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef char CHAR; /** \addtogroup LALDatatypes */ /*@{*/
typedef unsigned char UCHAR;
typedef unsigned char BOOLEAN; typedef char CHAR; /**< One-byte signed integer, see \ref LALDa
tatypes for more details */
typedef unsigned char UCHAR; /**< One-byte unsigned integer, see \ref LAL
Datatypes for more details */
typedef unsigned char BOOLEAN; /**< Boolean logical type, see \ref LALDatat
ypes for more details */
#include <stdint.h> #include <stdint.h>
#ifndef LAL_USE_OLD_COMPLEX_STRUCTS
#if defined(__cplusplus)
#include <complex>
#else
#include <complex.h>
#endif
#endif /* LAL_USE_OLD_COMPLEX_STRUCTS */
#include <lal/LALConfig.h> #include <lal/LALConfig.h>
#include <lal/LALRCSID.h>
NRCSID( LALATOMICDATATYPESH, "$Id$" );
/* If INT8 etc. are already defined, undefine them */ /* If INT8 etc. are already defined, undefine them */
#undef CHAR #undef CHAR
#undef UCHAR #undef UCHAR
#undef INT2 #undef INT2
#undef INT4 #undef INT4
#undef INT8 #undef INT8
#undef UINT2 #undef UINT2
#undef UINT4 #undef UINT4
#undef UINT8 #undef UINT8
#undef REAL4 #undef REAL4
#undef REAL8 #undef REAL8
#undef COMPLEX8 #undef COMPLEX8
#undef COMPLEX16 #undef COMPLEX16
/* Integer types */ /* Integer types */
typedef int16_t INT2; typedef int16_t INT2; /**< Two-byte signed integer */
typedef int32_t INT4; typedef int32_t INT4; /**< Four-byte signed integer. */
typedef int64_t INT8; typedef int64_t INT8; /**< Eight-byte signed integer; on some plat
typedef uint16_t UINT2; forms this is equivalent to <tt>long int</tt> instead. */
typedef uint32_t UINT4; typedef uint16_t UINT2; /**< Two-byte unsigned integer. */
typedef uint64_t UINT8; typedef uint32_t UINT4; /**< Four-byte unsigned integer. */
typedef uint64_t UINT8; /**< Eight-byte unsigned integer; on
some platforms this is equivalent to <tt>unsigned long int</tt> instead. *
/
/* Macros for integer constants */ /* Macros for integer constants */
/** \def LAL_INT8_C(v) (v ## LL)
* \brief Macro for use in defining \a v as an INT8 constant.
*
* This macro affixes the appropriate qualifier to form an INT8 constant.
* For example:
* \code
* const INT8 jan_1_2000_gps_nanosec = LAL_INT8_C(63072001300000000)
* \endcode
*/
#define LAL_INT8_C INT64_C #define LAL_INT8_C INT64_C
/** \def LAL_UINT8_C(v) (v ## ULL)
* \brief Macro for use in defining \a v as an UINT8 constant.
*
* This macro affixes the appropriate qualifier to form an UINT8 constant.
* For example:
* \code
* const UINT8 jan_1_2000_gps_nanosec = LAL_UINT8_C(63072001300000000)
* \endcode
*/
#define LAL_UINT8_C UINT64_C #define LAL_UINT8_C UINT64_C
/* Real types */ /* Real types */
typedef float REAL4; typedef float REAL4; /**< Single precision real floating-point number (4
typedef double REAL8; bytes). */
typedef double REAL8; /**< Double precision real floating-point number (8
bytes). */
/* <lalLaTeX> #ifndef SWIG /* exclude from SWIG interface */
\subsubsection*{Complex datatypes} #ifndef LAL_USE_OLD_COMPLEX_STRUCTS
LAL represents complex numbers as structures with two floating-point /* Complex types */
fields, storing the real and imaginary parts. These are considered #if defined(__cplusplus)
primitive datatypes (rather than aggregate or structured datatypes) typedef std::complex<float> COMPLEX8;
because they conceptually represent a single number. Furthermore, typedef std::complex<double> COMPLEX16;
atomic and complex datatypes are treated equivalently by LAL aggregate #else
and structured datatypes. typedef float complex COMPLEX8;
typedef double complex COMPLEX16;
#endif
\vspace{1ex} /** \cond DONT_DOXYGEN */
\begin{verbatim} /* Complex type constructors */
COMPLEX8 #if defined(__cplusplus)
\end{verbatim} #define CX8rect( re, im) COMPLEX8( re, im )
This structure stores a single-precision complex number in 8~bytes of #define CX16rect(re, im) COMPLEX16( re, im )
memory. The fields are: #define CX8polar( r, th) ( (r) * std::exp( CX8rect( 0, th ) ) )
\begin{description} #define CX16polar(r, th) ( (r) * std::exp( CX16rect( 0, th ) ) )
\item[\texttt{REAL4 re}] The real part. #else
\item[\texttt{REAL4 im}] The imaginary part. #define CX8rect( re, im) ( (re) + _Complex_I * (im) )
\end{description} #define CX16rect(re, im) ( (re) + _Complex_I * (im) )
#define CX8polar( r, th) ( (r) * cexpf( CX8rect( 0, th ) ) )
#define CX16polar(r, th) ( (r) * cexp( CX16rect( 0, th ) ) )
#endif
\vspace{1ex} /* Real and imaginary part accessors */
\begin{verbatim} #if defined(__cplusplus)
COMPLEX16 #define CX8re( z) std::real(z)
\end{verbatim} #define CX16re(z) std::real(z)
This structure stores a double-precision complex number in 16~bytes of #define CX8im( z) std::imag(z)
memory. The fields are: #define CX16im(z) std::imag(z)
\begin{description} #else
\item[\texttt{REAL8 re}] The real part. #define CX8re( z) crealf(z)
\item[\texttt{REAL8 im}] The imaginary part. #define CX16re(z) creal( z)
\end{description} #define CX8im( z) cimagf(z)
#define CX16im(z) cimag( z)
#endif
</lalLaTeX> */ /* Real and imaginary part assignment */
#if !defined(__cplusplus) && defined(__GNUC__)
#define setCX8re( z, re) ( __real__(z) = (re) )
#define setCX16re(z, re) ( __real__(z) = (re) )
#define setCX8im( z, im) ( __imag__(z) = (im) )
#define setCX16im(z, im) ( __imag__(z) = (im) )
#else
#define setCX8re( z, re) ( (z) = CX8rect( re, CX8im( z) ) )
#define setCX16re(z, re) ( (z) = CX16rect( re, CX16im(z) ) )
#define setCX8im( z, im) ( (z) = CX8rect( CX8re( z), im ) )
#define setCX16im(z, im) ( (z) = CX16rect( CX16re(z), im ) )
#endif
/** \endcond */
#else /* LAL_USE_OLD_COMPLEX_STRUCTS */
/** 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> #endif /* LAL_USE_OLD_COMPLEX_STRUCTS */
\vfill{\footnotesize\input{LALAtomicDatatypesHV}}
</lalLaTeX> */ /*@}*/
#endif /* SWIG */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _LALATOMICDATATYPES_H */ #endif /* _LALATOMICDATATYPES_H */
 End of changes. 19 change blocks. 
240 lines changed or deleted 106 lines changed or added


 LALBarycenter.h   LALBarycenter.h 
skipping to change at line 39 skipping to change at line 39
#include <math.h> #include <math.h>
#include <lal/LALStdio.h> #include <lal/LALStdio.h>
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
#include <lal/LALConstants.h> #include <lal/LALConstants.h>
#include <lal/DetectorSite.h> #include <lal/DetectorSite.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/** \cond DONT_DOXYGEN */
NRCSID (LALBARYCENTERH,"$Id$");
/** \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_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"
 End of changes. 1 change blocks. 
4 lines changed or deleted 0 lines changed or added


 LALCache.h   LALCache.h 
skipping to change at line 44 skipping to change at line 44
#endif #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$" );
/** An entry in a LAL cache */ /** An entry in a LAL cache */
typedef struct tagLALCacheEntry { typedef struct tagLALCacheEntry {
SWIGLAL_STRUCT(LALCacheEntry); SWIGLAL_STRUCT(LALCacheEntry);
CHAR *src; /**< File source field */ CHAR *src; /**< File source field */
CHAR *dsc; /**< File description field */ CHAR *dsc; /**< File description field */
INT4 t0; /**< GPS time (seconds) of beginning of data in file */ 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;
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 LALCalibration.h   LALCalibration.h 
skipping to change at line 30 skipping to change at line 30
#ifndef _LALCALIBRATION_H #ifndef _LALCALIBRATION_H
#define _LALCALIBRATION_H #define _LALCALIBRATION_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALDatatypes.h> #include <lal/LALDatatypes.h>
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); SWIGLAL_STRUCT(LALCalData);
REAL4TimeSeries *cavityFactors; REAL4TimeSeries *cavityFactors;
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 LALComplex.h   LALComplex.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 _LALCOMPLEX_H #ifndef _LALCOMPLEX_H
#define _LALCOMPLEX_H #define _LALCOMPLEX_H
/* include only if using old LAL complex struct types */
#ifdef LAL_USE_OLD_COMPLEX_STRUCTS
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#include <lal/LALAtomicDatatypes.h> #include <lal/LALAtomicDatatypes.h>
NRCSID (LALCOMPLEXH,"$Id$");
#ifdef LAL_USE_COMPLEX_SHORT_MACROS #ifdef LAL_USE_COMPLEX_SHORT_MACROS
#if defined __COMPLEX__ || defined _COMPLEX_H #if defined __COMPLEX__ || defined _COMPLEX_H
#error "don't use both <complex.h> and LAL_USE_SHORT_MACROS" #error "don't use both <complex.h> and LAL_USE_SHORT_MACROS"
#endif #endif
#endif #endif
#ifdef LAL_NO_COMPLEX_MACROS #ifdef LAL_NO_COMPLEX_MACROS
#undef LAL_USE_COMPLEX_MACROS #undef LAL_USE_COMPLEX_MACROS
#undef LAL_USE_COMPLEX_SHORT_MACROS #undef LAL_USE_COMPLEX_SHORT_MACROS
#else #else
skipping to change at line 549 skipping to change at line 550
#define catanhf(a) (XLALCOMPLEX8Arctanh(a)) #define catanhf(a) (XLALCOMPLEX8Arctanh(a))
#define catanhrf(x) (XLALCOMPLEX8ArctanhReal(x)) #define catanhrf(x) (XLALCOMPLEX8ArctanhReal(x))
#define cacothf(a) (XLALCOMPLEX8Arccoth(a)) #define cacothf(a) (XLALCOMPLEX8Arccoth(a))
#endif #endif
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* LAL_USE_OLD_COMPLEX_STRUCTS */
#endif /* _LALCOMPLEX8_H */ #endif /* _LALCOMPLEX8_H */
 End of changes. 3 change blocks. 
2 lines changed or deleted 5 lines changed or added


 LALConfig.h   LALConfig.h 
/* include/lal/LALConfig.h. Generated from LALConfig.h.in by configure. * / /* include/lal/LALConfig.h. Generated from LALConfig.h.in by configure. * /
/* only include this file if LAL's config.h has not been included */ /* only include this file if LAL's config.h has not been included */
/* $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.6.2" #define LAL_VERSION "6.7.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 6 #define LAL_VERSION_MINOR 7
/* LAL Version Micro Number */ /* LAL Version Micro Number */
#define LAL_VERSION_MICRO 2 #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.6.2' '--exec-prefix=/home/andrey/upstream-tracker /testing/lal/6.6.2' '--sysconfdir=/home/andrey/upstream-tracker/testing/lal /6.6.2' '--datadir=/home/andrey/upstream-tracker/testing/lal/6.6.2' 'CFLAGS =-w -fpermissive' 'CXXFLAGS=-w -fpermissive'" #define LAL_CONFIGURE_ARGS " '--enable-shared' '--prefix=/home/andrey/upstr eam-tracker/testing/lal/6.7.0' '--exec-prefix=/home/andrey/upstream-tracker /testing/lal/6.7.0' '--sysconfdir=/home/andrey/upstream-tracker/testing/lal /6.7.0' '--datadir=/home/andrey/upstream-tracker/testing/lal/6.7.0' 'CFLAGS =-w -fpermissive' 'CXXFLAGS=-w -fpermissive'"
/* LAL Configure Date */ /* LAL Configure Date */
#define LAL_CONFIGURE_DATE "2012-05-12T12:08:09+0400" #define LAL_CONFIGURE_DATE "2012-05-12T12:05:59+0400"
/* LAL Install Prefix */ /* LAL Install Prefix */
#define LAL_PREFIX "/usr/local" #define LAL_PREFIX "/usr/local"
/* Suppress debugging code */ /* Suppress debugging code */
/* #undef LAL_NDEBUG */ /* #undef LAL_NDEBUG */
/* Use functions rather than macros */ /* Use functions rather than macros */
/* #undef NOLALMACROS */ /* #undef NOLALMACROS */
/* Use pthread mutex lock for threadsafety */ /* Use pthread mutex lock for threadsafety */
/* #undef LAL_PTHREAD_LOCK */ /* #undef LAL_PTHREAD_LOCK */
/* Define if using fftw3 library */ /* Define if using fftw3 library */
#define LAL_FFTW3_ENABLED 1 #define LAL_FFTW3_ENABLED 1
/* Define if using boinc library */ /* Define if using boinc library */
/* #undef LAL_BOINC_ENABLED */ /* #undef LAL_BOINC_ENABLED */
/* Define if using CUDA library */
/* #undef LAL_CUDA_ENABLED */
/* Define if using qthread library */ /* Define if using qthread library */
/* #undef LAL_QTHREAD */ /* #undef LAL_QTHREAD */
#endif /* _LALCONFIG_H */ #endif /* _LALCONFIG_H */
#endif /* CONFIG_H__LAL */ #endif /* CONFIG_H__LAL */
 End of changes. 7 change blocks. 
6 lines changed or deleted 8 lines changed or added


 LALConstants.h   LALConstants.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 * \addtogroup LALConstants_h
* \author Creighton, T. D. * \author Creighton, T. D.
* \date $Id$
* \brief Provides standard numerical constants for LAL. * \brief Provides standard numerical constants for LAL.
* *
* This header defines a number of useful numerical constants * This header defines a number of useful numerical constants
* for use in LAL routines. These constants come in three basic * for use in LAL routines. These constants come in three basic
* flavours: arithmetic and mathematical constants, fundamental (or * flavours: arithmetic and mathematical constants, fundamental (or
* defined) physical constants, and measured astrophysical and * defined) physical constants, and measured astrophysical and
* cosmological parameters. * cosmological parameters.
* *
* Note that this header is not included automatically by the header * Note that this header is not included automatically by the header
* <tt>LALStdlib.h</tt>. Include it explicitly if you need any of these * <tt>LALStdlib.h</tt>. Include it explicitly if you need any of these
* constants. * constants.
*/ */
/*@{*/
/********************************* <lalVerbatim file="LALConstantsHV">
Author: Creighton, T. D.
$Id$
********************************** </lalVerbatim> */
/* <lalLaTeX>
\section{Header \texttt{LALConstants.h}}
\label{s:LALConstants.h}
Provides standard numerical constants for LAL.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/LALConstants.h>
\end{verbatim}
\noindent This header defines a number of useful numerical constants
for use in LAL routines. These constants come in three basic
flavours: arithmetic and mathematical constants, fundamental (or
defined) physical constants, and measured astrophysical and
cosmological parameters.
Note that, unlike the other headers in the \verb@std@ package, this
header is \emph{not} included automatically by the header
\verb@LALStdlib.h@. Include it explicitly if you need any of these
constants.
</lalLaTeX> */
#ifndef _LALCONSTANTS_H #ifndef _LALCONSTANTS_H
#define _LALCONSTANTS_H #define _LALCONSTANTS_H
#include <lal/LALRCSID.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (LALCONSTANTSH, "$Id$");
/* <lalLaTeX>
\subsection*{Mathematical constants}
\idx[Constant]{LAL\_REAL4\_MANT}
\idx[Constant]{LAL\_REAL4\_MAX}
\idx[Constant]{LAL\_REAL4\_MIN}
\idx[Constant]{LAL\_REAL4\_EPS}
\idx[Constant]{LAL\_REAL8\_MANT}
\idx[Constant]{LAL\_REAL8\_MAX}
\idx[Constant]{LAL\_REAL8\_MIN}
\idx[Constant]{LAL\_REAL8\_EPS}
\idx[Constant]{LAL\_E}
\idx[Constant]{LAL\_LOG2E}
\idx[Constant]{LAL\_LOG10E}
\idx[Constant]{LAL\_LN2}
\idx[Constant]{LAL\_LN10}
\idx[Constant]{LAL\_SQRT2}
\idx[Constant]{LAL\_SQRT1\_2}
\idx[Constant]{LAL\_GAMMA}
\idx[Constant]{LAL\_PI}
\idx[Constant]{LAL\_TWOPI}
\idx[Constant]{LAL\_PI\_2}
\idx[Constant]{LAL\_PI\_4}
\idx[Constant]{LAL\_1\_PI}
\idx[Constant]{LAL\_2\_PI}
\idx[Constant]{LAL\_2\_SQRTPI}
\idx[Constant]{LAL\_PI\_180}
\idx[Constant]{LAL\_180\_PI}
The following constants define the precision and range of
floating-point arithmetic in LAL. They are taken from the IEEE
standard~754 for binary arithmetic. All numbers are dimensionless.
\begin{center}
\begin{tabular}{|lll|}
\hline
Name & Value & Description \\
\hline
\tt LAL\_REAL4\_MANT & 24 &
Bits in {\tt REAL4} mantissa \\
\tt LAL\_REAL4\_MAX & $3.40282347\times10^{38}$ &
Largest {\tt REAL4} \\
\tt LAL\_REAL4\_MIN & $1.17549435\times10^{-38}$ &
Smallest positive {\tt REAL4} \\
\tt LAL\_REAL4\_EPS & $1.19209290\times10^{-7}$ &
$2^{-(\mathtt{LAL\_REAL4\_MANT}-1)}$ \\
\hline
\tt LAL\_REAL8\_MANT & 53 &
Bits in {\tt REAL8} mantissa \\
\tt LAL\_REAL8\_MAX & $1.7976931348623157\times10^{308}$ &
Largest {\tt REAL8} \\
\tt LAL\_REAL8\_MIN & $2.2250738585072014\times10^{-308}$ &
Smallest positive {\tt REAL8} \\
\tt LAL\_REAL8\_EPS & $2.2204460492503131\times10^{-16}$ &
$2^{-(\mathtt{LAL\_REAL8\_MANT}-1)}$ \\
\hline
\end{tabular}
\end{center}
\noindent\verb@LAL_REAL4_EPS@ and \verb@LAL_REAL8_EPS@ can be thought
of as the difference between 1 and the next representable \verb@REAL4@
or \verb@REAL8@ number.
\vspace{3ex}
</lalLaTeX> */
/** \name Floating-point constants /** \name Floating-point constants
* The following constants define the precision and range of * The following constants define the precision and range of
* floating-point arithmetic in LAL. They are taken from the IEEE * floating-point arithmetic in LAL. They are taken from the IEEE
* standard 754 for binary arithmetic. All numbers are dimensionless. */ * standard 754 for binary arithmetic. All numbers are dimensionless. */
/*@{*/ /*@{*/
#define LAL_REAL4_MANT 24 /**< Bits of precision in the mantissa of a REAL4 */ #define LAL_REAL4_MANT 24 /**< Bits of precision in the mantissa of a REAL4 */
#define LAL_REAL4_MAX 3.40282347e+38 /**< Largest REAL4 */ #define LAL_REAL4_MAX 3.40282347e+38 /**< Largest REAL4 */
#define LAL_REAL4_MIN 1.17549435e-38 /**< Smallest nonzero REAL4 */ #define LAL_REAL4_MIN 1.17549435e-38 /**< Smallest nonzero REAL4 */
#define LAL_REAL4_EPS 1.19209290e-07 /**< 0.5^(LAL_REAL4_MANT-1), i.e. the difference between 1 and the next resolveable REAL4 */ #define LAL_REAL4_EPS 1.19209290e-07 /**< 0.5^(LAL_REAL4_MANT-1), ie the di fference between 1 and the next resolveable REAL4 */
#define LAL_REAL8_MANT 53 /**< Bits of precision in the mantissa of a REAL8 */ #define LAL_REAL8_MANT 53 /**< Bits of precision in the mantissa of a REAL8 */
#define LAL_REAL8_MAX 1.7976931348623157e+308 /**< Largest REAL8 */ #define LAL_REAL8_MAX 1.7976931348623157e+308 /**< Largest REAL8 */
#define LAL_REAL8_MIN 2.2250738585072014e-308 /**< Smallest nonzero REAL8 * / #define LAL_REAL8_MIN 2.2250738585072014e-308 /**< Smallest nonzero REAL8 * /
#define LAL_REAL8_EPS 2.2204460492503131e-16 /**< 0.5^(LAL_REAL8_MANT-1), i.e. the difference between 1 and the next resolveable REAL8 */ #define LAL_REAL8_EPS 2.2204460492503131e-16 /**< 0.5^(LAL_REAL8_MANT-1), ie the difference between 1 and the next resolveable REAL8 */
/*@}*/ /*@}*/
/* <lalLaTeX>
The following are fundamental mathematical constants. They are mostly
taken from the GNU C \verb@math.h@ header (with the exception of
\verb@LAL_TWOPI@, which was computed using Maple). All numbers are
dimensionless.
\begin{center}
\begin{tabular}{|llc|}
\hline
Name & Value & Expression \\
\hline
\tt LAL\_E & 2.7182818284590452353602874713526625 & $e$ \\
\tt LAL\_LOG2E & 1.4426950408889634073599246810018922 & $\log_2 e$ \\
\tt LAL\_LOG10E & 0.4342944819032518276511289189166051 & $\log_{10} e$ \
\
\tt LAL\_LN2 & 0.6931471805599453094172321214581766 & $\log_e 2$ \\
\tt LAL\_LN10 & 2.3025850929940456840179914546843642 & $\log_e 10$ \\
\tt LAL\_SQRT2 & 1.4142135623730950488016887242096981 & $\sqrt{2}$ \\
\tt LAL\_SQRT1\_2 & 0.7071067811865475244008443621048490 & $1/\sqrt{2}$ \\
\tt LAL\_GAMMA & 0.5772156649015328606065120900824024 & $\gamma$ \\
\tt LAL\_PI & 3.1415926535897932384626433832795029 & $\pi$ \\
\tt LAL\_TWOPI & 6.2831853071795864769252867665590058 & $2\pi$ \\
\tt LAL\_PI\_2 & 1.5707963267948966192313216916397514 & $\pi/2$ \\
\tt LAL\_PI\_4 & 0.7853981633974483096156608458198757 & $\pi/4$ \\
\tt LAL\_1\_PI & 0.3183098861837906715377675267450287 & $1/\pi$ \\
\tt LAL\_2\_PI & 0.6366197723675813430755350534900574 & $2/\pi$ \\
\tt LAL\_2\_SQRTPI & 1.1283791670955125738961589031215452 & $2/\sqrt{\pi}$
\\
\tt LAL\_PI\_180 & 1.7453292519943295769236907684886127$\times10^{-2}$ &
$\pi/180$ \\
\tt LAL\_180\_PI & 57.295779513082320876798154814105170 & $180/\pi$ \\
\hline
\end{tabular}
\end{center}
</lalLaTeX> */
/** \name Mathematical constants /** \name Mathematical constants
* The following are fundamental mathematical constants. They are mostly * The following are fundamental mathematical constants. They are mostly
* taken from the GNU C <tt>math.h</tt> header (with the exception of * taken from the GNU C <tt>math.h</tt> header (with the exception of
* <tt>LAL_TWOPI</tt>, which was computed using Maple). All numbers are * <tt>LAL_TWOPI</tt>, which was computed using Maple). All numbers are
* dimensionless. The value of exp(gamma) is taken from * dimensionless. The value of exp(gamma) is taken from
* http://www.research.att.com/~njas/sequences/A073004 */ * http://www.research.att.com/~njas/sequences/A073004 */
/*@{*/ /*@{*/
#define LAL_E 2.7182818284590452353602874713526625 /**< e */ #define LAL_E 2.7182818284590452353602874713526625 /**< e */
#define LAL_LOG2E 1.4426950408889634073599246810018922 /**< log_2 e */ #define LAL_LOG2E 1.4426950408889634073599246810018922 /**< log_2 e */
#define LAL_LOG10E 0.4342944819032518276511289189166051 /**< log_10 e * / #define LAL_LOG10E 0.4342944819032518276511289189166051 /**< log_10 e * /
skipping to change at line 224 skipping to change at line 87
#define LAL_TWOPI 6.2831853071795864769252867665590058 /**< 2*pi */ #define LAL_TWOPI 6.2831853071795864769252867665590058 /**< 2*pi */
#define LAL_PI_2 1.5707963267948966192313216916397514 /**< pi/2 */ #define LAL_PI_2 1.5707963267948966192313216916397514 /**< pi/2 */
#define LAL_PI_4 0.7853981633974483096156608458198757 /**< pi/4 */ #define LAL_PI_4 0.7853981633974483096156608458198757 /**< pi/4 */
#define LAL_1_PI 0.3183098861837906715377675267450287 /**< 1/pi */ #define LAL_1_PI 0.3183098861837906715377675267450287 /**< 1/pi */
#define LAL_2_PI 0.6366197723675813430755350534900574 /**< 2/pi */ #define LAL_2_PI 0.6366197723675813430755350534900574 /**< 2/pi */
#define LAL_2_SQRTPI 1.1283791670955125738961589031215452 /**< 2/sqrt(pi) */ #define LAL_2_SQRTPI 1.1283791670955125738961589031215452 /**< 2/sqrt(pi) */
#define LAL_PI_180 1.7453292519943295769236907684886127e-2 /**< pi/180 * / #define LAL_PI_180 1.7453292519943295769236907684886127e-2 /**< pi/180 * /
#define LAL_180_PI 57.295779513082320876798154814105170 /**< 180/pi */ #define LAL_180_PI 57.295779513082320876798154814105170 /**< 180/pi */
/*@}*/ /*@}*/
/* <lalLaTeX>
\subsection*{Physical constants}
\idx[Constant]{LAL\_C\_SI}
\idx[Constant]{LAL\_EPSILON0\_SI}
\idx[Constant]{LAL\_MU0\_SI}
\idx[Constant]{LAL\_GEARTH\_SI}
\idx[Constant]{LAL\_PATM\_SI}
\idx[Constant]{LAL\_YRJUL\_SI}
\idx[Constant]{LAL\_LYR\_SI}
\idx[Constant]{LAL\_G\_SI}
\idx[Constant]{LAL\_H\_SI}
\idx[Constant]{LAL\_HBAR\_SI}
\idx[Constant]{LAL\_MPL\_SI}
\idx[Constant]{LAL\_LPL\_SI}
\idx[Constant]{LAL\_TPL\_SI}
\idx[Constant]{LAL\_K\_SI}
\idx[Constant]{LAL\_R\_SI}
\idx[Constant]{LAL\_MOL}
\idx[Constant]{LAL\_BWIEN\_SI}
\idx[Constant]{LAL\_SIGMA\_SI}
\idx[Constant]{LAL\_AMU\_SI}
\idx[Constant]{LAL\_MP\_SI}
\idx[Constant]{LAL\_ME\_SI}
\idx[Constant]{LAL\_QP\_SI}
\idx[Constant]{LAL\_ALPHA}
\idx[Constant]{LAL\_RE\_SI}
\idx[Constant]{LAL\_LAMBDAE\_SI}
\idx[Constant]{LAL\_AB\_SI}
\idx[Constant]{LAL\_MUB\_SI}
\idx[Constant]{LAL\_MUN\_SI}
The following physical constants are defined to have exact values.
The values of $c$ and $g$ are taken from~\cite{Barnet:1996},
$p_\mathrm{atm}$ is from~\cite{Lang:1992}, while $\epsilon_0$ and
$\mu_0$ are computed from $c$ using exact formulae. The use of a
Julian year (365.25 days) as standard is specified by the IAU.
They are given in the SI units shown.
\begin{center}
\begin{tabular}{|lll|}
\hline
Name & Value & Description \\
\hline
\tt LAL\_C\_SI & $299\,792\,458\,\mathrm{m}\,\mathrm{s}^{-1}$ &
Speed of light $c$ in free space \\
\tt LAL\_EPSILON0\_SI & \multicolumn{2}{l|}{
$8.8541878176203898505365630317107503\times10^{-12}\,
\mathrm{C}^2\mathrm{N}^{-1}\mathrm{m}^{-2}$} \\
& & Permittivity $\epsilon_0$ of free space \\
\tt LAL\_MU0\_SI & \multicolumn{2}{l|}{
$1.2566370614359172953850573533118012\times10^{-6}\,
\mathrm{N}\,\mathrm{A}^{-2}$} \\
& & Permeability $\mu_0$ of free space \\
\tt LAL\_GEARTH\_SI & $9.80665\,\mathrm{m}\,\mathrm{s}^{-2}$ &
Standard gravity $g$ \\
\tt LAL\_PATM\_SI & $101\,325\,\mathrm{Pa}$ &
Standard atmospheric pressure $p_\mathrm{atm}$ \\
\tt LAL\_YRJUL\_SI & $31\,557\,600\,\mathrm{s}$ &
(Julian) year \\
\tt LAL\_LYR\_SI & $9.4607304725808\times10^{15}\,\mathrm{m}$ &
$c\times$(Julian) year\\
\hline
\end{tabular}
\end{center}
</lalLaTeX> */
/** \name Exact physical constants /** \name Exact physical constants
* The following physical constants are defined to have exact values. * The following physical constants are defined to have exact values.
* The values of \f$c\f$ and \f$g\f$ are taken from Barnet (1996), * The values of \f$c\f$ and \f$g\f$ are taken from \ref Barnet_1996,
* \f$p_\mathrm{atm}\f$ is from Lang (1992), while \f$\epsilon_0\f$ and * \f$p_\mathrm{atm}\f$ is from \ref Lang_1992, while \f$\epsilon_0\f$ and
* \f$\mu_0\f$ are computed from \f$c\f$ using exact formulae. The use * \f$\mu_0\f$ are computed from \f$c\f$ using exact formulae. The use
* of a Julian year (365.25 days) as standard is specified by the IAU. * of a Julian year (365.25 days) as standard is specified by the IAU.
* They are given in the SI units shown. */ * They are given in the SI units shown. */
/*@{*/ /*@{*/
#define LAL_C_SI 299792458 /**< Speed of light in vacuo, m s^-1 */ #define LAL_C_SI 299792458 /**< Speed of light in vacuo, m s^-1 */
#define LAL_EPSILON0_SI 8.8541878176203898505365630317107503e-12 /**< Perm ittivity of free space, C^2 N^-1 m^-2 */ #define LAL_EPSILON0_SI 8.8541878176203898505365630317107503e-12 /**< Perm ittivity of free space, C^2 N^-1 m^-2 */
#define LAL_MU0_SI 1.2566370614359172953850573533118012e-6 /**< Permeabi lity of free space, N A^-2 */ #define LAL_MU0_SI 1.2566370614359172953850573533118012e-6 /**< Permeabi lity of free space, N A^-2 */
#define LAL_GEARTH_SI 9.80665 /**< Standard gravity, m s^-2 */ #define LAL_GEARTH_SI 9.80665 /**< Standard gravity, m s^-2 */
#define LAL_PATM_SI 101325 /**< Standard atmosphere, Pa */ #define LAL_PATM_SI 101325 /**< Standard atmosphere, Pa */
#define LAL_YRJUL_SI 31557600 /**< Julian year, s */ #define LAL_YRJUL_SI 31557600 /**< Julian year, s */
#define LAL_LYR_SI 9.4607304725808e15 /**< (Julian) Lightyear, m */ #define LAL_LYR_SI 9.4607304725808e15 /**< (Julian) Lightyear, m */
/*@}*/ /*@}*/
/* <lalLaTeX>
The following are measured fundamental physical constants, with values
given in \cite{Barnet:1996}. When not dimensionless, they are given
in the SI units shown.
\begin{center}
\begin{tabular}{|lll|}
\hline
Name & Value & Description \\
\hline
\tt LAL\_G\_SI & $6.67259\times10^{-11}\,\mathrm{N}\,\mathrm{m}^{2}
\mathrm{kg}^{-2}$ & Gravitational constant $G$ \\
\tt LAL\_H\_SI & $6.6260755\times10^{-34}\,\mathrm{J}\,\mathrm{s}$ &
Planck constant $h$ \\
\tt LAL\_HBAR\_SI & $1.05457266\times10^{-34}\,\mathrm{J}\,\mathrm{s}$ &
Reduced Planck constant $\hbar$ \\
\tt LAL\_MPL\_SI & $2.17671\times10^{-8}\,\mathrm{kg}$ & Planck mass \\
\tt LAL\_LPL\_SI & $1.61605\times10^{-35}\,\mathrm{m}$ & Planck length \\
\tt LAL\_TPL\_SI & $5.39056\times10^{-44}\,\mathrm{s}$ & Planck time \\
\tt LAL\_K\_SI & $1.380658\times10^{-23}\,\mathrm{J}\,\mathrm{K}^{-1}$
&
Boltzmann constant $k$ \\
\tt LAL\_R\_SI & $8.314511\,\mathrm{J}\,\mathrm{K}^{-1}$ &
Ideal gas constant $R$ \\
\tt LAL\_MOL & $6.0221367\times10^{23}$ & Avogadro constant \\
\tt LAL\_BWIEN\_SI & $2.897756\times10^{-3}\,\mathrm{m}\,\mathrm{K}$ &
Wien displacement law constant $b$ \\
\tt LAL\_SIGMA\_SI & $5.67051\times10^{-8}\,\mathrm{W}\,\mathrm{m}^{-2}
\mathrm{K}^{-4}$ & Stefan-Boltzmann constant $\sigma$ \\
\tt LAL\_AMU\_SI & $1.6605402\times10^{-27}\,\mathrm{kg}$ &
Atomic mass unit \\
\tt LAL\_MP\_SI & $1.6726231\times10^{-27}\,\mathrm{kg}$ & Proton mass \
\
\tt LAL\_ME\_SI & $9.1093897\times10^{-31}\,\mathrm{kg}$ & Electron mass
\\
\tt LAL\_QP\_SI & $1.60217733\times10^{-19}\,\mathrm{C}$ & Proton charge
\\
\tt LAL\_ALPHA & $7.297354677\times10^{-3}$ & Fine structure constant \
\
\tt LAL\_RE\_SI & $2.81794092\times10^{-15}\,\mathrm{m}$ &
Classical electron radius $r_e$ \\
\tt LAL\_LAMBDAE\_SI & $3.86159323\times10^{-13}\,\mathrm{m}$ &
Electron Compton wavelength $\lambda_e$ \\
\tt LAL\_AB\_SI & $5.29177249\times10^{-11}\,\mathrm{m}$ & Bohr radius $
a$\\
\tt LAL\_MUB\_SI & $9.27401543\times10^{-24}\,\mathrm{J}\,\mathrm{T}^{-1}
$ &
Bohr magneton $\mu_B$ \\
\tt LAL\_MUN\_SI & $5.05078658\times10^{-27}\,\mathrm{J}\,\mathrm{T}^{-1}
$ &
Nuclear magneton $\mu_N$ \\
\hline
\end{tabular}
\end{center}
</lalLaTeX> */
/** \name Physical constants /** \name Physical constants
* The following are measured fundamental physical constants, with values * The following are measured fundamental physical constants, with values
* given in Barnet (1996). When not dimensionless, they are given * given in \ref Barnet_1996. When not dimensionless, they are given
* in the SI units shown. */ * in the SI units shown. */
/*@{*/ /*@{*/
#define LAL_G_SI 6.67259e-11 /**< Gravitational constant, N m^2 kg^ -2 */ #define LAL_G_SI 6.67259e-11 /**< Gravitational constant, N m^2 kg^ -2 */
#define LAL_H_SI 6.6260755e-34 /**< Planck constant, J s */ #define LAL_H_SI 6.6260755e-34 /**< Planck constant, J s */
#define LAL_HBAR_SI 1.05457266e-34 /**< Reduced Planck constant, J s */ #define LAL_HBAR_SI 1.05457266e-34 /**< Reduced Planck constant, J s */
#define LAL_MPL_SI 2.17671e-8 /**< Planck mass, kg */ #define LAL_MPL_SI 2.17671e-8 /**< Planck mass, kg */
#define LAL_LPL_SI 1.61605e-35 /**< Planck length, m */ #define LAL_LPL_SI 1.61605e-35 /**< Planck length, m */
#define LAL_TPL_SI 5.39056e-44 /**< Planck time, s */ #define LAL_TPL_SI 5.39056e-44 /**< Planck time, s */
#define LAL_K_SI 1.380658e-23 /**< Boltzmann constant, J K^-1 */ #define LAL_K_SI 1.380658e-23 /**< Boltzmann constant, J K^-1 */
#define LAL_R_SI 8.314511 /**< Ideal gas constant, J K^-1 */ #define LAL_R_SI 8.314511 /**< Ideal gas constant, J K^-1 */
skipping to change at line 386 skipping to change at line 132
#define LAL_ME_SI 9.1093897e-31 /**< Electron mass, kg */ #define LAL_ME_SI 9.1093897e-31 /**< Electron mass, kg */
#define LAL_QE_SI 1.60217733e-19 /**< Electron charge, C */ #define LAL_QE_SI 1.60217733e-19 /**< Electron charge, C */
#define LAL_ALPHA 7.297354677e-3 /**< Fine structure constant, dimensionle ss */ #define LAL_ALPHA 7.297354677e-3 /**< Fine structure constant, dimensionle ss */
#define LAL_RE_SI 2.81794092e-15 /**< Classical electron radius, m */ #define LAL_RE_SI 2.81794092e-15 /**< Classical electron radius, m */
#define LAL_LAMBDAE_SI 3.86159323e-13 /**< Electron Compton wavelength, m * / #define LAL_LAMBDAE_SI 3.86159323e-13 /**< Electron Compton wavelength, m * /
#define LAL_AB_SI 5.29177249e-11 /**< Bohr radius, m */ #define LAL_AB_SI 5.29177249e-11 /**< Bohr radius, m */
#define LAL_MUB_SI 9.27401543e-24 /**< Bohr magneton, J T^-1 */ #define LAL_MUB_SI 9.27401543e-24 /**< Bohr magneton, J T^-1 */
#define LAL_MUN_SI 5.05078658e-27 /**< Nuclear magneton, J T^-1 */ #define LAL_MUN_SI 5.05078658e-27 /**< Nuclear magneton, J T^-1 */
/*@}*/ /*@}*/
/* <lalLaTeX>
\subsection*{Astrophysical parameters}
\idx[Constant]{LAL\_REARTH\_SI}
\idx[Constant]{LAL\_AWGS84\_SI}
\idx[Constant]{LAL\_BWGS84\_SI}
\idx[Constant]{LAL\_MEARTH\_SI}
\idx[Constant]{LAL\_IEARTH}
\idx[Constant]{LAL\_EEARTH}
\idx[Constant]{LAL\_RSUN\_SI}
\idx[Constant]{LAL\_MSUN\_SI}
\idx[Constant]{LAL\_MRSUN\_SI}
\idx[Constant]{LAL\_MTSUN\_SI}
\idx[Constant]{LAL\_LSUN\_SI}
\idx[Constant]{LAL\_AU\_SI}
\idx[Constant]{LAL\_PC\_SI}
\idx[Constant]{LAL\_YRTROP\_SI}
\idx[Constant]{LAL\_YRSID\_SI}
\idx[Constant]{LAL\_DAYSID\_SI}
\idx[Constant]{LAL\_H0\_SI}
\idx[Constant]{LAL\_H0FAC\_SI}
\idx[Constant]{LAL\_RHOC\_SI}
\idx[Constant]{LAL\_RHOCFAC\_SI}
\idx[Constant]{LAL\_TCBR\_SI}
\idx[Constant]{LAL\_VCBR\_SI}
\idx[Constant]{LAL\_RHOCBR\_SI}
\idx[Constant]{LAL\_NCBR\_SI}
\idx[Constant]{LAL\_SCBR\_SI}
The following parameters are derived from measured properties of the
Earth and Sun. The values are taken from~\cite{Barnet:1996}, except
for the obliquity of the ecliptic plane and the eccentricity of
Earth's orbit, which are taken from~\cite{Lang:1992}. All values are
given in the SI units shown. Note that the ``year'' and ``light-year''
have exactly defined values, and appear under ``Exact physical constants''.
\begin{center}
\begin{tabular}{|lll|}
\hline
Name & Value & Description \\
\hline
\tt LAL\_REARTH\_SI & $6.378140\times10^6\,\mathrm{m}$ &
Earth equatorial radius \\
\tt LAL\_AWGS84\_SI & $6.378137\times10^6\,\mathrm{m}$ &
Semimajor axis of WGS-84 Reference Ellipsoid \\
\tt LAL\_BWGS84\_SI & $6.356752314\times10^6\,\mathrm{m}$ &
Semiminor axis of WGS-84 Reference Ellipsoid \\
\tt LAL\_MEARTH\_SI & $5.97370\times10^{24}\,\mathrm{kg}$ & Earth mass \\
\tt LAL\_IEARTH & $0.409092804\,\mathrm{rad}$ &
Obliquity of the ecliptic (2000) \\
\tt LAL\_EEARTH & 0.0167 & Earth orbital eccentricity \\
\tt LAL\_RSUN\_SI & $6.960\times10^8\,\mathrm{m}$ & Solar equatorial radi
us\\
\tt LAL\_MSUN\_SI & $1.98892\times10^{30}\,\mathrm{kg}$ & Solar mass \\
\tt LAL\_MRSUN\_SI & $1.47662504\times10^3\,\mathrm{m}$ &
Geometrized solar mass (length) \\
\tt LAL\_MTSUN\_SI & $4.92549095\times10^{-6}\,\mathrm{s}$ &
Geometrized solar mass (time) \\
\tt LAL\_LSUN\_SI & $3.846\times10^{26}\,\mathrm{W}$ & Solar luminosity \
\
\tt LAL\_AU\_SI & $1.4959787066\times10^{11}\,\mathrm{m}$ &
Astronomical unit \\
\tt LAL\_PC\_SI & $3.0856775807\times10^{16}\,\mathrm{m}$ & Parsec \\
\tt LAL\_YRTROP\_SI & $31\,556\,925.2\,\mathrm{s}$ & Tropical year (1994) \
\
\tt LAL\_YRSID\_SI & $31\,558\,149.8\,\mathrm{s}$ & Sidereal year (1994) \
\
\tt LAL\_DAYSID\_SI & $86\,164.09053\,\mathrm{s}$ & Mean sidereal day \\
\hline
\end{tabular}
\end{center}
</lalLaTeX> */
/** \name Astrophysical parameters /** \name Astrophysical parameters
* The following parameters are derived from measured properties of the * The following parameters are derived from measured properties of the
* Earth and Sun. The values are taken from Barnet (1996), except * Earth and Sun. The values are taken from \ref Barnet_1996, except
* for the obliquity of the ecliptic plane and the eccentricity of * for the obliquity of the ecliptic plane and the eccentricity of
* Earth's orbit, which are taken from Lang (1992). All values are * Earth's orbit, which are taken from \ref Lang_1992. All values are
* given in the SI units shown. Note that the ``year'' and * given in the SI units shown. Note that the ``year'' and
* ``light-year'' have exactly defined values, and appear under * ``light-year'' have exactly defined values, and appear under
* ``Exact physical constants''. * ``Exact physical constants''.
*/ */
/*@{*/ /*@{*/
#define LAL_REARTH_SI 6.378140e6 /**< Earth equatorial radius, m */ #define LAL_REARTH_SI 6.378140e6 /**< Earth equatorial radius, m */
#define LAL_AWGS84_SI 6.378137e6 /**< Semimajor axis of WGS-84 Referen ce Ellipsoid, m */ #define LAL_AWGS84_SI 6.378137e6 /**< Semimajor axis of WGS-84 Referen ce Ellipsoid, m */
#define LAL_BWGS84_SI 6.356752314e6 /**< Semiminor axis of WGS-84 Referen ce Ellipsoid, m */ #define LAL_BWGS84_SI 6.356752314e6 /**< Semiminor axis of WGS-84 Referen ce Ellipsoid, m */
#define LAL_MEARTH_SI 5.97370e24 /**< Earth mass, kg */ #define LAL_MEARTH_SI 5.97370e24 /**< Earth mass, kg */
#define LAL_IEARTH 0.409092804 /**< Earth inclination (2000), radian s */ #define LAL_IEARTH 0.409092804 /**< Earth inclination (2000), radian s */
skipping to change at line 484 skipping to change at line 160
#define LAL_MRSUN_SI 1.47662504e3 /**< Geometrized solar mass, m */ #define LAL_MRSUN_SI 1.47662504e3 /**< Geometrized solar mass, m */
#define LAL_MTSUN_SI 4.92549095e-6 /**< Geometrized solar mass, s */ #define LAL_MTSUN_SI 4.92549095e-6 /**< Geometrized solar mass, s */
#define LAL_LSUN_SI 3.846e26 /**< Solar luminosity, W */ #define LAL_LSUN_SI 3.846e26 /**< Solar luminosity, W */
#define LAL_AU_SI 1.4959787066e11 /**< Astronomical unit, m */ #define LAL_AU_SI 1.4959787066e11 /**< Astronomical unit, m */
#define LAL_PC_SI 3.0856775807e16 /**< Parsec, m */ #define LAL_PC_SI 3.0856775807e16 /**< Parsec, m */
#define LAL_YRTROP_SI 31556925.2 /**< Tropical year (1994), s */ #define LAL_YRTROP_SI 31556925.2 /**< Tropical year (1994), s */
#define LAL_YRSID_SI 31558149.8 /**< Sidereal year (1994), s */ #define LAL_YRSID_SI 31558149.8 /**< Sidereal year (1994), s */
#define LAL_DAYSID_SI 86164.09053 /**< Mean sidereal day, s */ #define LAL_DAYSID_SI 86164.09053 /**< Mean sidereal day, s */
/*@}*/ /*@}*/
/* <lalLaTeX>
The following cosmological parameters are derived from measurements of
the Hubble expansion rate and of the cosmic background radiation
(CBR). Data are taken from~\cite{Barnet:1996}. In what follows, the
normalized Hubble constant $h_0$ is equal to the actual Hubble
constant $H_0$ divided by $\langle H
\rangle=100\,\mathrm{km}\,\mathrm{s}^{-1}\mathrm{Mpc}^{-1}$. Thus the
Hubble constant can be written as:
$$
H_0 = \langle H \rangle h_0 \; .
$$
Similarly, the critical energy density $\rho_c$ required for spatial
flatness is given by:
$$
\rho_c = \langle\rho\rangle h_0^2 \; .
$$
Current estimates give $h_0$ a value of around 0.65, which is what is
assumed below. All values are in the SI units shown.
\begin{center}
\begin{tabular}{|lll|}
\hline
Name & Value & Description \\
\hline
\tt LAL\_H0\_SI & $2\times10^{-18}\,\mathrm{s}^{-1}$ &
Approx.\ Hubble constant $H_0$ \\
\tt LAL\_H0FAC\_SI & $3.2407792903\times10^{-18}\,\mathrm{s}^{-1}$ &
$H_0/h_0$ \\
\tt LAL\_RHOC\_SI & $7\times10^{-10}\,\mathrm{J}\,\mathrm{m}^{-3}$ &
Approx.\ critical energy density $\rho_c$ \\
\tt LAL\_RHOCFAC\_SI & $1.68860\times10^{-9}\,\mathrm{J}\,\mathrm{m}^{-3}$
&
$\rho_c/h_0^2$ \\
\tt LAL\_TCBR\_SI & $2.726 \mathrm{K}$ &
CBR temperature \\
\tt LAL\_VCBR\_SI & $3.695\times10^5\,\mathrm{m}\,\mathrm{s}^{-1}$ &
Solar velocity with respect to CBR \\
\tt LAL\_RHOCBR\_SI & $4.177\times10^{-14}\,\mathrm{J}\,\mathrm{m}^{-3}$ &
Energy density of CBR \\
\tt LAL\_NCBR\_SI & $4.109\times10^8\,\mathrm{m}^{-3}$ &
Number density of CBR photons \\
\tt LAL\_SCBR\_SI & $3.993\times10^{-14}\,\mathrm{J}\,\mathrm{K}^{-1}
\mathrm{m}^{-3}$ & Entropy density of CBR \\
\hline
\end{tabular}
\end{center}
</lalLaTeX> */
/** \name Cosmological parameters /** \name Cosmological parameters
* The following cosmological parameters are derived from measurements of * The following cosmological parameters are derived from measurements of
* the Hubble expansion rate and of the cosmic background radiation * the Hubble expansion rate and of the cosmic background radiation
* (CBR). Data are taken from Barnet (1996). In what follows, the * (CBR). Data are taken from \ref Barnet_1996. In what follows, the
* normalized Hubble constant \f$h_0\f$ is equal to the actual Hubble * normalized Hubble constant \f$h_0\f$ is equal to the actual Hubble
* constant \f$H_0\f$ divided by \f$\langle H * constant \f$H_0\f$ divided by \f$\langle H
* \rangle=100\,\mathrm{km}\,\mathrm{s}^{-1}\mathrm{Mpc}^{-1}\f$. Thus the * \rangle=100\,\mathrm{km}\,\mathrm{s}^{-1}\mathrm{Mpc}^{-1}\f$. Thus the
* Hubble constant can be written as: * Hubble constant can be written as:
* \f$H_0 = \langle H \rangle h_0\f$. * \f$H_0 = \langle H \rangle h_0\f$.
* Similarly, the critical energy density \f$\rho_c\f$ required for spatial * Similarly, the critical energy density \f$\rho_c\f$ required for spatial
* flatness is given by: \f$\rho_c = \langle\rho\rangle h_0^2\f$. * flatness is given by: \f$\rho_c = \langle\rho\rangle h_0^2\f$.
* Current estimates give \f$h_0\f$ a value of around 0.65, which is what i s * Current estimates give \f$h_0\f$ a value of around 0.65, which is what i s
* assumed below. All values are in the SI units shown. */ * assumed below. All values are in the SI units shown. */
/*@{*/ /*@{*/
skipping to change at line 560 skipping to change at line 187
#define LAL_RHOCFAC_SI 1.68860e-9 /**< Critical density prefactor, J m^-3 */ #define LAL_RHOCFAC_SI 1.68860e-9 /**< Critical density prefactor, J m^-3 */
#define LAL_RHOC_SI 7e-10 /**< Approximate critical density, J m^ -3 */ #define LAL_RHOC_SI 7e-10 /**< Approximate critical density, J m^ -3 */
/* Critical density RHOC = h0*h0*RHOCFAC, where h0 is around 0.65 */ /* Critical density RHOC = h0*h0*RHOCFAC, where h0 is around 0.65 */
#define LAL_TCBR_SI 2.726 /**< Cosmic background radiation temperature, K */ #define LAL_TCBR_SI 2.726 /**< Cosmic background radiation temperature, K */
#define LAL_VCBR_SI 3.695e5 /**< Solar velocity with respect to CBR, m s^ -1 */ #define LAL_VCBR_SI 3.695e5 /**< Solar velocity with respect to CBR, m s^ -1 */
#define LAL_RHOCBR_SI 4.177e-14 /**< Energy density of CBR, J m^-3 */ #define LAL_RHOCBR_SI 4.177e-14 /**< Energy density of CBR, J m^-3 */
#define LAL_NCBR_SI 4.109e8 /**< Number density of CBR photons, m^-3 */ #define LAL_NCBR_SI 4.109e8 /**< Number density of CBR photons, m^-3 */
#define LAL_SCBR_SI 3.993e-14 /**< Entropy density of CBR, J K^-1 m^-3 */ #define LAL_SCBR_SI 3.993e-14 /**< Entropy density of CBR, J K^-1 m^-3 */
/*@}*/ /*@}*/
/* <lalLaTeX> /*@}*/
\vfill{\footnotesize\input{LALConstantsHV}}
</lalLaTeX> */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _LALCONSTANTS_H */ #endif /* _LALCONSTANTS_H */
 End of changes. 18 change blocks. 
405 lines changed or deleted 12 lines changed or added


 LALCorrelation.h   LALCorrelation.h 
skipping to change at line 35 skipping to change at line 35
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#include <lal/LALStdlib.h> #include <lal/LALStdlib.h>
/* ****** 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$");
/** /**
\author Yakushin, Igor \author Yakushin, Igor
\addtogroup LALCorrelation_h \addtogroup LALCorrelation_h
\brief [One sentence briefly defining scope of the header] \brief [One sentence briefly defining scope of the header]
\heading{Synopsis} \heading{Synopsis}
\code \code
#include <lal/LALCorrelation.h> #include <lal/LALCorrelation.h>
\endcode \endcode
 End of changes. 1 change blocks. 
2 lines changed or deleted 0 lines changed or added


 LALDatatypes.h   LALDatatypes.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 // ---------- SEE LALDatatypes.dox for doxygen documentation ----------
* \ingroup std
* \author Creighton, J. D. E., and Creighton, T. D.
* \date $Id$
* \brief Provides the basic LAL datatypes.
*
* This header defines the standard data types and data
* structures that are used throughout LAL. They fall into three general
* categories: primitive datatypes, aggregates of primitive
* datatypes, and structured datatypes. The LAL status structure
* is a special case of a structured datatype that is used in every
* standard LAL function.
*
* This header file is automatically included by the header
* <tt>LALStdlib.h</tt>. In turn, this header file starts by including the
* header <tt>LALAtomicDatatypes.h</tt>.
*
*/
/********************************* <lalVerbatim file="LALDatatypesHV">
Author: J. D. E. Creighton, T. D. Creighton
$Id$
********************************** </lalVerbatim> */
/* <lalLaTeX>
\section{Header \texttt{LALDatatypes.h}}
\label{s:LALDatatypes.h}
Provides the basic LAL datatypes.
\subsection*{Synopsis}
\begin{verbatim}
#include <lal/LALDatatypes.h>
\end{verbatim}
\noindent This header defines the standard data types and data
structures that are used throughout LAL. They fall into three general
categories: \emph{primitive} datatypes, \emph{aggregates} of primitive
datatypes, and \emph{structured} datatypes. The LAL status structure
is a special case of a structured datatype that is used in every
standard LAL function.
This header file is automatically included by the header
\verb@LALStdlib.h@. In turn, this header file starts by including the
header \verb@LALAtomicDatatypes.h@, which is discussed in the
following section.
</lalLaTeX> */
#ifndef _LALDATATYPES_H #ifndef _LALDATATYPES_H
#define _LALDATATYPES_H #define _LALDATATYPES_H
/* remove SWIG interface directives */ /* remove SWIG interface directives */
#if !defined(SWIG) && !defined(SWIGLAL_STRUCT) #if !defined(SWIG) && !defined(SWIGLAL_STRUCT)
#define SWIGLAL_STRUCT(...) #define SWIGLAL_STRUCT(...)
#endif #endif
#if !defined(SWIG) && !defined(SWIGLAL_DYNAMIC_1DARRAY) #if !defined(SWIG) && !defined(SWIGLAL_DYNAMIC_1DARRAY)
#define SWIGLAL_DYNAMIC_1DARRAY(...) #define SWIGLAL_DYNAMIC_1DARRAY(...)
#endif #endif
#if !defined(SWIG) && !defined(SWIGLAL_DYNAMIC_2DARRAY) #if !defined(SWIG) && !defined(SWIGLAL_DYNAMIC_2DARRAY)
#define SWIGLAL_DYNAMIC_2DARRAY(...) #define SWIGLAL_DYNAMIC_2DARRAY(...)
#endif #endif
/* <lalLaTeX>
\newpage\input{LALAtomicDatatypesH}
</lalLaTeX> */
#include <lal/LALAtomicDatatypes.h> #include <lal/LALAtomicDatatypes.h>
/**** <lalLaTeX> /** \addtogroup LALDatatypes */ /*@{*/
* \newpage
* \subsection{Atomic datatypes codes}
* \label{ss:atomic-datatype-codes}
* \idx[Constant]{LAL\_1\_BYTE\_TYPE\_SIZE}
* \idx[Constant]{LAL\_2\_BYTE\_TYPE\_SIZE}
* \idx[Constant]{LAL\_4\_BYTE\_TYPE\_SIZE}
* \idx[Constant]{LAL\_8\_BYTE\_TYPE\_SIZE}
* \idx[Constant]{LAL\_16\_BYTE\_TYPE\_SIZE}
* \idx[Constant]{LAL\_TYPE\_SIZE\_MASK}
* \idx[Constant]{LAL\_FLTPT\_TYPE\_FLAG}
* \idx[Constant]{LAL\_CMPLX\_TYPE\_FLAG}
* \idx[Constant]{LAL\_UNSGN\_TYPE\_FLAG}
* \idx[Constant]{LAL\_CHAR\_TYPE\_CODE}
* \idx[Constant]{LAL\_I2\_TYPE\_CODE}
* \idx[Constant]{LAL\_I4\_TYPE\_CODE}
* \idx[Constant]{LAL\_I8\_TYPE\_CODE}
* \idx[Constant]{LAL\_UCHAR\_TYPE\_CODE}
* \idx[Constant]{LAL\_U2\_TYPE\_CODE}
* \idx[Constant]{LAL\_U4\_TYPE\_CODE}
* \idx[Constant]{LAL\_U8\_TYPE\_CODE}
* \idx[Constant]{LAL\_S\_TYPE\_CODE}
* \idx[Constant]{LAL\_D\_TYPE\_CODE}
* \idx[Constant]{LAL\_C\_TYPE\_CODE}
* \idx[Constant]{LAL\_Z\_TYPE\_CODE}
* \idx[Type]{LALTYPECODE}
*
* The following constants specify the size, in bytes, of the atomic dataty
pe.
*
* \begin{center}
* \begin{tabular}{|lcl|}
* \hline
* Name & Octal Value & Description \\
* \hline
* \tt LAL\_1\_BYTE\_TYPE\_SIZE & 000 & 1 byte type \\
* \tt LAL\_2\_BYTE\_TYPE\_SIZE & 001 & 2 byte type \\
* \tt LAL\_4\_BYTE\_TYPE\_SIZE & 002 & 4 byte type \\
* \tt LAL\_8\_BYTE\_TYPE\_SIZE & 003 & 8 byte type \\
* \tt LAL\_16\_BYTE\_TYPE\_SIZE & 004 & 16 byte type \\
* \tt LAL\_TYPE\_SIZE\_MASK & 007 & Mask for byte type size fields \\
* \hline
* \end{tabular}
* \end{center}
*
* \noindent
* The constant \verb+LAL_TYPE_SIZE_MASK+ is useful in extracting the size
* information from other type attributes. For example, the size, in bytes
,
* of an atomic datatype can be found using something like the following:
* \begin{verbatim}
* UINT4 code = LAL_S_TYPE_CODE;
* UINT4 size = 1U << ( code & LAL_TYPE_SIZE_MASK );
* \end{verbatim}
*
* \vspace{3ex}
*
* The following constants are flags describing the type attributes. A typ
e
* is either an integer or a floating-point, either purely real or complex,
* and, if integer, is either signed or unsigned.
*
* \begin{center}
* \begin{tabular}{|lcl|}
* \hline
* Name & Octal Value & Description \\
* \hline
* \tt LAL\_FLTPT\_TYPE\_FLAG & 010 & Floating-point (not integer) type \\
* \tt LAL\_CMPLX\_TYPE\_FLAG & 020 & Complex (not purely real) type \\
* \tt LAL\_UNSGN\_TYPE\_FLAG & 040 & Unsigned (no sign info) type \\
* \hline
* \end{tabular}
* \end{center}
*
* To get the actual type, these flags are combined together and with the
* type size constants using the bitwise-or operator (\verb+|+). For examp
le,
* an eight-byte floating point number would be
* \verb+LAL_8_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG+.
* Conceivably you could have a complex type made from a pair of unsigned
* one-byte integers that would be specified as
* \verb+LAL_1_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL_UNSGN_TYPE_FLAG+.
* Fortunately, there are none of these in LAL. Attribues of a particular
* type can be extracted using the bitwise-and operator. For example:
* \begin{verbatim}
* UINT4 code = LAL_S_TYPE_CODE;
* UINT4 isfloat = ( code & LAL_FLTPT_TYPE_FLAG );
* UINT4 iscmplx = ( code & LAL_CMPLX_TYPE_FLAG );
* \end{verbatim}
*
* \vspace{3ex}
*
* The following constants correspond to the types that actually exist in L
AL.
* Their enumeration is the type \verb+LALTYPECODE+.
* \begin{center}
* \begin{tabular}{|lcl|}
* \hline
* Name & Octal Value & Corresponding Type \\
* \hline
* \tt LAL\_CHAR\_TYPE\_CODE & 000 & \tt CHAR \\
* \tt LAL\_I2\_TYPE\_CODE & 001 & \tt INT2 \\
* \tt LAL\_I4\_TYPE\_CODE & 002 & \tt INT4 \\
* \tt LAL\_I8\_TYPE\_CODE & 003 & \tt INT8 \\
* \tt LAL\_UCHAR\_TYPE\_CODE & 040 & \tt UCHAR \\
* \tt LAL\_U2\_TYPE\_CODE & 041 & \tt UINT2 \\
* \tt LAL\_U4\_TYPE\_CODE & 042 & \tt UINT4 \\
* \tt LAL\_U8\_TYPE\_CODE & 043 & \tt UINT8 \\
* \tt LAL\_S\_TYPE\_CODE & 012 & \tt REAL4 \\
* \tt LAL\_D\_TYPE\_CODE & 013 & \tt REAL8 \\
* \tt LAL\_C\_TYPE\_CODE & 033 & \tt COMPLEX8 \\
* \tt LAL\_Z\_TYPE\_CODE & 034 & \tt COMPLEX16 \\
* \hline
* \end{tabular}
* \end{center}
*
**** </lalLaTeX> */
/* constants */ /* ---------- constants ---------- */
/** Type size constants. */ /** Type size constants, see \ref LALDatatypes for more details. */
enum enum
{ {
LAL_1_BYTE_TYPE_SIZE = 000, /**< One byte size 00 = 0 */ LAL_1_BYTE_TYPE_SIZE = 000, /**< One byte size 00 = 0 */
LAL_2_BYTE_TYPE_SIZE = 001, /**< Two byte size 01 = 1 */ LAL_2_BYTE_TYPE_SIZE = 001, /**< Two byte size 01 = 1 */
LAL_4_BYTE_TYPE_SIZE = 002, /**< Four byte size 010 = 2 */ LAL_4_BYTE_TYPE_SIZE = 002, /**< Four byte size 010 = 2 */
LAL_8_BYTE_TYPE_SIZE = 003, /**< Eight byte size 011 = 3 */ LAL_8_BYTE_TYPE_SIZE = 003, /**< Eight byte size 011 = 3 */
LAL_16_BYTE_TYPE_SIZE = 004, /**< Sixteen byte size 0100 = 4 */ LAL_16_BYTE_TYPE_SIZE = 004, /**< Sixteen byte size 0100 = 4 */
LAL_TYPE_SIZE_MASK = 007 /**< Type size mask 0111 = 7 */ LAL_TYPE_SIZE_MASK = 007 /**< Type size mask 0111 = 7 */
}; };
/** Type flag constants. */ /** Type flag constants, see \ref LALDatatypes for more details. */
enum enum
{ {
LAL_FLTPT_TYPE_FLAG = 010, /**< Floating-point (vs integer) type 0100 0 = 8 */ LAL_FLTPT_TYPE_FLAG = 010, /**< Floating-point (vs integer) type 0100 0 = 8 */
LAL_CMPLX_TYPE_FLAG = 020, /**< Complex (vs real) type 010000 = 16 * / LAL_CMPLX_TYPE_FLAG = 020, /**< Complex (vs real) type 010000 = 16 * /
LAL_UNSGN_TYPE_FLAG = 040 /**< Unsigned (vs signed) type 0100000 = 3 2 */ LAL_UNSGN_TYPE_FLAG = 040 /**< Unsigned (vs signed) type 0100000 = 3 2 */
}; };
/** Type codes: use these type codes to identify a LAL atomic data type. /** Type codes: use these type codes to identify a LAL atomic data type, se
*/ e \ref LALDatatypes for more details. */
typedef enum typedef enum
{ {
LAL_CHAR_TYPE_CODE = LAL_1_BYTE_TYPE_SIZE, /**< CHAR type code (0) */ LAL_CHAR_TYPE_CODE = LAL_1_BYTE_TYPE_SIZE, /**< CHAR type code (0) */
LAL_I2_TYPE_CODE = LAL_2_BYTE_TYPE_SIZE, /**< INT2 type code (1) */ LAL_I2_TYPE_CODE = LAL_2_BYTE_TYPE_SIZE, /**< INT2 type code (1) */
LAL_I4_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE, /**< INT4 type code (2) */ LAL_I4_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE, /**< INT4 type code (2) */
LAL_I8_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE, /**< INT8 type code (3) */ LAL_I8_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE, /**< INT8 type code (3) */
LAL_UCHAR_TYPE_CODE = LAL_1_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UCHAR type code (32) */ LAL_UCHAR_TYPE_CODE = LAL_1_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UCHAR type code (32) */
LAL_U2_TYPE_CODE = LAL_2_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UINT2 type code (33) */ LAL_U2_TYPE_CODE = LAL_2_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UINT2 type code (33) */
LAL_U4_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UINT4 type code (34) */ LAL_U4_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UINT4 type code (34) */
LAL_U8_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UINT8 type code (35) */ LAL_U8_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, /** < UINT8 type code (35) */
LAL_S_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG, /** < REAL4 type code (18) */ LAL_S_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG, /** < REAL4 type code (18) */
LAL_D_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG, /** < REAL8 type code (19) */ LAL_D_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG, /** < REAL8 type code (19) */
LAL_C_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL_ FLTPT_TYPE_FLAG, /**< COMPLEX8 type code (27) */ LAL_C_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL_ FLTPT_TYPE_FLAG, /**< COMPLEX8 type code (27) */
LAL_Z_TYPE_CODE = LAL_16_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL _FLTPT_TYPE_FLAG /**< COMPLEX16 type code (28) */ LAL_Z_TYPE_CODE = LAL_16_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL _FLTPT_TYPE_FLAG /**< COMPLEX16 type code (28) */
} }
LALTYPECODE; LALTYPECODE;
#include <lal/LALRCSID.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
NRCSID (LALDATATYPESH, "$Id$"); /* ---------- Vector types ---------- */
/* <lalLaTeX>
\newpage
\subsection{Aggregate datatypes}
\label{ss:aggregate-datatypes}
These datatypes store arbitrarily large sets or collections of
primitive datatypes. At this level there is no physical
interpretation assigned to the objects (such as names or units); the
aggregate datatypes simply collect and arrange the primitive
datatypes. The following types of aggregate datatypes are defines:
vectors, arrays, sequences, vector sequences, and array sequences.
\vspace{2ex}
\begin{verbatim}
<datatype>Vector
\end{verbatim}
This structure stores an ordered set of $n$ elements of type
\verb@<datatype>@, which can be any primitive datatype. The data are
to be interpreted as being a point in an $n$-dimensional vector space.
The fields are:
\begin{description}
\item[\texttt{UINT4 length}] The number of data $n$.
\item[\texttt{<datatype> *data}] Pointer to the data array. The data
are stored sequentially as \verb@data[@$0,\ldots,n-1$\verb@]@.
\end{description}
</lalLaTeX> */
/** \name Aggregate datatypes. /** Vector of type CHAR, see \ref ss_Vector for more details. */
*
* These datatypes store arbitrarily large sets or collections of
* primitive datatypes. At this level there is no physical
* interpretation assigned to the objects (such as names or units); the
* aggregate datatypes simply collect and arrange the primitive
* datatypes. The following types of aggregate datatypes are defines:
* vectors, arrays, sequences, vector sequences, and array sequences.
*
* \b Vector structures store an ordered set of \a n elements of any
* primative datatype.
*
* \b Sequence structures are synonyms for Vector structures.
*
* \b Array structures store a set of elements of any primative
* datatype, arranged as an \a m dimensional
* array. That is, each element can be thought of as having \a m
* indecies, \f$A_{i_0\cdots i_{m-1}}\f$, where each index \f$i_k\f$
* runs over its own range \f$0,\ldots,n_k-1\f$. The total number of
* elements is then \f$N=n_0\times\cdots\times n_{m-1}\f$. In memory the
* array is flattened so that the elements are stored sequentially in
* a contiguous block. That is, the array of memory is packed so that
* element \f$A_{i_0\cdots i_{m-1}}\f$ is stored as
* \f$\mathtt{data[}i_{m-1} + n_{m-2}\times(i_{m-2} +
* n_{m-3}\times(\cdots(i_1 + n_0\times i_0)\cdots))\mathtt{]}\f$.
*
* \b VectorSequence structures store an ordered set of \a l elements of ty
pe
* \c \<datatype\>Vector, where \c \<datatype\> can be any primitive
* datatype. Mathematically the sequence can be written as
* \f$\{\vec{v}^{(0)},\ldots,\vec{v}^{(l-1)}\}\f$, where each element
* \f$\vec{v}^{(j)}=(v^{(j)}_0,\ldots,v^{(i)}_{n-1})\f$ is a vector of leng
th
* \f$n\f$. In memory the elements are flattened; that is, they are
* stored sequentially in a contiguous block of memory such that
* element \f$v^{(j)}_i\f$ is stored as
* \f$\mathtt{data[}j\times n + i\mathtt{]}\f$.
*
* \b ArraySequence structures stores an ordered set of \a l elements of ty
pe
* \c \<datatype\>Array where \c \<datatype\> can be any primitive
* datatype. The indexing of an array sequence can get quite
* complicated; it helps to read first the documentation for data arrays,
* above. Mathematically the data can be written as a set
* \f$\{A^{(j)}_{i_0\cdots i_{m-1}}\f$, where the sequence number
* \f$j\f$ runs from 0 to \f$l-1\f$, and each array index \f$i_k\f$ runs ov
er its own
* range \f$0,\ldots,n_k-1\f$. The total number of data in a given array
* element is then \f$N=n_0\times\cdots\times n_{m-1}\f$, and the total
* number of data in the sequence is \f$N\times l\f$. In memory the array
is
* flattened so that the elements are stored sequentially in a
* contiguous block.
* The element
* \f$A^{(j)}_{i_0\cdots i_{m-1}}\f$ is stored as
* \f$\mathtt{data[}j\times N + i_{m-1} + n_{m-2}\times(i_{m-2} +
* 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
* array element before incrementing to the next array element.
*
*/
/*@{*/
/** Vector of type CHAR. */
typedef struct typedef struct
tagCHARVector tagCHARVector
{ {
SWIGLAL_STRUCT(CHARVector); SWIGLAL_STRUCT(CHARVector);
SWIGLAL_DYNAMIC_1DARRAY(CHAR, data, UINT4, length); 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', see \ref ss_Vector for more details . */
typedef struct tagLALStringVector { typedef struct tagLALStringVector {
SWIGLAL_STRUCT(LALStringVector); SWIGLAL_STRUCT(LALStringVector);
SWIGLAL_DYNAMIC_1DARRAY(CHAR*, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagINT2Vector tagINT2Vector
{ {
SWIGLAL_STRUCT(INT2Vector); SWIGLAL_STRUCT(INT2Vector);
SWIGLAL_DYNAMIC_1DARRAY(INT2, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagUINT2Vector tagUINT2Vector
{ {
SWIGLAL_STRUCT(UINT2Vector); SWIGLAL_STRUCT(UINT2Vector);
SWIGLAL_DYNAMIC_1DARRAY(UINT2, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagINT4Vector tagINT4Vector
{ {
SWIGLAL_STRUCT(INT4Vector); SWIGLAL_STRUCT(INT4Vector);
SWIGLAL_DYNAMIC_1DARRAY(INT4, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagUINT4Vector tagUINT4Vector
{ {
SWIGLAL_STRUCT(UINT4Vector); SWIGLAL_STRUCT(UINT4Vector);
SWIGLAL_DYNAMIC_1DARRAY(UINT4, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagINT8Vector tagINT8Vector
{ {
SWIGLAL_STRUCT(INT8Vector); SWIGLAL_STRUCT(INT8Vector);
SWIGLAL_DYNAMIC_1DARRAY(INT8, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagUINT8Vector tagUINT8Vector
{ {
SWIGLAL_STRUCT(UINT8Vector); SWIGLAL_STRUCT(UINT8Vector);
SWIGLAL_DYNAMIC_1DARRAY(UINT8, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct typedef struct
tagREAL4Vector tagREAL4Vector
{ {
SWIGLAL_STRUCT(REAL4Vector); SWIGLAL_STRUCT(REAL4Vector);
SWIGLAL_DYNAMIC_1DARRAY(REAL4, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct tagREAL8Vector typedef struct tagREAL8Vector
{ {
SWIGLAL_STRUCT(REAL8Vector); SWIGLAL_STRUCT(REAL8Vector);
SWIGLAL_DYNAMIC_1DARRAY(REAL8, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct tagCOMPLEX8Vector typedef struct tagCOMPLEX8Vector
{ {
SWIGLAL_STRUCT(COMPLEX8Vector); SWIGLAL_STRUCT(COMPLEX8Vector);
SWIGLAL_DYNAMIC_1DARRAY(COMPLEX8, data, UINT4, length); 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, see \ref ss_Vector for more details. */
typedef struct tagCOMPLEX16Vector typedef struct tagCOMPLEX16Vector
{ {
SWIGLAL_STRUCT(COMPLEX16Vector); SWIGLAL_STRUCT(COMPLEX16Vector);
SWIGLAL_DYNAMIC_1DARRAY(COMPLEX16, data, UINT4, length); 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> /* ---------- Array types ---------- */
\vspace{2ex}
\begin{verbatim}
<datatype>Array
\end{verbatim}
This structure stores a set of elements of type \verb@<datatype>@,
which can be any primitive datatype, arranged as an $m$-dimensional
array. That is, each element can be thought of as having $m$
indecies, $\mathsf{A}_{i_0\cdots i_{m-1}}$, where each index $i_k$
runs over its own range $0,\ldots,n_k-1$. The total number of
elements is then $N=n_0\times\cdots\times n_{m-1}$. In memory the
array is ``flattened'' so that the elements are stored sequentially in
a contiguous block. The fields are:
\begin{description}
\item[\texttt{UINT4Vector *dimLength}] Pointer to a vector of length
$m$, storing the index ranges $(n_0,\ldots,n_{m-1})$.
\item[\texttt{<datatype> *data}] Pointer to the data array. The data
element $\mathsf{A}_{i_0\cdots i_{m-1}}$ is stored as
\verb@data[@$i_{m-1} + n_{m-2}\times(i_{m-2} +
n_{m-3}\times(\cdots(i_1 + n_0\times i_0)\cdots))$\verb@]@; that is,
the index of \verb@data[]@ runs over the entire range of an index
$i_{k+1}$ before incrementing $i_k$.
\end{description}
</lalLaTeX> */
/** Multidimentional array of INT2. */ /** Multidimentional array of INT2, see \ref ss_Array for more details. */
typedef struct typedef struct
tagINT2Array tagINT2Array
{ {
SWIGLAL_STRUCT(INT2Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagUINT2Array tagUINT2Array
{ {
SWIGLAL_STRUCT(UINT2Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagINT4Array tagINT4Array
{ {
SWIGLAL_STRUCT(INT4Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagUINT4Array tagUINT4Array
{ {
SWIGLAL_STRUCT(UINT4Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagINT8Array tagINT8Array
{ {
SWIGLAL_STRUCT(INT8Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagUINT8Array tagUINT8Array
{ {
SWIGLAL_STRUCT(UINT8Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagREAL4Array tagREAL4Array
{ {
SWIGLAL_STRUCT(REAL4Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagREAL8Array tagREAL8Array
{ {
SWIGLAL_STRUCT(REAL8Array); 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, see \ref ss_Array for more details. */
typedef struct typedef struct
tagCOMPLEX8Array tagCOMPLEX8Array
{ {
SWIGLAL_STRUCT(COMPLEX8Array); 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, see \ref ss_Array for more details . */
typedef struct typedef struct
tagCOMPLEX16Array tagCOMPLEX16Array
{ {
SWIGLAL_STRUCT(COMPLEX16Array); 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> /* ---------- Sequence types ---------- */
\vspace{2ex}
\begin{verbatim}
<datatype>Sequence
\end{verbatim}
This structure stores an ordered set of $l$ elements of type
\verb@<datatype>@, which can be any primitive datatype. It is
identical to \verb@<datatype>Vector@, except that the elements are to
be interpreted as $l$ consecutive elements rather than the components
of an $l$-dimensional vector. The fields are:
\begin{description}
\item[\texttt{UINT4 length}] The number of data $l$.
\item[\texttt{<datatype> *data}] Pointer to the data array. The data
are stored sequentially as \verb@data[@$0,\ldots,l-1$\verb@]@.
\end{description}
</lalLaTeX> */
typedef CHARVector CHARSequence;
typedef INT2Vector INT2Sequence;
typedef UINT2Vector UINT2Sequence;
typedef INT4Vector INT4Sequence;