AVFactories.h

Go to the documentation of this file.

/*----------------------------------------------------------------------- 

File Name: AVFactories.h

<lalVerbatim file="AVFactoriesHV">
Revision: $Id: AVFactoriesH.m4,v 1.2 2004/11/04 22:48:56 jolien Exp $
</lalVerbatim>

-------------------------------------------------------------------------*/

/* <lalLaTeX>

\section{Header \texttt{AVFactories.h}}
\label{s:AVFactories.h}

Provides prototype and status code information for use of CreateVector,
CreateArray, ResizeVector, ResizeArray, DestroyVector and DestroyArray

\subsection*{Synopsis}
\begin{verbatim}
#include <lal/AVFactories.h>
\end{verbatim}

</lalLaTeX> */

#ifndef _AVFACTORIES_H
#define _AVFACTORIES_H

#include <lal/LALDatatypes.h>
#include <stdarg.h>

#ifdef  __cplusplus
extern "C" {
#endif

NRCSID (AVFACTORIESH, "$Id: AVFactoriesH.m4,v 1.2 2004/11/04 22:48:56 jolien Exp $");

/* <lalLaTeX>

\subsection*{Error conditions}
\input{AVFactoriesHErrTab}

</lalLaTeX> */

/*
<lalErrTable file="AVFactoriesHErrTab">
*/
#define AVFACTORIESH_ELENGTH 1
#define AVFACTORIESH_EVPTR   2
#define AVFACTORIESH_EUPTR   4
#define AVFACTORIESH_EDPTR   8
#define AVFACTORIESH_EMALLOC 16
#define AVFACTORIESH_MSGELENGTH  "Illegal length."
#define AVFACTORIESH_MSGEVPTR    "Null vector/array handle."
#define AVFACTORIESH_MSGEUPTR    "Non-null vector/array pointer."
#define AVFACTORIESH_MSGEDPTR    "Null vector/array data."
#define AVFACTORIESH_MSGEMALLOC  "Malloc failure."
/*
</lalErrTable>
*/

/* Function prototypes. */
/* <lalLaTeX>
\newpage\input{VectorFactoriesC}
\newpage\input{ArrayFactoriesC}

\newpage
\subsection{XLAL Functions}

\subsubsection*{Synopsis}
\begin{verbatim}
#include <lal/AVFactories.h>

REAL4Vector * XLALCreateVector(UINT4 length);
REAL4Vector * XLALResizeVector(REAL4Vector *vector, UINT4 length);
void XLALDestroyVector(REAL4Vector *vector, UINT4 length);

<vectype> * XLALCreate<vectype>(UINT4 length );
<vectype> * XLALResize<vectype>(<vectype> *vector, UINT4 length );
void XLALDestroy<vectype>(<vectype> *vector);

REAL4Array * XLALCreateArrayL(UINT4 ndim, ...);
REAL4Array * XLALCreateArrayV(UINT4 ndim, UINT4 *dims);
REAL4Array * XLALCreateArray(UINT4Vector *dimLength);
REAL4Array * XLALResizeArrayL(REAL4Array *array, UINT4 ndim, ...);
REAL4Array * XLALResizeArrayV(REAL4Array *array, UINT4 ndim, UINT4 *dims);
REAL4Array * XLALResizeArray(REAL4Array *array, UINT4Vector *dimLength);
void XLALDestroyArray(REAL4Array *array);

<arrtype> * XLALCreate<arrtype>L(UINT4 ndim, ...);
<arrtype> * XLALCreate<arrtype>V(UINT4 ndim, UINT4 *dims);
<arrtype> * XLALCreate<arrtype>(UINT4Vector *dimLength);
<arrtype> * XLALResize<arrtype>L(<arrtype> *array, UINT4 ndim, ...);
<arrtype> * XLALResize<arrtype>V(<arrtype> *array, UINT4 ndim, UINT4 *dims);
<arrtype> * XLALResize<arrtype>(<arrtype> *array, UINT4Vector *dimLength);
void XLALDestroy<arrtype>(<arrtype> *array);
\end{verbatim}
\idx{XLALCreateVector}
\idx{XLALResizeVector}
\idx{XLALDestroyVector}
\idx{XLALCreateArrayL}
\idx{XLALCreateArrayV}
\idx{XLALCreateArray}
\idx{XLALResizeArrayL}
\idx{XLALResizeArrayV}
\idx{XLALResizeArray}
\idx{XLALDestroyArray}
\idx{XLALCreate<type>Vector}
\idx{XLALResize<type>Vector}
\idx{XLALDestroy<type>Vector}
\idx{XLALCreate<type>ArrayL}
\idx{XLALCreate<type>ArrayV}
\idx{XLALCreate<type>Array}
\idx{XLALResize<type>ArrayL}
\idx{XLALResize<type>ArrayV}
\idx{XLALResize<type>Array}
\idx{XLALDestroy<type>Array}

Here \verb+<vectype>+ is one of
\verb+COMPLEX16Vector+,
\verb+COMPLEX8Vector+,
\verb+REAL8Vector+,
\verb+REAL4Vector+,
\verb+INT8Vector+,
\verb+INT4Vector+,
\verb+INT2Vector+,
\verb+UINT8Vector+,
\verb+UINT4Vector+,
\verb+UINT2Vector+, or
\verb+CHARVector+,
and \verb+<arrtype>+ is one of
\verb+COMPLEX16Array+,
\verb+COMPLEX8Array+,
\verb+REAL8Array+,
\verb+REAL4Array+,
\verb+INT8Array+,
\verb+INT4Array+,
\verb+INT2Array+,
\verb+UINT8Array+,
\verb+UINT4Array+, or
\verb+UINT2Array+.

\subsubsection*{Description}

The \verb+XLALCreate<type>Vector+ functions create vectors of the specified
\verb+length+ number of objects of type \verb+<type>+.  The function
\verb+XLALCreateVector+ is the same as \verb+XLALCreateREAL4Vector+.

The \verb+XLALDestroy<type>Vector+ functions deallocate the memory allocation
pointed to by \verb+vector+ including its contents.  The function
\verb+XLALDestroyVector+ is the same as \verb+XLALDestroyREAL4Vector+.

The \verb+XLALResize<type>Vector+ functions resize the supplied vector
\verb+vector+ to the new size \verb+length+.  If \verb+vector+ is \verb+NULL+
then this is equivalent to \verb+XLALCreate<type>Vector+.  If \verb+length+
is zero then this is equivalent to \verb+XLALDestroy<type>Vector+ and the
routine returns \verb+NULL+.  Otherwise, the amount of data in the vector
is realloced using \verb+LALRealloc+.  The function
\verb+XLALResizeVector+ is the same as \verb+XLALResizeREAL4Vector+.

The \verb+XLALCreate<type>Array+
\verb+XLALCreate<type>ArrayL+
\verb+XLALCreate<type>ArrayV+
all create an object of type \verb+<type>Array+.  They differ in the way
that the dimensions of the array are specified.  The function
\verb+XLALCreate<type>Array+ allocates an array with dimensions specified
by the \verb+UINT4Vector+ \verb+dimLength+ which is a vector of dimension
lengths for the array.  The function
\verb+XLALCreate<type>ArrayV+ provides these dimensions with two arguments:
\verb+ndim+ is the number of dimensions and \verb+dims+ is an array of
\verb+UINT4+ values for the dimensions.  The function
\verb+XLALCreate<type>ArrayL+ also specifies the dimensions as arguments.
Here, the first argument, \verb+ndim+, is the number of dimensions, and
this is followed by \verb+ndim+ arguments that provide the dimensions.
Note that for this function, a maximum of 16 dimensions can be provided
(that is, \verb+ndim+ cannot be more than 16 and there cannot be more than
16 arguments after the first).
The \verb+XLALCreateArray+
\verb+XLALCreateArrayL+
\verb+XLALCreateArrayV+
functions are equivalent to the
\verb+XLALCreateREAL4Array+
\verb+XLALCreateREAL4ArrayL+
\verb+XLALCreateREAL4ArrayV+
functions respectively.

The \verb+XLALDestroy<type>Array+ functions deallocate the memory allocation
pointed to by \verb+array+ including its contents.  The function
\verb+XLALDestroyArray+ is the same as \verb+XLALDestroyREAL4Array+.

The \verb+XLALResize<type>Array+
\verb+XLALResize<type>ArrayL+
\verb+XLALResize<type>ArrayV+
functions resize the provided array \verb+array+.  The arguments after the
first are interpreted in the same way as for the 
\verb+XLALCreate<type>Array+
\verb+XLALCreate<type>ArrayL+
\verb+XLALCreate<type>ArrayV+
functions.  If \verb+array+ is \verb+NULL+, the resize functions are equivalent
to the corresponding create function.  If \verb+ndim+ is zero for 
\verb+XLALResize<type>ArrayL+ or
\verb+XLALResize<type>ArrayV+, or if \verb+dimLength+ is \verb+NULL+ for
\verb+XLALResize<type>Array+, then these functions are equivalent to
\verb+XLALDestroy<type>Array+.
The \verb+XLALResizeArray+
\verb+XLALResizeArrayL+
\verb+XLALResizeArrayV+
functions are equivalent to the
\verb+XLALResizeREAL4Array+
\verb+XLALResizeREAL4ArrayL+
\verb+XLALResizeREAL4ArrayV+
functions respectively.

\subsubsection*{Return Values}

If successful, the create and resize functions return a pointer to the same
data that was passed to the function.  The resize functions will return
a \verb+NULL+ pointer if the size of the new object was zero.  Upon failure
these routines will return \verb+NULL+ and will set \verb+xlalErrno+ to
one of these values: \verb+XLAL_ENOMEM+ if a memory allocation failed,
\verb+XLAL_EBADLEN+ if an invalid length was provided (for example, a
zero-size allocation with a create function), \verb+XLAL_EINVAL+ if an
invalid argument is provided (for example, if the pointer to an
array of dimensions is \verb+NULL+).

The destroy function does not return any value.  If the function is passed a
\verb+NULL+ pointer, it will set \verb+xlalErrno+ to \verb+XLAL_EFAULT+.
If the function is passed an object that appears corrupted (e.g., a
vector with zero length or will a \verb+NULL+ data pointer) it will set
\verb+xlalErrno+ to \verb+XLAL_EINVAL+.

</lalLaTeX> */


/* 



















 * CHAR
 */
CHARVector * XLALCreateCHARVector ( UINT4 length );
CHARVector * XLALResizeCHARVector ( CHARVector * vector, UINT4 length );
void XLALDestroyCHARVector ( CHARVector * vector );
void LALCHARCreateVector ( LALStatus *, CHARVector **, UINT4 );
void LALCHARResizeVector ( LALStatus *, CHARVector **, UINT4 );
void LALCHARDestroyVector ( LALStatus *, CHARVector ** );



/* 



















 * INT2
 */
INT2Vector * XLALCreateINT2Vector ( UINT4 length );
INT2Vector * XLALResizeINT2Vector ( INT2Vector * vector, UINT4 length );
void XLALDestroyINT2Vector ( INT2Vector * vector );
void LALI2CreateVector ( LALStatus *, INT2Vector **, UINT4 );
void LALI2ResizeVector ( LALStatus *, INT2Vector **, UINT4 );
void LALI2DestroyVector ( LALStatus *, INT2Vector ** );

/* 























 * INT2
 */
INT2Array * XLALCreateINT2ArrayL ( UINT4, ... );
INT2Array * XLALCreateINT2ArrayV ( UINT4, UINT4 * );
INT2Array * XLALCreateINT2Array ( UINT4Vector * );
INT2Array * XLALResizeINT2ArrayL ( INT2Array *, UINT4, ... );
INT2Array * XLALResizeINT2ArrayV ( INT2Array *, UINT4, UINT4 * );
INT2Array * XLALResizeINT2Array ( INT2Array *, UINT4Vector * );
void XLALDestroyINT2Array ( INT2Array * );
void LALI2CreateArray ( LALStatus *, INT2Array **, UINT4Vector * );
void LALI2ResizeArray ( LALStatus *, INT2Array **, UINT4Vector * );
void LALI2DestroyArray ( LALStatus *, INT2Array ** );



/* 



















 * INT4
 */
INT4Vector * XLALCreateINT4Vector ( UINT4 length );
INT4Vector * XLALResizeINT4Vector ( INT4Vector * vector, UINT4 length );
void XLALDestroyINT4Vector ( INT4Vector * vector );
void LALI4CreateVector ( LALStatus *, INT4Vector **, UINT4 );
void LALI4ResizeVector ( LALStatus *, INT4Vector **, UINT4 );
void LALI4DestroyVector ( LALStatus *, INT4Vector ** );

/* 























 * INT4
 */
INT4Array * XLALCreateINT4ArrayL ( UINT4, ... );
INT4Array * XLALCreateINT4ArrayV ( UINT4, UINT4 * );
INT4Array * XLALCreateINT4Array ( UINT4Vector * );
INT4Array * XLALResizeINT4ArrayL ( INT4Array *, UINT4, ... );
INT4Array * XLALResizeINT4ArrayV ( INT4Array *, UINT4, UINT4 * );
INT4Array * XLALResizeINT4Array ( INT4Array *, UINT4Vector * );
void XLALDestroyINT4Array ( INT4Array * );
void LALI4CreateArray ( LALStatus *, INT4Array **, UINT4Vector * );
void LALI4ResizeArray ( LALStatus *, INT4Array **, UINT4Vector * );
void LALI4DestroyArray ( LALStatus *, INT4Array ** );



/* 



















 * INT8
 */
INT8Vector * XLALCreateINT8Vector ( UINT4 length );
INT8Vector * XLALResizeINT8Vector ( INT8Vector * vector, UINT4 length );
void XLALDestroyINT8Vector ( INT8Vector * vector );
void LALI8CreateVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8ResizeVector ( LALStatus *, INT8Vector **, UINT4 );
void LALI8DestroyVector ( LALStatus *, INT8Vector ** );

/* 























 * INT8
 */
INT8Array * XLALCreateINT8ArrayL ( UINT4, ... );
INT8Array * XLALCreateINT8ArrayV ( UINT4, UINT4 * );
INT8Array * XLALCreateINT8Array ( UINT4Vector * );
INT8Array * XLALResizeINT8ArrayL ( INT8Array *, UINT4, ... );
INT8Array * XLALResizeINT8ArrayV ( INT8Array *, UINT4, UINT4 * );
INT8Array * XLALResizeINT8Array ( INT8Array *, UINT4Vector * );
void XLALDestroyINT8Array ( INT8Array * );
void LALI8CreateArray ( LALStatus *, INT8Array **, UINT4Vector * );
void LALI8ResizeArray ( LALStatus *, INT8Array **, UINT4Vector * );
void LALI8DestroyArray ( LALStatus *, INT8Array ** );



/* 



















 * UINT2
 */
UINT2Vector * XLALCreateUINT2Vector ( UINT4 length );
UINT2Vector * XLALResizeUINT2Vector ( UINT2Vector * vector, UINT4 length );
void XLALDestroyUINT2Vector ( UINT2Vector * vector );
void LALU2CreateVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2ResizeVector ( LALStatus *, UINT2Vector **, UINT4 );
void LALU2DestroyVector ( LALStatus *, UINT2Vector ** );

/* 























 * UINT2
 */
UINT2Array * XLALCreateUINT2ArrayL ( UINT4, ... );
UINT2Array * XLALCreateUINT2ArrayV ( UINT4, UINT4 * );
UINT2Array * XLALCreateUINT2Array ( UINT4Vector * );
UINT2Array * XLALResizeUINT2ArrayL ( UINT2Array *, UINT4, ... );
UINT2Array * XLALResizeUINT2ArrayV ( UINT2Array *, UINT4, UINT4 * );
UINT2Array * XLALResizeUINT2Array ( UINT2Array *, UINT4Vector * );
void XLALDestroyUINT2Array ( UINT2Array * );
void LALU2CreateArray ( LALStatus *, UINT2Array **, UINT4Vector * );
void LALU2ResizeArray ( LALStatus *, UINT2Array **, UINT4Vector * );
void LALU2DestroyArray ( LALStatus *, UINT2Array ** );



/* 



















 * UINT4
 */
UINT4Vector * XLALCreateUINT4Vector ( UINT4 length );
UINT4Vector * XLALResizeUINT4Vector ( UINT4Vector * vector, UINT4 length );
void XLALDestroyUINT4Vector ( UINT4Vector * vector );
void LALU4CreateVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4ResizeVector ( LALStatus *, UINT4Vector **, UINT4 );
void LALU4DestroyVector ( LALStatus *, UINT4Vector ** );

/* 























 * UINT4
 */
UINT4Array * XLALCreateUINT4ArrayL ( UINT4, ... );
UINT4Array * XLALCreateUINT4ArrayV ( UINT4, UINT4 * );
UINT4Array * XLALCreateUINT4Array ( UINT4Vector * );
UINT4Array * XLALResizeUINT4ArrayL ( UINT4Array *, UINT4, ... );
UINT4Array * XLALResizeUINT4ArrayV ( UINT4Array *, UINT4, UINT4 * );
UINT4Array * XLALResizeUINT4Array ( UINT4Array *, UINT4Vector * );
void XLALDestroyUINT4Array ( UINT4Array * );
void LALU4CreateArray ( LALStatus *, UINT4Array **, UINT4Vector * );
void LALU4ResizeArray ( LALStatus *, UINT4Array **, UINT4Vector * );
void LALU4DestroyArray ( LALStatus *, UINT4Array ** );



/* 



















 * UINT8
 */
UINT8Vector * XLALCreateUINT8Vector ( UINT4 length );
UINT8Vector * XLALResizeUINT8Vector ( UINT8Vector * vector, UINT4 length );
void XLALDestroyUINT8Vector ( UINT8Vector * vector );
void LALU8CreateVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8ResizeVector ( LALStatus *, UINT8Vector **, UINT4 );
void LALU8DestroyVector ( LALStatus *, UINT8Vector ** );

/* 























 * UINT8
 */
UINT8Array * XLALCreateUINT8ArrayL ( UINT4, ... );
UINT8Array * XLALCreateUINT8ArrayV ( UINT4, UINT4 * );
UINT8Array * XLALCreateUINT8Array ( UINT4Vector * );
UINT8Array * XLALResizeUINT8ArrayL ( UINT8Array *, UINT4, ... );
UINT8Array * XLALResizeUINT8ArrayV ( UINT8Array *, UINT4, UINT4 * );
UINT8Array * XLALResizeUINT8Array ( UINT8Array *, UINT4Vector * );
void XLALDestroyUINT8Array ( UINT8Array * );
void LALU8CreateArray ( LALStatus *, UINT8Array **, UINT4Vector * );
void LALU8ResizeArray ( LALStatus *, UINT8Array **, UINT4Vector * );
void LALU8DestroyArray ( LALStatus *, UINT8Array ** );



/* 



















 * REAL4
 */
REAL4Vector * XLALCreateREAL4Vector ( UINT4 length );
REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyREAL4Vector ( REAL4Vector * vector );
void LALSCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALSDestroyVector ( LALStatus *, REAL4Vector ** );

/* 























 * REAL4
 */
REAL4Array * XLALCreateREAL4ArrayL ( UINT4, ... );
REAL4Array * XLALCreateREAL4ArrayV ( UINT4, UINT4 * );
REAL4Array * XLALCreateREAL4Array ( UINT4Vector * );
REAL4Array * XLALResizeREAL4ArrayL ( REAL4Array *, UINT4, ... );
REAL4Array * XLALResizeREAL4ArrayV ( REAL4Array *, UINT4, UINT4 * );
REAL4Array * XLALResizeREAL4Array ( REAL4Array *, UINT4Vector * );
void XLALDestroyREAL4Array ( REAL4Array * );
void LALSCreateArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALSResizeArray ( LALStatus *, REAL4Array **, UINT4Vector * );
void LALSDestroyArray ( LALStatus *, REAL4Array ** );



/* 



















 * REAL8
 */
REAL8Vector * XLALCreateREAL8Vector ( UINT4 length );
REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length );
void XLALDestroyREAL8Vector ( REAL8Vector * vector );
void LALDCreateVector ( LALStatus *, REAL8Vector **, UINT4 );
void LALDResizeVector ( LALStatus *, REAL8Vector **, UINT4 );
void LALDDestroyVector ( LALStatus *, REAL8Vector ** );

