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, 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.
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 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.
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.
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:
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:
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 |
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.
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
.
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
.
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
.
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
.
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
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.
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:
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
.
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
.
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
.
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
.
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 char CHAR |
One-byte signed integer, see Headers LAL(Atomic)Datatypes.h for more details.
Definition at line 37 of file LALAtomicDatatypes.h.
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.
typedef unsigned char BOOLEAN |
Boolean logical type, see Headers LAL(Atomic)Datatypes.h for more details.
Definition at line 39 of file LALAtomicDatatypes.h.
typedef int16_t INT2 |
Two-byte signed integer.
Definition at line 56 of file LALAtomicDatatypes.h.
typedef int32_t INT4 |
Four-byte signed integer.
Definition at line 57 of file LALAtomicDatatypes.h.
typedef uint16_t UINT2 |
Two-byte unsigned integer.
Definition at line 58 of file LALAtomicDatatypes.h.
typedef uint32_t UINT4 |
Four-byte unsigned integer.
Definition at line 59 of file LALAtomicDatatypes.h.
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.
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.
typedef float REAL4 |
Single precision real floating-point number (4 bytes).
Definition at line 102 of file LALAtomicDatatypes.h.
typedef double REAL8 |
Double precision real floating-point number (8 bytes).
Definition at line 103 of file LALAtomicDatatypes.h.
typedef float complex COMPLEX8 |
Single-precision floating-point complex number (8 bytes total)
Definition at line 119 of file LALAtomicDatatypes.h.
typedef double complex COMPLEX16 |
Double-precision floating-point complex number (16 bytes total)
Definition at line 120 of file LALAtomicDatatypes.h.
typedef CHARVector CHARSequence |
See DATATYPE-Sequence types for documentation.
Definition at line 246 of file LALDatatypes.h.
typedef INT2Vector INT2Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 247 of file LALDatatypes.h.
typedef UINT2Vector UINT2Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 248 of file LALDatatypes.h.
typedef INT4Vector INT4Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 249 of file LALDatatypes.h.
typedef UINT4Vector UINT4Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 250 of file LALDatatypes.h.
typedef INT8Vector INT8Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 251 of file LALDatatypes.h.
typedef UINT8Vector UINT8Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 252 of file LALDatatypes.h.
typedef REAL4Vector REAL4Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 253 of file LALDatatypes.h.
typedef REAL8Vector REAL8Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 254 of file LALDatatypes.h.
typedef COMPLEX8Vector COMPLEX8Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 255 of file LALDatatypes.h.
typedef COMPLEX16Vector COMPLEX16Sequence |
See DATATYPE-Sequence types for documentation.
Definition at line 256 of file LALDatatypes.h.
anonymous enum |
Type size constants, see Headers LAL(Atomic)Datatypes.h for more details.
Definition at line 32 of file LALDatatypes.h.
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.
enum LALTYPECODE |
Type codes: use these type codes to identify a LAL atomic data type, see Headers LAL(Atomic)Datatypes.h for more details.
Definition at line 49 of file LALDatatypes.h.
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.
Definition at line 472 of file LALDatatypes.h.
enum enumLALNameLength |
Length of name fields of LAL structured data types.
Enumerator | |
---|---|
LALNameLength |
Definition at line 508 of file LALDatatypes.h.
#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.
#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.
#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.
#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.
#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:
Definition at line 87 of file LALAtomicDatatypes.h.
#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:
Definition at line 99 of file LALAtomicDatatypes.h.
#define _LAL_C99_COMPLEX_NUMBERS_ |
Definition at line 111 of file LALAtomicDatatypes.h.
Construct a COMPLEX8 from real and imaginary parts.
Definition at line 122 of file LALAtomicDatatypes.h.
Construct a COMPLEX16 from real and imaginary parts.
Definition at line 123 of file LALAtomicDatatypes.h.
Construct a COMPLEX8 from polar modulus and argument.
Definition at line 124 of file LALAtomicDatatypes.h.
Construct a COMPLEX16 from polar modulus and argument.
Definition at line 125 of file LALAtomicDatatypes.h.
#define LIGOTIMEGPSZERO { 0, 0 } |
Zero-initializer for LIGOTimeGPS structs.
Definition at line 464 of file LALDatatypes.h.