LAL  6.21.0.1-1696c80
Headers LAL(Atomic)Datatypes.h

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.

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:

REAL4REAL8
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 digits6-915-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
LAL_TYPE_SIZE_MASK007Mask 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 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
LAL_UNSGN_TYPE_FLAG040Unsigned (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 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:

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:

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:

The concrete types are CHARSequence, INT2Sequence, UINT2Sequence, INT4Sequence, UINT4Sequence, INT8Sequence, UINT8Sequence, REAL4Sequence, REAL8Sequence, COMPLEX8Sequence, COMPLEX16Sequence.

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:

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:

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:

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:

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:

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:

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:

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:

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

See DATATYPE-Sequence types for documentation.

Definition at line 246 of file LALDatatypes.h.

◆ INT2Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 247 of file LALDatatypes.h.

◆ UINT2Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 248 of file LALDatatypes.h.

◆ INT4Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 249 of file LALDatatypes.h.

◆ UINT4Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 250 of file LALDatatypes.h.

◆ INT8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 251 of file LALDatatypes.h.

◆ UINT8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 252 of file LALDatatypes.h.

◆ REAL4Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 253 of file LALDatatypes.h.

◆ REAL8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 254 of file LALDatatypes.h.

◆ COMPLEX8Sequence

See DATATYPE-Sequence types for documentation.

Definition at line 255 of file LALDatatypes.h.

◆ 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

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

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)

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.