/* 























 * REAL8
 */
REAL8Array * XLALCreateREAL8ArrayL ( UINT4, ... );
REAL8Array * XLALCreateREAL8ArrayV ( UINT4, UINT4 * );
REAL8Array * XLALCreateREAL8Array ( UINT4Vector * );
REAL8Array * XLALResizeREAL8ArrayL ( REAL8Array *, UINT4, ... );
REAL8Array * XLALResizeREAL8ArrayV ( REAL8Array *, UINT4, UINT4 * );
REAL8Array * XLALResizeREAL8Array ( REAL8Array *, UINT4Vector * );
void XLALDestroyREAL8Array ( REAL8Array * );
void LALDCreateArray ( LALStatus *, REAL8Array **, UINT4Vector * );
void LALDResizeArray ( LALStatus *, REAL8Array **, UINT4Vector * );
void LALDDestroyArray ( LALStatus *, REAL8Array ** );



/* 



















 * COMPLEX8
 */
COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length );
COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4 length );
void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector * vector );
void LALCCreateVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCResizeVector ( LALStatus *, COMPLEX8Vector **, UINT4 );
void LALCDestroyVector ( LALStatus *, COMPLEX8Vector ** );

/* 























 * COMPLEX8
 */
COMPLEX8Array * XLALCreateCOMPLEX8ArrayL ( UINT4, ... );
COMPLEX8Array * XLALCreateCOMPLEX8ArrayV ( UINT4, UINT4 * );
COMPLEX8Array * XLALCreateCOMPLEX8Array ( UINT4Vector * );
COMPLEX8Array * XLALResizeCOMPLEX8ArrayL ( COMPLEX8Array *, UINT4, ... );
COMPLEX8Array * XLALResizeCOMPLEX8ArrayV ( COMPLEX8Array *, UINT4, UINT4 * );
COMPLEX8Array * XLALResizeCOMPLEX8Array ( COMPLEX8Array *, UINT4Vector * );
void XLALDestroyCOMPLEX8Array ( COMPLEX8Array * );
void LALCCreateArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * );
void LALCResizeArray ( LALStatus *, COMPLEX8Array **, UINT4Vector * );
void LALCDestroyArray ( LALStatus *, COMPLEX8Array ** );



