LAL  7.1.7.1-f7f2ccf

## Detailed Description

Provides the basic LAL datatypes.

### Synopsis

#include <lal/LALDatatypes.h>

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, and is described in Header LALStatusMacros.h.

This header file is automatically included by Header LALStdlib.h. In turn, this header file starts by including LALAtomicDatatypes.h, which is discussed in the following section.

# Primitive 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). The non-complex datatypes are known as atomic 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 int32_t. While the size of types such as int and long int are platform dependent, the sizes of INT4 and INT8 is always 4- and 8-bytes respectively (platform independent). REAL4 and REAL8 are always type float and double 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 long int rather than type long long int.

The primitive datatypes are defined in a separate header LALAtomicDatatypes.h, which is included by LALDatatypes.h. This is done in order to facilitate the interface between LAL and non-LAL modules. By including just 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 atomic datatypes and the complex datatypes.

## 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 usually correspond.

TypeBytesRangeUsual C/C++ type
CHAR1'\0' to '\255'char
UCHAR1'\0' to '\255'unsigned char
BOOLEAN10 or positiveunsigned char
INT22$$-2^{-15}$$ to $$2^{15}-1$$short
INT44$$-2^{-31}$$ to $$2^{31}-1$$int or long
INT88$$-2^{-63}$$ to $$2^{63}-1$$long long
UINT220 to $$2^{16}-1$$unsigned short
UINT440 to $$2^{32}-1$$unsigned int or long
UINT880 to $$2^{64}-1$$unsigned long long
REAL44$$-3.4\times10^{38}$$ to $$3.4\times10^{38}$$float
REAL88$$-1.8\times10^{308}$$ to $$1.8\times10^{308}$$double

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 REAL4 and 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:

 REAL4 REAL8 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

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 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.

## Complex datatypes

LAL uses native C99 datatypes float complex and double complex to represent complex numbers. These are considered primitive datatypes (rather than aggregate or structured datatypes) because they conceptually represent a single number. Furthermore, atomic and complex datatypes are treated equivalently by LAL aggregate and structured datatypes. The two complex datatypes are COMPLEX8 and COMPLEX16. Macros are provided for constructing COMPLEX8 and COMPLEX16 values from rectangular (crectf, crect) and polar (cpolarf, cpolar) coordinates.

# Atomic datatypes codes

The following constants specify the size, in bytes, of the atomic datatype.

NameOctal ValueDescription
LAL_1_BYTE_TYPE_SIZE0001 byte type
LAL_2_BYTE_TYPE_SIZE0012 byte type
LAL_4_BYTE_TYPE_SIZE0024 byte type
LAL_8_BYTE_TYPE_SIZE0038 byte type
LAL_16_BYTE_TYPE_SIZE00416 byte type

The constant 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:

UINT4 size = 1U << ( code & LAL_TYPE_SIZE_MASK );

The following constants are flags describing the type attributes. A type is either an integer or a floating-point, either purely real or complex, and, if integer, is either signed or unsigned.

NameOctal ValueDescription
LAL_FLTPT_TYPE_FLAG010Floating-point (not integer) type
LAL_CMPLX_TYPE_FLAG020Complex (not purely real) type

To get the actual type, these flags are combined together and with the type size constants using the bitwise-or operator (|). For example, an eight-byte floating point number would be (LAL_8_BYTE_TYPE_SIZE | 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 (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:

UINT4 isfloat = ( code & LAL_FLTPT_TYPE_FLAG );
UINT4 iscmplx = ( code & LAL_CMPLX_TYPE_FLAG );

The following constants correspond to the types that actually exist in LAL. Their enumeration is the type LALTYPECODE.

NameOctal ValueCorresponding Type
LAL_CHAR_TYPE_CODE000CHAR
LAL_I2_TYPE_CODE001INT2
LAL_I4_TYPE_CODE002INT4
LAL_I8_TYPE_CODE003INT8
LAL_UCHAR_TYPE_CODE040UCHAR
LAL_U2_TYPE_CODE041UINT2
LAL_U4_TYPE_CODE042UINT4
LAL_U8_TYPE_CODE043UINT8
LAL_S_TYPE_CODE012REAL4
LAL_D_TYPE_CODE013REAL8
LAL_C_TYPE_CODE033COMPLEX8
LAL_Z_TYPE_CODE034COMPLEX16

# 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.

## DATATYPE-Vector types

This structure stores an ordered set of $$n$$ elements of type <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:

• UINT4 length: The number of data $$n$$.
• <datatype> *data: Pointer to the data array. The data are stored sequentially as $$\mathtt{data}[0,\ldots,n-1]$$.

## DATATYPE-Array types

This structure stores a set of elements of type <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:

• UINT4Vector *dimLength: Pointer to a vector of length $$m$$, storing the index ranges $$(n_0,\ldots,n_{m-1})$$.
• <datatype> *data: Pointer to the data array. The data element $$\mathsf{A}_{i_0\cdots i_{m-1}}$$ is stored as $$\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))]$$; that is, the index of data[] runs over the entire range of an index $$i_{k+1}$$ before incrementing $$i_k$$.

