ArrayFactories.c

Go to the documentation of this file.

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

File Name: ArrayFactories.c

<lalVerbatim file="ArrayFactoriesCV">
Revision: $Id: ArrayFactories.m4,v 1.5 2003/09/29 00:33:24 dwchin Exp $
</lalVerbatim>

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

/* <lalLaTeX>

\subsection{Module \texttt{ArrayFactories.c}}
\label{ss:ArrayFactories.c}

Create/destroy $\langle\mbox{datatype}\rangle$Array objects. 

\subsubsection*{Prototypes}
\vspace{0.1in}
\input{ArrayFactoriesD}
\idx{LALZCreateArray()}
\idx{LALCCreateArray()}
\idx{LALDCreateArray()}
\idx{LALSCreateArray()}
\idx{LALI2CreateArray()}
\idx{LALI4CreateArray()}
\idx{LALI8CreateArray()}
\idx{LALU2CreateArray()}
\idx{LALU4CreateArray()}
\idx{LALU8CreateArray()}
\idx{LALCreateArray()}
\idx{LALZDestroyArray()}
\idx{LALCDestroyArray()}
\idx{LALDDestroyArray()}
\idx{LALSDestroyArray()}
\idx{LALI2DestroyArray()}
\idx{LALI4DestroyArray()}
\idx{LALI8DestroyArray()}
\idx{LALU2DestroyArray()}
\idx{LALU4DestroyArray()}
\idx{LALU8DestroyArray()}
\idx{LALDestroyArray()}

\subsubsection*{Description}

The \texttt{CreateArray} family of functions create a
$\langle\mbox{datatype}\rangle$\texttt{Array} of the appropriate dimensions.

The \texttt{DestroyArray} family of functions return the storage allocated by
the \texttt{CreateArray} functions to the system.

\subsubsection*{Algorithm}

\subsubsection*{Uses}
\begin{verbatim}
LALMalloc()
LALFree()
\end{verbatim}

\subsubsection*{Notes}

\vfill{\footnotesize\input{ArrayFactoriesCV}}

</lalLaTeX> */

#include <string.h>
#include "LALStdlib.h"
#include "AVFactories.h"

/* <lalVerbatim file="ArrayFactoriesNRCSID"> */
NRCSID( ARRAYFACTORIESC, "$Id: ArrayFactories.m4,v 1.5 2003/09/29 00:33:24 dwchin Exp $" );
/* </lalVerbatim> */















 
 
 

COMPLEX16Array * XLALCreateCOMPLEX16ArrayL ( UINT4 ndim, ... )
{
  enum { maxdim = 16 };
  va_list ap;
  COMPLEX16Array *arr;
  UINT4 dims[maxdim];
  UINT4 dim;

  if ( ! ndim )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16ArrayL", XLAL_EBADLEN );
  if ( ndim > maxdim )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16ArrayL", XLAL_EINVAL );

  va_start( ap, ndim );
  for ( dim = 0; dim < ndim; ++dim )
    dims[dim] = va_arg( ap, UINT4 );
  va_end( ap );

  arr = XLALCreateCOMPLEX16ArrayV ( ndim, dims );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16ArrayL", XLAL_EFUNC );
  return arr; 
}

COMPLEX16Array * XLALCreateCOMPLEX16ArrayV ( UINT4 ndim, UINT4 *dims )
{
  COMPLEX16Array *arr;
  UINT4Vector dimLength;

  if ( ! ndim )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16ArrayV", XLAL_EBADLEN );
  if ( ! dims )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16ArrayV", XLAL_EFAULT );

  dimLength.length = ndim;
  dimLength.data   = dims;

  arr = XLALCreateCOMPLEX16Array ( &dimLength );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16ArrayV", XLAL_EFUNC );
  return arr;
}


COMPLEX16Array * XLALCreateCOMPLEX16Array ( UINT4Vector *dimLength )
{
  COMPLEX16Array *arr;
  UINT4 size = 1;
  UINT4 ndim;
  UINT4 dim;

  if ( ! dimLength )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_EFAULT );
  if ( ! dimLength->length )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_EBADLEN );
  if ( ! dimLength->data )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_EINVAL );

  ndim = dimLength->length;
  for ( dim = 0; dim < ndim; ++dim )
    size *= dimLength->data[dim];

  if ( ! size )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_EBADLEN );

  /* create array */
  arr = LALMalloc( sizeof( *arr ) );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_ENOMEM );

  /* create array dimensions */
  arr->dimLength = XLALCreateUINT4Vector( ndim );
  if ( ! arr->dimLength )
  {
    LALFree( arr );
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_EFUNC );
  }

  /* copy dimension lengths */
  memcpy( arr->dimLength->data, dimLength->data,
      ndim * sizeof( *arr->dimLength->data ) );

  /* allocate data storage */
  arr->data = LALMalloc( size * sizeof( *arr->data ) );
  if ( ! arr->data )
  {
    XLALDestroyUINT4Vector( arr->dimLength );
    LALFree( arr );
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Array", XLAL_ENOMEM );
  }

  return arr;
}