/* 



















 * COMPLEX16
 */
COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length );
COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UINT4 length );
void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector * vector );
void LALZCreateVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZResizeVector ( LALStatus *, COMPLEX16Vector **, UINT4 );
void LALZDestroyVector ( LALStatus *, COMPLEX16Vector ** );

/* 























 * COMPLEX16
 */
COMPLEX16Array * XLALCreateCOMPLEX16ArrayL ( UINT4, ... );
COMPLEX16Array * XLALCreateCOMPLEX16ArrayV ( UINT4, UINT4 * );
COMPLEX16Array * XLALCreateCOMPLEX16Array ( UINT4Vector * );
COMPLEX16Array * XLALResizeCOMPLEX16ArrayL ( COMPLEX16Array *, UINT4, ... );
COMPLEX16Array * XLALResizeCOMPLEX16ArrayV ( COMPLEX16Array *, UINT4, UINT4 * );
COMPLEX16Array * XLALResizeCOMPLEX16Array ( COMPLEX16Array *, UINT4Vector * );
void XLALDestroyCOMPLEX16Array ( COMPLEX16Array * );
void LALZCreateArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * );
void LALZResizeArray ( LALStatus *, COMPLEX16Array **, UINT4Vector * );
void LALZDestroyArray ( LALStatus *, COMPLEX16Array ** );



/* 



















 * REAL4
 */
REAL4Vector * XLALCreateVector ( UINT4 length );
REAL4Vector * XLALResizeVector ( REAL4Vector * vector, UINT4 length );
void XLALDestroyVector ( REAL4Vector * vector );
void LALCreateVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALResizeVector ( LALStatus *, REAL4Vector **, UINT4 );
void LALDestroyVector ( LALStatus *, REAL4Vector ** );

/* 























 * REAL4
 */
REAL4Array * XLALCreateArrayL ( UINT4, ... );
REAL4Array *