The concrete types are INT2Array, UINT2Array, INT4Array, UINT4Array, INT8Array, UINT8Array, REAL4Array, REAL8Array, COMPLEX8Array, COMPLEX16Array.

## DATATYPE-Sequence types

This structure stores an ordered set of $$l$$ elements of type <datatype>, which can be any primitive datatype. It is identical to <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:

• UINT4 length: The number of data $$l$$.
• <datatype> *data: Pointer to the data array. The data are stored sequentially as $$\mathtt{data}[0, \ldots, l-1]$$.

The concrete types are CHARVector, INT2Vector, UINT2Vector, INT4Vector, UINT4Vector, INT8Vector, UINT8Vector, REAL4Vector, REAL8Vector, COMPLEX8Vector, COMPLEX16Vector.

## DATATYPE-VectorSequence types

This structure stores an ordered set of $$l$$ elements of type <datatype>Vector, where <datatype> can be any primitive datatype. Mathematically the sequence can be written as $$\{\vec{v}^{(0)},\ldots,\vec{v}^{(l-1)}\}$$, where each element $$\vec{v}^{(j)}=(v^{(j)}_0,\ldots,v^{(i)}_{n-1})$$ is a vector of length $$n$$. In memory the elements are "flattened"; that is, they are stored sequentially in a contiguous block of memory. The fields are:

• UINT4 length: The number of vectors $$l$$.
• UINT4 vectorLength: The length $$n$$ of each vector.
• <datatype> *data: Pointer to the data array. The data element $$v^{(j)}_i$$ is stored as $$\mathtt{data}[j\times n + i]$$; that is, the index of data[] runs over the internal index of each vector element before incrementing to the next vector element.

## DATATYPE-ArraySequence types

This structure stores an ordered set of $$l$$ elements of type <datatype>Array, where <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 $$\{\mathsf{A}^{(j)}_{i_0\cdots i_{m-1}}$$, where the sequence number $$j$$ runs from 0 to $$l-1$$, and each array index $$i_k$$ runs over its own range $$0,\ldots,n_k-1$$. The total number of data in a given array element is then $$N=n_0\times\cdots\times n_{m-1}$$, and the total number of data in the sequence is $$N\times l$$. In memory the array is "flattened" so that the elements are stored sequentially in a contiguous block. The fields are:

• UINT4 length: The number $$l$$ of array elements in the sequence.
• UINT4 arrayDim: The number of data $$N$$ (not the number of indecies $$m$$) in each array element of the sequence.
• UINT4Vector *dimLength: Pointer to a vector of length $$m$$, storing the index ranges $$(n_0,\ldots,n_{m-1})$$.
• <datatype> *data: Pointer to the data. The element $$\mathsf{A}^{(j)}_{i_0\cdots i_{m-1}}$$ is stored as $$\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))]$$; that is, the index of data[] runs over the internal indecies of each array element before incrementing to the next array element.

# Structured datatypes

These datatypes embed primitive and aggregate datatypes inside structures that define their physical meaning. Most of these structures are wrappers for aggregate datatypes that store a physical quantity as a function of time or frequency. Other structures store specific physical information, such as the GPS time, or the factored response function of a filter.

## LIGOTimeGPS type

The LIGOTimeGPS structure stores the time, to nanosecond precision, synchronized to the Global Positioning System time reference. The zero time for the GPS standard is the moment of midnight beginning January 6, 1980, UTC. The LIGOTimeGPS structure can represent times up to 68 years on either side of this epoch. (Note that this is better than an equivalently-sized REAL8 representation of time, which can maintain nanosecond precision only for times within 104 days of its reference point. However, the REAL8 representation does allow one to cover arbitrarily long timescales at correspondingly lower precision.)

The macro LIGOTIMEGPSZERO can be used to statically initialize a LIGOTimeGPS object, for example:

## DATATYPE-TimeSeries types