/* <lalVerbatim file="ArrayFactoriesD"> */
void LALZCreateArray ( LALStatus *status, COMPLEX16Array **array, UINT4Vector *dimLength ) 
{ /* </lalVerbatim> */
  INITSTATUS (status, "LALZCreateArray", ARRAYFACTORIESC);   

  /* make sure arguments are sane */

  ASSERT (array,             status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (!*array,           status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
  ASSERT (dimLength,         status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (dimLength->data,   status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (dimLength->length, status,
          AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);

  *array = XLALCreateCOMPLEX16Array ( dimLength );
  if ( ! *array )
  {
    int code = xlalErrno & ~XLAL_EFUNC; /* turn off subfunction error bit */
    XLALClearErrno();
    if ( code & XLAL_EFAULT )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_EBADLEN )
    {
      ABORT (status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT (status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC);
    }
  }

  RETURN (status);
}
















 
 
 
 
 


COMPLEX16Array * XLALResizeCOMPLEX16ArrayL ( COMPLEX16Array *array, UINT4 ndim, ... )
{
  enum { maxdim = 16 };
  va_list ap;
  UINT4 dims[maxdim];
  UINT4 dim;

  if ( ! ndim )
  {
    XLALDestroyCOMPLEX16Array ( array );
    return NULL;
  }
  if ( ndim > maxdim )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16ArrayL", XLAL_EINVAL );

  va_start( ap, ndim );
  for ( dim = 0; dim < ndim; ++dim )
    dims[dim] = va_arg( ap, UINT4 );
  va_end( ap );

  return XLALResizeCOMPLEX16ArrayV ( array, ndim, dims );
}

COMPLEX16Array * XLALResizeCOMPLEX16ArrayV ( COMPLEX16Array *array, UINT4 ndim, UINT4 *dims )
{
  UINT4Vector dimLength;

  if ( ! ndim )
  {
    XLALDestroyCOMPLEX16Array ( array );
    return NULL;
  }
  if ( ! dims )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16ArrayV", XLAL_EINVAL );

  dimLength.length = ndim;
  dimLength.data   = dims;

  return XLALResizeCOMPLEX16Array ( array, &dimLength );
}

COMPLEX16Array * XLALResizeCOMPLEX16Array ( COMPLEX16Array *array, UINT4Vector *dimLength )
{
  UINT4 size = 1;
  UINT4 ndim;
  UINT4 dim;

  if ( ! array )
    return XLALCreateCOMPLEX16Array ( dimLength );
  if ( ! dimLength )
  {
    XLALDestroyCOMPLEX16Array ( array );
    return NULL;
  }
  if ( ! dimLength->length )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16Array", XLAL_EBADLEN );
  if ( ! dimLength->data )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16Array", XLAL_EINVAL );

  ndim = dimLength->length;
  for ( dim = 0; dim < ndim; ++dim )
    size *= dimLength->data[dim];

  if ( ! size )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16Array", XLAL_EBADLEN );
  
  /* resize array->dimLength vector if needed */
  if ( array->dimLength->length != ndim )
  {
    array->dimLength = XLALResizeUINT4Vector( array->dimLength, ndim );
    if ( ! array->dimLength )
      XLAL_ERROR_NULL( "XLALResizeCOMPLEX16Array", XLAL_EFUNC );
  }

  /* copy dimension lengths */
  memcpy( array->dimLength->data, dimLength->data,
      ndim * sizeof( *array->dimLength->data ) );

  /* reallocate data storage */
  array->data = LALRealloc( array->data, size * sizeof( *array->data ) );
  if ( ! array->data )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16Array", XLAL_ENOMEM );

  return array;
}

/* <lalVerbatim file="ArrayFactoriesD"> */
void LALZResizeArray ( LALStatus *status, COMPLEX16Array **array, UINT4Vector *dimLength )
{  /* </lalVerbatim> */
  COMPLEX16Array *tmparr = NULL;

  INITSTATUS (status, "LALZResizeArray", ARRAYFACTORIESC);

  ASSERT ( array != NULL, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR );

  if ( ! array )
  {
    tmparr = XLALCreateCOMPLEX16Array ( dimLength );
  }
  else if ( ! dimLength )
  {
    XLALDestroyCOMPLEX16Array ( *array );
    *array = NULL;
  }
  else
  {
    tmparr = XLALResizeCOMPLEX16Array ( *array, dimLength );
  }

  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_EBADLEN )
    {
      ABORT (status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT (status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC);
    }
  }

  *array = tmparr;

  RETURN (status);
}














  

void XLALDestroyCOMPLEX16Array ( COMPLEX16Array *array )
{
  if ( ! array )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX16Array", XLAL_EFAULT );
  if ( ! array->dimLength
      || ! array->dimLength->length
      || ! array->dimLength->data
      || ! array->data )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX16Array", XLAL_EINVAL );
  XLALDestroyUINT4Vector( array->dimLength );
  LALFree( array->data );
  LALFree( array );
  return;
}

/* <lalVerbatim file="ArrayFactoriesD"> */
void LALZDestroyArray ( LALStatus *status, COMPLEX16Array **array )
{ /* </lalVerbatim> */
  INITSTATUS (status, "LALZDestroyArray", ARRAYFACTORIESC);     
      
  ASSERT (array,          status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (*array,         status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
  ASSERT ((*array)->data, status, AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR);

  /* Free allocated storage */

  XLALDestroyCOMPLEX16Array ( *array );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR);
    }
  }
  *array = NULL;            /* make sure we don't point to freed struct */

  RETURN (status);
}
















 
 
 

COMPLEX8Array * XLALCreateCOMPLEX8ArrayL ( UINT4 ndim, ... )
{
  enum { maxdim = 16 };
  va_list ap;
  COMPLEX8Array *arr;
  UINT4 dims[maxdim];
  UINT4 dim;

  if ( ! ndim )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8ArrayL", XLAL_EBADLEN );
  if ( ndim > maxdim )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8ArrayL", XLAL_EINVAL );

  va_start( ap, ndim );
  for ( dim = 0; dim < ndim; ++dim )
    dims[dim] = va_arg( ap, UINT4 );
  va_end( ap );

  arr = XLALCreateCOMPLEX8ArrayV ( ndim, dims );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8ArrayL", XLAL_EFUNC );
  return arr; 
}

COMPLEX8Array * XLALCreateCOMPLEX8ArrayV ( UINT4 ndim, UINT4 *dims )
{
  COMPLEX8Array *arr;
  UINT4Vector dimLength;

  if ( ! ndim )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8ArrayV", XLAL_EBADLEN );
  if ( ! dims )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8ArrayV", XLAL_EFAULT );

  dimLength.length = ndim;
  dimLength.data   = dims;

  arr = XLALCreateCOMPLEX8Array ( &dimLength );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8ArrayV", XLAL_EFUNC );
  return arr;
}


COMPLEX8Array * XLALCreateCOMPLEX8Array ( UINT4Vector *dimLength )
{
  COMPLEX8Array *arr;
  UINT4 size = 1;
  UINT4 ndim;
  UINT4 dim;

  if ( ! dimLength )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_EFAULT );
  if ( ! dimLength->length )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_EBADLEN );
  if ( ! dimLength->data )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_EINVAL );

  ndim = dimLength->length;
  for ( dim = 0; dim < ndim; ++dim )
    size *= dimLength->data[dim];

  if ( ! size )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_EBADLEN );

  /* create array */
  arr = LALMalloc( sizeof( *arr ) );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_ENOMEM );

  /* create array dimensions */
  arr->dimLength = XLALCreateUINT4Vector( ndim );
  if ( ! arr->dimLength )
  {
    LALFree( arr );
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_EFUNC );
  }

  /* copy dimension lengths */
  memcpy( arr->dimLength->data, dimLength->data,
      ndim * sizeof( *arr->dimLength->data ) );

  /* allocate data storage */
  arr->data = LALMalloc( size * sizeof( *arr->data ) );
  if ( ! arr->data )
  {
    XLALDestroyUINT4Vector( arr->dimLength );
    LALFree( arr );
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Array", XLAL_ENOMEM );
  }

  return arr;
}


