Detailed Description

Provides the basic LAL datatypes.

Authors: J. D. E. Creighton; T. D. Creighton; K. Wette

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.

Type	Bytes	Range	Usual C/C++ type
CHAR	1	`'\0'` to `'\255'`	char
UCHAR	1	`'\0'` to `'\255'`	unsigned char
BOOLEAN	1	0 or positive	unsigned char
INT2	2	\(-2^{-15}\) to \(2^{15}-1\)	short
INT4	4	\(-2^{-31}\) to \(2^{31}-1\)	`int` or `long`
INT8	8	\(-2^{-63}\) to \(2^{63}-1\)	long long
UINT2	2	0 to \(2^{16}-1\)	unsigned short
UINT4	4	0 to \(2^{32}-1\)	`unsigned int` or `long`
UINT8	8	0 to \(2^{64}-1\)	unsigned long long
REAL4	4	\(-3.4\times10^{38}\) to \(3.4\times10^{38}\)	float
REAL8	8	\(-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.

Name	Octal Value	Description
LAL_1_BYTE_TYPE_SIZE	000	1 byte type
LAL_2_BYTE_TYPE_SIZE	001	2 byte type
LAL_4_BYTE_TYPE_SIZE	002	4 byte type
LAL_8_BYTE_TYPE_SIZE	003	8 byte type
LAL_16_BYTE_TYPE_SIZE	004	16 byte type
LAL_TYPE_SIZE_MASK	007	Mask for byte type size fields

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 code = LAL_S_TYPE_CODE;

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

UINT4

uint32_t UINT4

Four-byte unsigned integer.

Definition: LALAtomicDatatypes.h:59

LAL_S_TYPE_CODE

@ LAL_S_TYPE_CODE

REAL4 type code (18)

Definition: LALDatatypes.h:58

LAL_TYPE_SIZE_MASK

@ LAL_TYPE_SIZE_MASK

Type size mask 0111 = 7.

Definition: LALDatatypes.h:38

test_python_scripts.code

code

Definition: test_python_scripts.py:149

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.

Name	Octal Value	Description
LAL_FLTPT_TYPE_FLAG	010	Floating-point (not integer) type
LAL_CMPLX_TYPE_FLAG	020	Complex (not purely real) type
LAL_UNSGN_TYPE_FLAG	040	Unsigned (no sign info) 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 code = LAL_S_TYPE_CODE;
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.

Name	Octal Value	Corresponding Type
LAL_CHAR_TYPE_CODE	000	CHAR
LAL_I2_TYPE_CODE	001	INT2
LAL_I4_TYPE_CODE	002	INT4
LAL_I8_TYPE_CODE	003	INT8
LAL_UCHAR_TYPE_CODE	040	UCHAR
LAL_U2_TYPE_CODE	041	UINT2
LAL_U4_TYPE_CODE	042	UINT4
LAL_U8_TYPE_CODE	043	UINT8
LAL_S_TYPE_CODE	012	REAL4
LAL_D_TYPE_CODE	013	REAL8
LAL_C_TYPE_CODE	033	COMPLEX8
LAL_Z_TYPE_CODE	034	COMPLEX16

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]\).

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

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.

The concrete types are CHARVectorSequence, INT2VectorSequence, UINT2VectorSequence, INT4VectorSequence, UINT4VectorSequence, INT8VectorSequence, UINT8VectorSequence, REAL4VectorSequence, REAL8VectorSequence, COMPLEX8VectorSequence, COMPLEX16VectorSequence.

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.

The concrete types are INT2ArraySequence, UINT2ArraySequence, INT4ArraySequence, UINT4ArraySequence, INT8ArraySequence, UINT8ArraySequence, REAL4ArraySequence, REAL8ArraySequence, COMPLEX8ArraySequence, COMPLEX16ArraySequence

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:

LIGOTimeGPS epoch = LIGOTIMEGPSZERO;

LIGOTIMEGPSZERO

#define LIGOTIMEGPSZERO

Zero-initializer for LIGOTimeGPS structs.

Definition: LALDatatypes.h:464

LIGOTimeGPS

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

Definition: LALDatatypes.h:458