This structure represents a sequence of data of type <datatype> (where <datatype> can be any primitive datatype), sampled over uniform time intervals $$t_0, t_0+\Delta t, \ldots , t_0+l\Delta t$$. Essentially this is a <datatype>Sequence with extra fields defining the sample times and the type of data being sampled. The raw data may also have been heterodyned; that is, multiplied by a sinusoid of some frequency $$f_0$$, low-pass filtered, and resampled, in order to extract the behaviour in a small bandwidth about $$f_0$$. The fields are:

• CHAR name[LALNameLength]: The name of the data series (i.e. the type of data being sampled).
• LIGOTimeGPS epoch: The start time $$t_0$$ of the data series.
• REAL8 deltaT: The sampling interval $$\Delta t$$, in seconds.
• REAL8 f0: The heterodyning frequency $$f_0$$, in Hertz.
• LALUnit sampleUnits: The physical units of the quantity being sampled.
• <datatype>Sequence *data: The sequence of sampled data.

## DATATYPE-TimeVectorSeries

Like <datatype>TimeSeries, above, except that the sampled data are of type <datatype>Vector (where <datatype> can be any primitive datatype). The fields are:

• CHAR name[LALNameLength]: The name of the data series (i.e. the type of data being sampled).
• LIGOTimeGPS epoch: The start time of the data series.
• REAL8 deltaT: The sampling interval, in seconds.
• REAL8 f0: The heterodyning frequency, in Hertz.
• LALUnit sampleUnits: The physical units of the quantity being sampled.
• <datatype>VectorSequence *data: The sequence of sampled data.

## DATATYPE-TimeArraySeries types

Like <datatype>TimeSeries, above, except that the sampled data are of type <datatype>Array (where <datatype> can be any primitive datatype). The fields are:

• CHAR name[LALNameLength]: The name of the data series (i.e. the type of data being sampled).
• LIGOTimeGPS epoch: The start time of the data series.
• REAL8 deltaT: The sampling interval, in seconds.
• REAL8 f0: The heterodyning frequency, in Hertz.
• LALUnit sampleUnits: The physical units of the quantity being sampled.
• <datatype>ArraySequence *data: The sequence of sampled data.

## DATATYPE-FrequencySeries types

This structure represents a frequency spectrum of data of type <datatype> (where <datatype> can be any primitive datatype), sampled over uniform frequency intervals $$f_0, f_0+\Delta f, \ldots , f_0+l\Delta f$$. Essentially this is a <datatype>Sequence with extra fields defining the sample frequencies, the timestamp of the spectrum, and the type of data being sampled. The fields are:

• CHAR name[LALNameLength]: The name of the data series (i.e. the type of data being sampled).
• LIGOTimeGPS epoch: The start time of the time series from which the spectrum was calculated.
• REAL8 f0: The lowest frequency $$f_0$$ being sampled, in Hertz.
• REAL8 deltaF: The frequency sampling interval $$\Delta f$$, in Hertz.
• LALUnit sampleUnits: The physical units of the quantity being sampled.
• <datatype>Sequence *data: The sequence of sampled data.

## DATATYPE-ZPGFilter types

This structure stores the complex frequency response of a filter or transfer function in a factored form, where <datatype> can be either COMPLEX8 or COMPLEX16. One defines a (dimensionless) complex frequency variable $$\zeta(f\Delta t)$$, where $$\Delta t$$ is the time sampling interval of the data to which the filter will be applied (in the case of a digital filter), or some other reference timescale (in the case of an analog filter). The complex response function can then be given (or approximated) as $$H(f)=g\times\prod_k(\zeta-z_k)/\prod_l(\zeta-p_l)$$, where $$z_k$$ are the complex zeros, $$p_l$$ are the complex poles, and $$g$$ is the complex gain of the response function. Some common complex frequency representations are the $$z$$-plane representation $$\zeta(f\Delta t)=\exp(2\pi if\Delta t)$$, which maps the Nyquist interval $$f\in[0,1/2\Delta t)$$ onto the upper-half unit circle in $$\zeta$$, and the $$w$$-plane representation $$\zeta(f\Delta t)=\tan(\pi f\Delta t)$$, which maps the Nyquist interval onto the positive real axis in $$\zeta$$.

The fields of <datatype>ZPGFilter are:

• CHAR name[LALNameLength]: The name of the filter or transfer function. This should also mention its complex frequency representation.
• REAL8 deltaT: The sampling time or reference timescale $$\Delta t$$ for the filter, in seconds. If zero, it will be treated as being equal to the sampling interval of the data being filtered.
• <datatype>Vector *zeros: Pointer to a vector storing the zeros $$z_k$$ of the filter.
• <datatype>Vector *poles: Pointer to a vector storing the poles $$p_k$$ of the filter.
• <datatype> gain: The gain $$g$$ of the filter.