/* <lalVerbatim file="ArrayFactoriesD"> */
void LALCCreateArray ( LALStatus *status, COMPLEX8Array **array, UINT4Vector *dimLength ) 
{ /* </lalVerbatim> */
  INITSTATUS (status, "LALCCreateArray", ARRAYFACTORIESC);   

  /* make sure arguments are sane */

  ASSERT (array,             status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (!*array,           status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
  ASSERT (dimLength,         status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (dimLength->data,   status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (dimLength->length, status,
          AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);

  *array = XLALCreateCOMPLEX8Array ( dimLength );
  if ( ! *array )
  {
    int code = xlalErrno & ~XLAL_EFUNC; /* turn off subfunction error bit */
    XLALClearErrno();
    if ( code & XLAL_EFAULT )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_EBADLEN )
    {
      ABORT (status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT (status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC);
    }
  }

  RETURN (status);
}
















 
 
 
 
 


COMPLEX8Array * XLALResizeCOMPLEX8ArrayL ( COMPLEX8Array *array, UINT4 ndim, ... )
{
  enum { maxdim = 16 };
  va_list ap;
  UINT4 dims[maxdim];
  UINT4 dim;

  if ( ! ndim )
  {
    XLALDestroyCOMPLEX8Array ( array );
    return NULL;
  }
  if ( ndim > maxdim )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8ArrayL", XLAL_EINVAL );

  va_start( ap, ndim );
  for ( dim = 0; dim < ndim; ++dim )
    dims[dim] = va_arg( ap, UINT4 );
  va_end( ap );

  return XLALResizeCOMPLEX8ArrayV ( array, ndim, dims );
}

COMPLEX8Array * XLALResizeCOMPLEX8ArrayV ( COMPLEX8Array *array, UINT4 ndim, UINT4 *dims )
{
  UINT4Vector dimLength;

  if ( ! ndim )
  {
    XLALDestroyCOMPLEX8Array ( array );
    return NULL;
  }
  if ( ! dims )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8ArrayV", XLAL_EINVAL );

  dimLength.length = ndim;
  dimLength.data   = dims;

  return XLALResizeCOMPLEX8Array ( array, &dimLength );
}

COMPLEX8Array * XLALResizeCOMPLEX8Array ( COMPLEX8Array *array, UINT4Vector *dimLength )
{
  UINT4 size = 1;
  UINT4 ndim;
  UINT4 dim;

  if ( ! array )
    return XLALCreateCOMPLEX8Array ( dimLength );
  if ( ! dimLength )
  {
    XLALDestroyCOMPLEX8Array ( array );
    return NULL;
  }
  if ( ! dimLength->length )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8Array", XLAL_EBADLEN );
  if ( ! dimLength->data )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8Array", XLAL_EINVAL );

  ndim = dimLength->length;
  for ( dim = 0; dim < ndim; ++dim )
    size *= dimLength->data[dim];

  if ( ! size )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8Array", XLAL_EBADLEN );
  
  /* resize array->dimLength vector if needed */
  if ( array->dimLength->length != ndim )
  {
    array->dimLength = XLALResizeUINT4Vector( array->dimLength, ndim );
    if ( ! array->dimLength )
      XLAL_ERROR_NULL( "XLALResizeCOMPLEX8Array", XLAL_EFUNC );
  }

  /* copy dimension lengths */
  memcpy( array->dimLength->data, dimLength->data,
      ndim * sizeof( *array->dimLength->data ) );

  /* reallocate data storage */
  array->data = LALRealloc( array->data, size * sizeof( *array->data ) );
  if ( ! array->data )
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8Array", XLAL_ENOMEM );

  return array;
}

/* <lalVerbatim file="ArrayFactoriesD"> */
void LALCResizeArray ( LALStatus *status, COMPLEX8Array **array, UINT4Vector *dimLength )
{  /* </lalVerbatim> */
  COMPLEX8Array *tmparr = NULL;

  INITSTATUS (status, "LALCResizeArray", ARRAYFACTORIESC);

  ASSERT ( array != NULL, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR );

  if ( ! array )
  {
    tmparr = XLALCreateCOMPLEX8Array ( dimLength );
  }
  else if ( ! dimLength )
  {
    XLALDestroyCOMPLEX8Array ( *array );
    *array = NULL;
  }
  else
  {
    tmparr = XLALResizeCOMPLEX8Array ( *array, dimLength );
  }

  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_EBADLEN )
    {
      ABORT (status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT (status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC);
    }
  }

  *array = tmparr;

  RETURN (status);
}














  

void XLALDestroyCOMPLEX8Array ( COMPLEX8Array *array )
{
  if ( ! array )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX8Array", XLAL_EFAULT );
  if ( ! array->dimLength
      || ! array->dimLength->length
      || ! array->dimLength->data
      || ! array->data )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX8Array", XLAL_EINVAL );
  XLALDestroyUINT4Vector( array->dimLength );
  LALFree( array->data );
  LALFree( array );
  return;
}

/* <lalVerbatim file="ArrayFactoriesD"> */
void LALCDestroyArray ( LALStatus *status, COMPLEX8Array **array )
{ /* </lalVerbatim> */
  INITSTATUS (status, "LALCDestroyArray", ARRAYFACTORIESC);     
      
  ASSERT (array,          status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (*array,         status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
  ASSERT ((*array)->data, status, AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR);

  /* Free allocated storage */

  XLALDestroyCOMPLEX8Array ( *array );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno();
    if ( code == XLAL_EFAULT )
    {
      ABORT (status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (status, AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR);
    }
  }
  *array = NULL;            /* make sure we don't point to freed struct */

  RETURN (status);
}
















 
 
 

REAL8Array * XLALCreateREAL8ArrayL ( UINT4 ndim, ... )
{
  enum { maxdim = 16 };
  va_list ap;
  REAL8Array *arr;
  UINT4 dims[maxdim];
  UINT4 dim;

  if ( ! ndim )
    XLAL_ERROR_NULL( "XLALCreateREAL8ArrayL", XLAL_EBADLEN );
  if ( ndim > maxdim )
    XLAL_ERROR_NULL( "XLALCreateREAL8ArrayL", XLAL_EINVAL );

  va_start( ap, ndim );
  for ( dim = 0; dim < ndim; ++dim )
    dims[dim] = va_arg( ap, UINT4 );
  va_end( ap );

  arr = XLALCreateREAL8ArrayV ( ndim, dims );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateREAL8ArrayL", XLAL_EFUNC );
  return arr; 
}

REAL8Array * XLALCreateREAL8ArrayV ( UINT4 ndim, UINT4 *dims )
{
  REAL8Array *arr;
  UINT4Vector dimLength;

  if ( ! ndim )
    XLAL_ERROR_NULL( "XLALCreateREAL8ArrayV", XLAL_EBADLEN );
  if ( ! dims )
    XLAL_ERROR_NULL( "XLALCreateREAL8ArrayV", XLAL_EFAULT );

  dimLength.length = ndim;
  dimLength.data   = dims;

  arr = XLALCreateREAL8Array ( &dimLength );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateREAL8ArrayV", XLAL_EFUNC );
  return arr;
}


REAL8Array * XLALCreateREAL8Array ( UINT4Vector *dimLength )
{
  REAL8Array *arr;
  UINT4 size = 1;
  UINT4 ndim;
  UINT4 dim;

  if ( ! dimLength )
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_EFAULT );
  if ( ! dimLength->length )
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_EBADLEN );
  if ( ! dimLength->data )
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_EINVAL );

  ndim = dimLength->length;
  for ( dim = 0; dim < ndim; ++dim )
    size *= dimLength->data[dim];

  if ( ! size )
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_EBADLEN );

  /* create array */
  arr = LALMalloc( sizeof( *arr ) );
  if ( ! arr )
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_ENOMEM );

  /* create array dimensions */
  arr->dimLength = XLALCreateUINT4Vector( ndim );
  if ( ! arr->dimLength )
  {
    LALFree( arr );
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_EFUNC );
  }

  /* copy dimension lengths */
  memcpy( arr->dimLength->data, dimLength->data,
      ndim * sizeof( *arr->dimLength->data ) );

  /* allocate data storage */
  arr->data = LALMalloc( size * sizeof( *arr->data ) );
  if ( ! arr->data )
  {
    XLALDestroyUINT4Vector( arr->dimLength );
    LALFree( arr );
    XLAL_ERROR_NULL( "XLALCreateREAL8Array", XLAL_ENOMEM );
  }

  return arr;
}


/* <lalVerbatim file="ArrayFactoriesD"> */
void LALDCreateArray ( LALStatus *status, REAL8Array **array, UINT4Vector *dimLength ) 
{ /* </lalVerbatim> */
  INITSTATUS (status, "LALDCreateArray", ARRAYFACTORIESC);   

  /* make sure arguments are sane */

  ASSERT (array,             status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (!*array,           status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR);
  ASSERT (dimLength,         status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (dimLength->data,   status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
  ASSERT (dimLength->length, status,
          AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);

  *array = XLALCreateREAL8Array ( dimLength );
  if ( ! *array )
  {
    int code = xlalErrno & ~XLAL_EFUNC; /* turn off subfunction error bit */
    XLALClearErrno();
    if ( code & XLAL_EFAULT )
    {
      ABORT (status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR);
    }
    if ( code == XLAL_EBADLEN )
    {
      ABORT (status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH);
    }
    if ( code == XLAL_EINVAL )
    {
      ABORT (