epoch

enum @1 epoch

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.

The concrete types are INT2TimeSeries, UINT2TimeSeries, INT4TimeSeries, UINT4TimeSeries, INT8TimeSeries, UINT8TimeSeries, REAL4TimeSeries, REAL8TimeSeries, COMPLEX8TimeSeries, COMPLEX16TimeSeries.

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.

The concrete types are INT2TimeVectorSeries, UINT2TimeVectorSeries, INT4TimeVectorSeries, UINT4TimeVectorSeries, INT8TimeVectorSeries, UINT8TimeVectorSeries, REAL4TimeVectorSeries, REAL8TimeVectorSeries, COMPLEX8TimeVectorSeries, COMPLEX16TimeVectorSeries.

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.

The concrete types are INT2TimeArraySeries, UINT2TimeArraySeries, INT4TimeArraySeries, UINT4TimeArraySeries, INT8TimeArraySeries, UINT8TimeArraySeries, REAL4TimeArraySeries, REAL8TimeArraySeries, COMPLEX8TimeArraySeries, COMPLEX16TimeArraySeries.

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.

The concrete types are INT2FrequencySeries, UINT2FrequencySeries, INT4FrequencySeries, UINT4FrequencySeries, INT8FrequencySeries, UINT8FrequencySeries, REAL4FrequencySeries, REAL8FrequencySeries, COMPLEX8FrequencySeries, COMPLEX16FrequencySeries.

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 , LALUnitIndexKelvin , LALUnitIndexStrain , LALUnitIndexADCCount , LALNumUnits }
	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...

Typedef Documentation

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

Enumeration Type Documentation

◆ 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.
LAL_TYPE_SIZE_MASK	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.
LALUnitIndexADCCount	The ADC counts 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.

Macro Definition Documentation

◆ 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)

LAL_INT8_C

#define LAL_INT8_C(c)

Macro for use in defining v as an INT8 constant.

Definition: LALAtomicDatatypes.h:87

INT8

int64_t INT8

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

Definition: LALAtomicDatatypes.h:61

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)

UINT8

uint64_t UINT8

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

Definition: LALAtomicDatatypes.h:62

LAL_UINT8_C

#define LAL_UINT8_C(c)

Macro for use in defining v as an UINT8 constant.

Definition: LALAtomicDatatypes.h:99

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.

Detailed Description

Synopsis

Primitive datatypes

Atomic datatypes

Complex datatypes

Atomic datatypes codes

Aggregate datatypes

DATATYPE-Vector types

DATATYPE-Array types

DATATYPE-Sequence types

DATATYPE-VectorSequence types

DATATYPE-ArraySequence types

Structured datatypes

LIGOTimeGPS type

DATATYPE-TimeSeries types

DATATYPE-TimeVectorSeries

DATATYPE-TimeArraySeries types

DATATYPE-FrequencySeries types

DATATYPE-ZPGFilter types

Data Structures

Typedefs

Enumerations

Macros

Typedef Documentation

◆ CHAR

◆ UCHAR

◆ BOOLEAN

◆ INT2

◆ INT4

◆ UINT2

◆ UINT4

◆ INT8

◆ UINT8

◆ REAL4

◆ REAL8

◆ COMPLEX8

◆ COMPLEX16

◆ CHARSequence

◆ INT2Sequence

◆ UINT2Sequence

◆ INT4Sequence

◆ UINT4Sequence

◆ INT8Sequence

◆ UINT8Sequence

◆ REAL4Sequence

◆ REAL8Sequence

◆ COMPLEX8Sequence

◆ COMPLEX16Sequence

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ LALTYPECODE

◆ anonymous enum

◆ enumLALNameLength

Macro Definition Documentation

◆ XLAL_INIT_MEM

◆ XLAL_INIT_DECL

◆ XLAL_NUM_ELEM

◆ XLAL_LAST_ELEM

◆ LAL_INT8_C

◆ LAL_UINT8_C

◆ _LAL_C99_COMPLEX_NUMBERS_

◆ crectf

◆ crect

◆ cpolarf

◆ cpolar

◆ LIGOTIMEGPSZERO