The concrete types are COMPLEX8ZPGFilter and COMPLEX16ZPGFilter.

## Data Structures

struct  CHARVector
Vector of type CHAR, see DATATYPE-Vector types for more details. More...

struct  LALStringVector
Vector of type CHAR*, ie 'strings', see DATATYPE-Vector types for more details. More...

struct  INT2Vector
Vector of type INT2, see DATATYPE-Vector types for more details. More...

struct  UINT2Vector
Vector of type UINT2, see DATATYPE-Vector types for more details. More...

struct  INT4Vector
Vector of type INT4, see DATATYPE-Vector types for more details. More...

struct  UINT4Vector
Vector of type UINT4, see DATATYPE-Vector types for more details. More...

struct  INT8Vector
Vector of type INT8, see DATATYPE-Vector types for more details. More...

struct  UINT8Vector
Vector of type UINT8, see DATATYPE-Vector types for more details. More...

struct  REAL4Vector
Vector of type REAL4, see DATATYPE-Vector types for more details. More...

struct  REAL8Vector
Vector of type REAL8, see DATATYPE-Vector types for more details. More...

struct  COMPLEX8Vector
Vector of type COMPLEX8, see DATATYPE-Vector types for more details. More...

struct  COMPLEX16Vector
Vector of type COMPLEX16, see DATATYPE-Vector types for more details. More...

struct  INT2Array
Multidimentional array of INT2, see DATATYPE-Array types for more details. More...

struct  UINT2Array
Multidimentional array of UINT2, see DATATYPE-Array types for more details. More...

struct  INT4Array
Multidimentional array of INT4, see DATATYPE-Array types for more details. More...

struct  UINT4Array
Multidimentional array of UINT4, see DATATYPE-Array types for more details. More...

struct  INT8Array
Multidimentional array of INT8, see DATATYPE-Array types for more details. More...

struct  UINT8Array
Multidimentional array of UINT8, see DATATYPE-Array types for more details. More...

struct  REAL4Array
Multidimentional array of REAL4, see DATATYPE-Array types for more details. More...

struct  REAL8Array
Multidimentional array of REAL8, see DATATYPE-Array types for more details. More...

struct  COMPLEX8Array
Multidimentional array of COMPLEX8, see DATATYPE-Array types for more details. More...

struct  COMPLEX16Array
Multidimentional array of COMPLEX16, see DATATYPE-Array types for more details. More...

struct  CHARVectorSequence
Sequence of CHAR Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  INT2VectorSequence
Sequence of INT2 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  UINT2VectorSequence
Sequence of UINT2 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  INT4VectorSequence
Sequence of INT4 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  UINT4VectorSequence
Sequence of UINT4 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  INT8VectorSequence
Sequence of INT8 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  UINT8VectorSequence
Sequence of UINT8 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  REAL4VectorSequence
Sequence of REAL4 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  REAL8VectorSequence
Sequence of REAL8 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  COMPLEX8VectorSequence
Sequence of COMPLEX8 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  COMPLEX16VectorSequence
Sequence of COMPLEX16 Vectors, see DATATYPE-VectorSequence types for more details. More...

struct  INT2ArraySequence
Sequence of INT2 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  UINT2ArraySequence
Sequence of UINT2 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  INT4ArraySequence
Sequence of INT4 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  UINT4ArraySequence
Sequence of UINT4 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  INT8ArraySequence
Sequence of INT8 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  UINT8ArraySequence
Sequence of UINT8 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  REAL4ArraySequence
Sequence of REAL4 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  REAL8ArraySequence
Sequence of REAL8 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  COMPLEX8ArraySequence
Sequence of COMPLEX8 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  COMPLEX16ArraySequence
Sequence of COMPLEX16 multidimensional arrays, see DATATYPE-ArraySequence types for more details. More...

struct  LIGOTimeGPS
Epoch relative to GPS epoch, see LIGOTimeGPS type for more details. More...

struct  LALUnit
This structure stores units in the mksA system (plus Kelvin, Strain, and ADC Count). More...

struct  INT2TimeSeries
Time series of INT2 data, see DATATYPE-TimeSeries types for more details. More...

struct  UINT2TimeSeries
Time series of UINT2 data, see DATATYPE-TimeSeries types for more details. More...

struct  INT4TimeSeries
Time series of INT4 data, see DATATYPE-TimeSeries types for more details. More...

struct  UINT4TimeSeries
Time series of UINT4 data, see DATATYPE-TimeSeries types for more details. More...

struct  INT8TimeSeries
Time series of INT8 data, see DATATYPE-TimeSeries types for more details. More...

