| 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 | |
|---|
|
| 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 | |
|---|
|
| 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 ".. | |
| | | ." | |
| | | 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"</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 | |
|---|
|
| 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 | |
|---|
|
| 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 | |
|---|
|
| 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 | |
|---|
|
| 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 | |
|---|
|
| 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 | |
|---|
|
| 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; | |