struct  UINT8TimeSeries
Time series of UINT8 data, see DATATYPE-TimeSeries types for more details. More...

struct  REAL4TimeSeries
Time series of REAL4 data, see DATATYPE-TimeSeries types for more details. More...

struct  REAL8TimeSeries
Time series of REAL8 data, see DATATYPE-TimeSeries types for more details. More...

struct  COMPLEX8TimeSeries
Time series of COMPLEX8 data, see DATATYPE-TimeSeries types for more details. More...

struct  COMPLEX16TimeSeries
Time series of COMPLEX16 data, see DATATYPE-TimeSeries types for more details. More...

struct  INT2TimeVectorSeries
Time series of INT2 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  UINT2TimeVectorSeries
Time series of UINT2 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  INT4TimeVectorSeries
Time series of INT4 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  UINT4TimeVectorSeries
Time series of UINT4 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  INT8TimeVectorSeries
Time series of INT8 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  UINT8TimeVectorSeries
Time series of UINT8 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  REAL4TimeVectorSeries
Time series of REAL4 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  REAL8TimeVectorSeries
Time series of REAL8 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  COMPLEX8TimeVectorSeries
Time series of COMPLEX8 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  COMPLEX16TimeVectorSeries
Time series of COMPLEX16 vectors, see DATATYPE-TimeVectorSeries for more details. More...

struct  INT2TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  UINT2TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  INT4TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  UINT4TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  INT8TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  UINT8TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  REAL4TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  REAL8TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  COMPLEX8TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  COMPLEX16TimeArraySeries
See DATATYPE-TimeArraySeries types for documentation. More...

struct  INT2FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  UINT2FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  INT4FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  UINT4FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  INT8FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  UINT8FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  REAL4FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  REAL8FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  COMPLEX8FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  COMPLEX16FrequencySeries
See DATATYPE-FrequencySeries types for documentation. More...

struct  COMPLEX8ZPGFilter
See DATATYPE-ZPGFilter types for details. More...

struct  COMPLEX16ZPGFilter
See DATATYPE-ZPGFilter types for details. More...

## Typedefs

typedef char CHAR
One-byte signed integer, see Headers LAL(Atomic)Datatypes.h for more details. More...

typedef unsigned char UCHAR
One-byte unsigned integer, see Headers LAL(Atomic)Datatypes.h for more details. More...

typedef unsigned char BOOLEAN
Boolean logical type, see Headers LAL(Atomic)Datatypes.h for more details. More...

typedef int16_t INT2
Two-byte signed integer. More...

typedef int32_t INT4
Four-byte signed integer. More...

typedef uint16_t UINT2
Two-byte unsigned integer. More...

typedef uint32_t UINT4
Four-byte unsigned integer. More...

typedef int64_t INT8
Eight-byte signed integer; on some platforms this is equivalent to long int instead. More...

typedef uint64_t UINT8
Eight-byte unsigned integer; on some platforms this is equivalent to unsigned long int instead. More...

typedef float REAL4
Single precision real floating-point number (4 bytes). More...

typedef double REAL8
Double precision real floating-point number (8 bytes). More...

typedef float complex COMPLEX8
Single-precision floating-point complex number (8 bytes total) More...

typedef double complex COMPLEX16
Double-precision floating-point complex number (16 bytes total) More...

typedef CHARVector CHARSequence
See DATATYPE-Sequence types for documentation. More...

typedef INT2Vector INT2Sequence
See DATATYPE-Sequence types for documentation. More...

typedef UINT2Vector UINT2Sequence
See DATATYPE-Sequence types for documentation. More...

typedef INT4Vector INT4Sequence
See DATATYPE-Sequence types for documentation. More...

typedef UINT4Vector UINT4Sequence
See DATATYPE-Sequence types for documentation. More...

typedef INT8Vector INT8Sequence
See DATATYPE-Sequence types for documentation. More...

typedef UINT8Vector UINT8Sequence
See DATATYPE-Sequence types for documentation. More...

typedef REAL4Vector REAL4Sequence
See DATATYPE-Sequence types for documentation. More...

typedef REAL8Vector REAL8Sequence
See DATATYPE-Sequence types for documentation. More...

typedef COMPLEX8Vector COMPLEX8Sequence
See DATATYPE-Sequence types for documentation. More...

typedef COMPLEX16Vector COMPLEX16Sequence
See DATATYPE-Sequence types for documentation. More...

## Enumerations

enum  {
LAL_1_BYTE_TYPE_SIZE = 000, LAL_2_BYTE_TYPE_SIZE = 001, LAL_4_BYTE_TYPE_SIZE = 002, LAL_8_BYTE_TYPE_SIZE = 003,
LAL_16_BYTE_TYPE_SIZE = 004, LAL_TYPE_SIZE_MASK = 007
}
Type size constants, see Headers LAL(Atomic)Datatypes.h for more details. More...

enum  { LAL_FLTPT_TYPE_FLAG = 010, LAL_CMPLX_TYPE_FLAG = 020, LAL_UNSGN_TYPE_FLAG = 040 }
Type flag constants, see Headers LAL(Atomic)Datatypes.h for more details. More...

enum  LALTYPECODE {
LAL_CHAR_TYPE_CODE = LAL_1_BYTE_TYPE_SIZE, LAL_I2_TYPE_CODE = LAL_2_BYTE_TYPE_SIZE, LAL_I4_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE, LAL_I8_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE,
LAL_UCHAR_TYPE_CODE = LAL_1_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, LAL_U2_TYPE_CODE = LAL_2_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, LAL_U4_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG, LAL_U8_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_UNSGN_TYPE_FLAG,
LAL_S_TYPE_CODE = LAL_4_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG, LAL_D_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_FLTPT_TYPE_FLAG, LAL_C_TYPE_CODE = LAL_8_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL_FLTPT_TYPE_FLAG, LAL_Z_TYPE_CODE = LAL_16_BYTE_TYPE_SIZE | LAL_CMPLX_TYPE_FLAG | LAL_FLTPT_TYPE_FLAG
}
Type codes: use these type codes to identify a LAL atomic data type, see Headers LAL(Atomic)Datatypes.h for more details. More...

enum  {
LALUnitIndexMeter, LALUnitIndexKiloGram, LALUnitIndexSecond, LALUnitIndexAmpere,
}
Indices of arrays corresponding to particular units. More...

enum  enumLALNameLength { LALNameLength = 64 }
Length of name fields of LAL structured data types. More...

## Macros

#define XLAL_INIT_MEM(x)   memset(&(x), 0, sizeof((x)))
MACRO to initialize arbitrary variable 'x' to zero. More...

#define XLAL_INIT_DECL(var, ...)   var __VA_ARGS__; XLAL_INIT_MEM(var)
C99 MACRO to declare and zero-initialize a variable, use as "type XLAL_INIT_DECL(var);". More...

#define XLAL_NUM_ELEM(x)   ( sizeof((x)) / sizeof((x)[0]) )
MACRO which gives the number of elements in a fixed-size array. More...

#define XLAL_LAST_ELEM(x)   (x)[ XLAL_NUM_ELEM(x) - 1 ]
MACRO to access the last element in a fixed-size array. More...

#define LAL_INT8_C(c)   INT64_C(c)
Macro for use in defining v as an INT8 constant. More...

#define LAL_UINT8_C(c)   UINT64_C(c)
Macro for use in defining v as an UINT8 constant. More...

#define _LAL_C99_COMPLEX_NUMBERS_

#define crectf(re, im)   (((REAL4)(re)) + _Complex_I*((REAL4)(im)))
Construct a COMPLEX8 from real and imaginary parts. More...

#define crect(re, im)   (((REAL8)(re)) + _Complex_I*((REAL8)(im)))
Construct a COMPLEX16 from real and imaginary parts. More...

#define cpolarf(r, th)   (((REAL4)(r)) * cexpf(crectf(0, th)))
Construct a COMPLEX8 from polar modulus and argument. More...

#define cpolar(r, th)   (((REAL8)(r)) * cexp(crect(0, th)))
Construct a COMPLEX16 from polar modulus and argument. More...

#define LIGOTIMEGPSZERO   { 0, 0 }
Zero-initializer for LIGOTimeGPS structs. More...

## ◆ CHAR

 typedef char CHAR

One-byte signed integer, see Headers LAL(Atomic)Datatypes.h for more details.

Definition at line 37 of file LALAtomicDatatypes.h.

## ◆ UCHAR

 typedef unsigned char UCHAR

One-byte unsigned integer, see Headers LAL(Atomic)Datatypes.h for more details.

Definition at line 38 of file LALAtomicDatatypes.h.

## ◆ BOOLEAN

 typedef unsigned char BOOLEAN

Boolean logical type, see Headers LAL(Atomic)Datatypes.h for more details.

Definition at line 39 of file LALAtomicDatatypes.h.

## ◆ INT2

 typedef int16_t INT2

Two-byte signed integer.

Definition at line 56 of file LALAtomicDatatypes.h.

## ◆ INT4

 typedef int32_t INT4

Four-byte signed integer.

Definition at line 57 of file LALAtomicDatatypes.h.

## ◆ UINT2

 typedef uint16_t UINT2

Two-byte unsigned integer.

Definition at line 58 of file LALAtomicDatatypes.h.

## ◆ UINT4

 typedef uint32_t UINT4

Four-byte unsigned integer.

Definition at line 59 of file LALAtomicDatatypes.h.

## ◆ INT8

 typedef int64_t INT8

Eight-byte signed integer; on some platforms this is equivalent to long int instead.

Definition at line 61 of file LALAtomicDatatypes.h.

## ◆ UINT8

 typedef uint64_t UINT8

Eight-byte unsigned integer; on some platforms this is equivalent to unsigned long int instead.

Definition at line 62 of file LALAtomicDatatypes.h.

## ◆ REAL4

 typedef float REAL4

Single precision real floating-point number (4 bytes).

Definition at line 102 of file LALAtomicDatatypes.h.

## ◆ REAL8

 typedef double REAL8

Double precision real floating-point number (8 bytes).

Definition at line 103 of file LALAtomicDatatypes.h.

## ◆ COMPLEX8

 typedef float complex COMPLEX8

Single-precision floating-point complex number (8 bytes total)

Definition at line 119 of file LALAtomicDatatypes.h.

## ◆ COMPLEX16

 typedef double complex COMPLEX16

Double-precision floating-point complex number (16 bytes total)

Definition at line 120 of file LALAtomicDatatypes.h.

## ◆ CHARSequence

 typedef CHARVector CHARSequence

See DATATYPE-Sequence types for documentation.

Definition at line 246 of file LALDatatypes.h.

## ◆ INT2Sequence

 typedef INT2Vector INT2Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 247 of file LALDatatypes.h.

## ◆ UINT2Sequence

 typedef UINT2Vector UINT2Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 248 of file LALDatatypes.h.

## ◆ INT4Sequence

 typedef INT4Vector INT4Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 249 of file LALDatatypes.h.

## ◆ UINT4Sequence

 typedef UINT4Vector UINT4Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 250 of file LALDatatypes.h.

## ◆ INT8Sequence

 typedef INT8Vector INT8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 251 of file LALDatatypes.h.

## ◆ UINT8Sequence

 typedef UINT8Vector UINT8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 252 of file LALDatatypes.h.

## ◆ REAL4Sequence

 typedef REAL4Vector REAL4Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 253 of file LALDatatypes.h.

## ◆ REAL8Sequence

 typedef REAL8Vector REAL8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 254 of file LALDatatypes.h.

## ◆ COMPLEX8Sequence

 typedef COMPLEX8Vector COMPLEX8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 255 of file LALDatatypes.h.

## ◆ COMPLEX16Sequence

 typedef COMPLEX16Vector COMPLEX16Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 256 of file LALDatatypes.h.

## ◆ anonymous enum

 anonymous enum

Type size constants, see Headers LAL(Atomic)Datatypes.h for more details.

Enumerator
LAL_1_BYTE_TYPE_SIZE

One byte size 00 = 0.

LAL_2_BYTE_TYPE_SIZE

Two byte size 01 = 1.

LAL_4_BYTE_TYPE_SIZE

Four byte size 010 = 2.

LAL_8_BYTE_TYPE_SIZE

Eight byte size 011 = 3.

LAL_16_BYTE_TYPE_SIZE

Sixteen byte size 0100 = 4.

Type size mask 0111 = 7.

Definition at line 32 of file LALDatatypes.h.

## ◆ anonymous enum

 anonymous enum

Type flag constants, see Headers LAL(Atomic)Datatypes.h for more details.

Enumerator
LAL_FLTPT_TYPE_FLAG

Floating-point (vs integer) type 01000 = 8.

LAL_CMPLX_TYPE_FLAG

Complex (vs real) type 010000 = 16.

LAL_UNSGN_TYPE_FLAG

Unsigned (vs signed) type 0100000 = 32.

Definition at line 42 of file LALDatatypes.h.

## ◆ LALTYPECODE

 enum LALTYPECODE

Type codes: use these type codes to identify a LAL atomic data type, see Headers LAL(Atomic)Datatypes.h for more details.

Enumerator
LAL_CHAR_TYPE_CODE

CHAR type code (0)

LAL_I2_TYPE_CODE

INT2 type code (1)

LAL_I4_TYPE_CODE

INT4 type code (2)

LAL_I8_TYPE_CODE

INT8 type code (3)

LAL_UCHAR_TYPE_CODE

UCHAR type code (32)

LAL_U2_TYPE_CODE

UINT2 type code (33)

LAL_U4_TYPE_CODE

UINT4 type code (34)

LAL_U8_TYPE_CODE

UINT8 type code (35)

LAL_S_TYPE_CODE

REAL4 type code (18)

LAL_D_TYPE_CODE

REAL8 type code (19)

LAL_C_TYPE_CODE

COMPLEX8 type code (27)

LAL_Z_TYPE_CODE

COMPLEX16 type code (28)

Definition at line 49 of file LALDatatypes.h.

## ◆ anonymous enum

 anonymous enum

Indices of arrays corresponding to particular units.

The LALUnit structure has arrays giving the numerators and denominators-minus-one of the powers of various units. These are the indices for the particular units.

Enumerator
LALUnitIndexMeter

The meter index.

LALUnitIndexKiloGram

The kilogram index.

LALUnitIndexSecond

The second index.

LALUnitIndexAmpere

The ampere index.

LALUnitIndexKelvin

The kelvin index.

LALUnitIndexStrain

The strain index.

LALNumUnits

The number of units.

Definition at line 472 of file LALDatatypes.h.

## ◆ enumLALNameLength

 enum enumLALNameLength

Length of name fields of LAL structured data types.

Enumerator
LALNameLength

Definition at line 508 of file LALDatatypes.h.

## ◆ XLAL_INIT_MEM

 #define XLAL_INIT_MEM ( x ) memset(&(x), 0, sizeof((x)))

MACRO to initialize arbitrary variable 'x' to zero.

Definition at line 66 of file LALAtomicDatatypes.h.

## ◆ XLAL_INIT_DECL

 #define XLAL_INIT_DECL ( var, ... ) var __VA_ARGS__; XLAL_INIT_MEM(var)

C99 MACRO to declare and zero-initialize a variable, use as "type XLAL_INIT_DECL(var);".

To declare and zero-initialize an array variable, use as "type XLAL_INIT_DECL(var, [n]);"

Definition at line 69 of file LALAtomicDatatypes.h.

## ◆ XLAL_NUM_ELEM

 #define XLAL_NUM_ELEM ( x ) ( sizeof((x)) / sizeof((x)[0]) )

MACRO which gives the number of elements in a fixed-size array.

Definition at line 72 of file LALAtomicDatatypes.h.

## ◆ XLAL_LAST_ELEM

 #define XLAL_LAST_ELEM ( x ) (x)[ XLAL_NUM_ELEM(x) - 1 ]

MACRO to access the last element in a fixed-size array.

Definition at line 74 of file LALAtomicDatatypes.h.

## ◆ LAL_INT8_C

 #define LAL_INT8_C ( c ) INT64_C(c)

Macro for use in defining v as an INT8 constant.

This macro affixes the appropriate qualifier to form an INT8 constant. For example:

const INT8 jan_1_2000_gps_nanosec = LAL_INT8_C(63072001300000000)

Definition at line 87 of file LALAtomicDatatypes.h.

## ◆ LAL_UINT8_C

 #define LAL_UINT8_C ( c ) UINT64_C(c)

Macro for use in defining v as an UINT8 constant.

This macro affixes the appropriate qualifier to form an UINT8 constant. For example:

const UINT8 jan_1_2000_gps_nanosec = LAL_UINT8_C(63072001300000000)

Definition at line 99 of file LALAtomicDatatypes.h.

## ◆ _LAL_C99_COMPLEX_NUMBERS_

 #define _LAL_C99_COMPLEX_NUMBERS_

Definition at line 111 of file LALAtomicDatatypes.h.

## ◆ crectf

 #define crectf ( re, im ) (((REAL4)(re)) + _Complex_I*((REAL4)(im)))

Construct a COMPLEX8 from real and imaginary parts.

Definition at line 122 of file LALAtomicDatatypes.h.

## ◆ crect

 #define crect ( re, im ) (((REAL8)(re)) + _Complex_I*((REAL8)(im)))

Construct a COMPLEX16 from real and imaginary parts.

Definition at line 123 of file LALAtomicDatatypes.h.

## ◆ cpolarf

 #define cpolarf ( r, th ) (((REAL4)(r)) * cexpf(crectf(0, th)))

Construct a COMPLEX8 from polar modulus and argument.

Definition at line 124 of file LALAtomicDatatypes.h.

## ◆ cpolar

 #define cpolar ( r, th ) (((REAL8)(r)) * cexp(crect(0, th)))

Construct a COMPLEX16 from polar modulus and argument.

Definition at line 125 of file LALAtomicDatatypes.h.

## ◆ LIGOTIMEGPSZERO

 #define LIGOTIMEGPSZERO   { 0, 0 }

Zero-initializer for LIGOTimeGPS structs.

Definition at line 464 of file LALDatatypes.h.