VectorFactories.c

Go to the documentation of this file.

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

File Name: VectorFactories.c

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

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

/* <lalLaTeX>

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

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

\subsubsection*{Prototypes}
\vspace{0.1in}
\input{VectorFactoriesD}
\idx{LALZCreateVector()}
\idx{LALCCreateVector()}
\idx{LALDCreateVector()}
\idx{LALSCreateVector()}
\idx{LALI2CreateVector()}
\idx{LALI4CreateVector()}
\idx{LALI8CreateVector()}
\idx{LALU2CreateVector()}
\idx{LALU4CreateVector()}
\idx{LALU8CreateVector()}
\idx{LALCHARCreateVector()}
\idx{LALCreateVector()}
\idx{LALZDestroyVector()}
\idx{LALCDestroyVector()}
\idx{LALDDestroyVector()}
\idx{LALSDestroyVector()}
\idx{LALI2DestroyVector()}
\idx{LALI4DestroyVector()}
\idx{LALI8DestroyVector()}
\idx{LALU2DestroyVector()}
\idx{LALU4DestroyVector()}
\idx{LALU8DestroyVector()}
\idx{LALCHARDestroyVector()}
\idx{LALDestroyVector()}

\subsubsection*{Description}

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

The \texttt{ResizeVector} family of functions changes the amount of
storage allocated by the \texttt{CreateVector} functions.

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

\subsubsection*{Algorithm}

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

\subsubsection*{Notes}

\vfill{\footnotesize\input{VectorFactoriesCV}}

</lalLaTeX> */

#include "LALStdlib.h"
#include "AVFactories.h"

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
















 

COMPLEX16Vector * XLALCreateCOMPLEX16Vector ( UINT4 length )
{
  COMPLEX16Vector * vector;
  vector = LALMalloc( sizeof( *vector ) );
  if ( ! vector )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Vector", XLAL_ENOMEM );
  vector->length = length;
  if ( ! length ) /* zero length: set data pointer to be NULL */
    vector->data = NULL;
  else /* non-zero length: allocate memory for data */
  {
    vector->data = LALMalloc( length * sizeof( *vector->data ) );
    if ( ! vector->data )
    {
      LALFree( vector );
      XLAL_ERROR_NULL( "XLALCreateCOMPLEX16Vector", XLAL_ENOMEM );
    }
  }
  return vector;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALZCreateVector ( LALStatus *status, COMPLEX16Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */

  INITSTATUS( status, "LALZCreateVector", VECTORFACTORIESC );   
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT( length > 0, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

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

  ASSERT( *vector == NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Allocate pointer
   */

  *vector = XLALCreateCOMPLEX16Vector ( length );
  if ( ! *vector )
  {
    XLALClearErrno();
    ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
  }

  /* We be done: Normal exit */

  RETURN( status );
}















 



COMPLEX16Vector * XLALResizeCOMPLEX16Vector ( COMPLEX16Vector * vector, UINT4 length )
{
  if ( ! vector )
    return XLALCreateCOMPLEX16Vector ( length );
  if ( ! length )
  {
    XLALDestroyCOMPLEX16Vector ( vector );
    return NULL;
  }
  vector->data = LALRealloc( vector->data, length * sizeof( *vector->data ) );
  if ( ! vector->data )
  {
    vector->length = 0;
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX16Vector", XLAL_ENOMEM );
  }
  vector->length = length;
  return vector;
}


/* <lalVerbatim file="VectorFactoriesD"> */
void LALZResizeVector ( LALStatus *status, COMPLEX16Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */
  INITSTATUS( status, "LALZResizeVector", VECTORFACTORIESC );   

  ASSERT ( vector != NULL, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR );
  ASSERT ( ! *vector || (*vector)->length, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
  ASSERT ( length || *vector, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* Want this to behave like realloc(3), i.e.
   * *vector == NULL => create a new vector 
   * length == 0 => destroy the vector 
   * otherwise => resize given vector 
   */

  *vector = XLALResizeCOMPLEX16Vector ( *vector, length );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno(); 
    if ( code == XLAL_EBADLEN )
    {
      ABORT( status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
    }
  }
      
  RETURN( status );
}















 

void XLALDestroyCOMPLEX16Vector ( COMPLEX16Vector *vector )
{
  if ( ! vector )
    return;
  if ( ( ! vector->length || ! vector->data ) && ( vector->length || vector->data  ) )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX16Vector", XLAL_EINVAL );
  if ( vector->data )
    LALFree( vector->data );
  vector->data = NULL; /* leave length non-zero to detect repeated frees */
  LALFree( vector );
  return;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALZDestroyVector ( LALStatus *status, COMPLEX16Vector **vector )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALZDestroyVector", VECTORFACTORIESC );  
      
  /* 
   * Check vector: is it non-NULL?
   */

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

  /* 
   * Check vector: does it point to non-NULL?
   */

  ASSERT( *vector != NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Check data in vector: does it point to non-NULL
   */

  ASSERT( (*vector)->data != NULL, status,
          AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR );

  /* Ok, now let's free allocated storage */

  XLALDestroyCOMPLEX16Vector ( *vector );
  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 );
    }
  }

  *vector = NULL;               /* make sure we don't point to freed struct */

  RETURN( status );
}

















 

COMPLEX8Vector * XLALCreateCOMPLEX8Vector ( UINT4 length )
{
  COMPLEX8Vector * vector;
  vector = LALMalloc( sizeof( *vector ) );
  if ( ! vector )
    XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Vector", XLAL_ENOMEM );
  vector->length = length;
  if ( ! length ) /* zero length: set data pointer to be NULL */
    vector->data = NULL;
  else /* non-zero length: allocate memory for data */
  {
    vector->data = LALMalloc( length * sizeof( *vector->data ) );
    if ( ! vector->data )
    {
      LALFree( vector );
      XLAL_ERROR_NULL( "XLALCreateCOMPLEX8Vector", XLAL_ENOMEM );
    }
  }
  return vector;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALCCreateVector ( LALStatus *status, COMPLEX8Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */

  INITSTATUS( status, "LALCCreateVector", VECTORFACTORIESC );   
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT( length > 0, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

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

  ASSERT( *vector == NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Allocate pointer
   */

  *vector = XLALCreateCOMPLEX8Vector ( length );
  if ( ! *vector )
  {
    XLALClearErrno();
    ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
  }

  /* We be done: Normal exit */

  RETURN( status );
}















 



COMPLEX8Vector * XLALResizeCOMPLEX8Vector ( COMPLEX8Vector * vector, UINT4 length )
{
  if ( ! vector )
    return XLALCreateCOMPLEX8Vector ( length );
  if ( ! length )
  {
    XLALDestroyCOMPLEX8Vector ( vector );
    return NULL;
  }
  vector->data = LALRealloc( vector->data, length * sizeof( *vector->data ) );
  if ( ! vector->data )
  {
    vector->length = 0;
    XLAL_ERROR_NULL( "XLALResizeCOMPLEX8Vector", XLAL_ENOMEM );
  }
  vector->length = length;
  return vector;
}


/* <lalVerbatim file="VectorFactoriesD"> */
void LALCResizeVector ( LALStatus *status, COMPLEX8Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */
  INITSTATUS( status, "LALCResizeVector", VECTORFACTORIESC );   

  ASSERT ( vector != NULL, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR );
  ASSERT ( ! *vector || (*vector)->length, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
  ASSERT ( length || *vector, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* Want this to behave like realloc(3), i.e.
   * *vector == NULL => create a new vector 
   * length == 0 => destroy the vector 
   * otherwise => resize given vector 
   */

  *vector = XLALResizeCOMPLEX8Vector ( *vector, length );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno(); 
    if ( code == XLAL_EBADLEN )
    {
      ABORT( status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
    }
  }
      
  RETURN( status );
}















 

void XLALDestroyCOMPLEX8Vector ( COMPLEX8Vector *vector )
{
  if ( ! vector )
    return;
  if ( ( ! vector->length || ! vector->data ) && ( vector->length || vector->data  ) )
    XLAL_ERROR_VOID( "XLALDestroyCOMPLEX8Vector", XLAL_EINVAL );
  if ( vector->data )
    LALFree( vector->data );
  vector->data = NULL; /* leave length non-zero to detect repeated frees */
  LALFree( vector );
  return;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALCDestroyVector ( LALStatus *status, COMPLEX8Vector **vector )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALCDestroyVector", VECTORFACTORIESC );  
      
  /* 
   * Check vector: is it non-NULL?
   */

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

  /* 
   * Check vector: does it point to non-NULL?
   */

  ASSERT( *vector != NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Check data in vector: does it point to non-NULL
   */

  ASSERT( (*vector)->data != NULL, status,
          AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR );

  /* Ok, now let's free allocated storage */

  XLALDestroyCOMPLEX8Vector ( *vector );
  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 );
    }
  }

  *vector = NULL;               /* make sure we don't point to freed struct */

  RETURN( status );
}

















 

REAL8Vector * XLALCreateREAL8Vector ( UINT4 length )
{
  REAL8Vector * vector;
  vector = LALMalloc( sizeof( *vector ) );
  if ( ! vector )
    XLAL_ERROR_NULL( "XLALCreateREAL8Vector", XLAL_ENOMEM );
  vector->length = length;
  if ( ! length ) /* zero length: set data pointer to be NULL */
    vector->data = NULL;
  else /* non-zero length: allocate memory for data */
  {
    vector->data = LALMalloc( length * sizeof( *vector->data ) );
    if ( ! vector->data )
    {
      LALFree( vector );
      XLAL_ERROR_NULL( "XLALCreateREAL8Vector", XLAL_ENOMEM );
    }
  }
  return vector;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALDCreateVector ( LALStatus *status, REAL8Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */

  INITSTATUS( status, "LALDCreateVector", VECTORFACTORIESC );   
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT( length > 0, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

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

  ASSERT( *vector == NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Allocate pointer
   */

  *vector = XLALCreateREAL8Vector ( length );
  if ( ! *vector )
  {
    XLALClearErrno();
    ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
  }

  /* We be done: Normal exit */

  RETURN( status );
}















 



REAL8Vector * XLALResizeREAL8Vector ( REAL8Vector * vector, UINT4 length )
{
  if ( ! vector )
    return XLALCreateREAL8Vector ( length );
  if ( ! length )
  {
    XLALDestroyREAL8Vector ( vector );
    return NULL;
  }
  vector->data = LALRealloc( vector->data, length * sizeof( *vector->data ) );
  if ( ! vector->data )
  {
    vector->length = 0;
    XLAL_ERROR_NULL( "XLALResizeREAL8Vector", XLAL_ENOMEM );
  }
  vector->length = length;
  return vector;
}


/* <lalVerbatim file="VectorFactoriesD"> */
void LALDResizeVector ( LALStatus *status, REAL8Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */
  INITSTATUS( status, "LALDResizeVector", VECTORFACTORIESC );   

  ASSERT ( vector != NULL, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR );
  ASSERT ( ! *vector || (*vector)->length, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
  ASSERT ( length || *vector, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* Want this to behave like realloc(3), i.e.
   * *vector == NULL => create a new vector 
   * length == 0 => destroy the vector 
   * otherwise => resize given vector 
   */

  *vector = XLALResizeREAL8Vector ( *vector, length );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno(); 
    if ( code == XLAL_EBADLEN )
    {
      ABORT( status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
    }
  }
      
  RETURN( status );
}















 

void XLALDestroyREAL8Vector ( REAL8Vector *vector )
{
  if ( ! vector )
    return;
  if ( ( ! vector->length || ! vector->data ) && ( vector->length || vector->data  ) )
    XLAL_ERROR_VOID( "XLALDestroyREAL8Vector", XLAL_EINVAL );
  if ( vector->data )
    LALFree( vector->data );
  vector->data = NULL; /* leave length non-zero to detect repeated frees */
  LALFree( vector );
  return;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALDDestroyVector ( LALStatus *status, REAL8Vector **vector )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALDDestroyVector", VECTORFACTORIESC );  
      
  /* 
   * Check vector: is it non-NULL?
   */

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

  /* 
   * Check vector: does it point to non-NULL?
   */

  ASSERT( *vector != NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Check data in vector: does it point to non-NULL
   */

  ASSERT( (*vector)->data != NULL, status,
          AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR );

  /* Ok, now let's free allocated storage */

  XLALDestroyREAL8Vector ( *vector );
  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 );
    }
  }

  *vector = NULL;               /* make sure we don't point to freed struct */

  RETURN( status );
}

















 

REAL4Vector * XLALCreateREAL4Vector ( UINT4 length )
{
  REAL4Vector * vector;
  vector = LALMalloc( sizeof( *vector ) );
  if ( ! vector )
    XLAL_ERROR_NULL( "XLALCreateREAL4Vector", XLAL_ENOMEM );
  vector->length = length;
  if ( ! length ) /* zero length: set data pointer to be NULL */
    vector->data = NULL;
  else /* non-zero length: allocate memory for data */
  {
    vector->data = LALMalloc( length * sizeof( *vector->data ) );
    if ( ! vector->data )
    {
      LALFree( vector );
      XLAL_ERROR_NULL( "XLALCreateREAL4Vector", XLAL_ENOMEM );
    }
  }
  return vector;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALSCreateVector ( LALStatus *status, REAL4Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */

  INITSTATUS( status, "LALSCreateVector", VECTORFACTORIESC );   
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT( length > 0, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

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

  ASSERT( *vector == NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Allocate pointer
   */

  *vector = XLALCreateREAL4Vector ( length );
  if ( ! *vector )
  {
    XLALClearErrno();
    ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
  }

  /* We be done: Normal exit */

  RETURN( status );
}















 



REAL4Vector * XLALResizeREAL4Vector ( REAL4Vector * vector, UINT4 length )
{
  if ( ! vector )
    return XLALCreateREAL4Vector ( length );
  if ( ! length )
  {
    XLALDestroyREAL4Vector ( vector );
    return NULL;
  }
  vector->data = LALRealloc( vector->data, length * sizeof( *vector->data ) );
  if ( ! vector->data )
  {
    vector->length = 0;
    XLAL_ERROR_NULL( "XLALResizeREAL4Vector", XLAL_ENOMEM );
  }
  vector->length = length;
  return vector;
}


/* <lalVerbatim file="VectorFactoriesD"> */
void LALSResizeVector ( LALStatus *status, REAL4Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */
  INITSTATUS( status, "LALSResizeVector", VECTORFACTORIESC );   

  ASSERT ( vector != NULL, status, AVFACTORIESH_EVPTR, AVFACTORIESH_MSGEVPTR );
  ASSERT ( ! *vector || (*vector)->length, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
  ASSERT ( length || *vector, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* Want this to behave like realloc(3), i.e.
   * *vector == NULL => create a new vector 
   * length == 0 => destroy the vector 
   * otherwise => resize given vector 
   */

  *vector = XLALResizeREAL4Vector ( *vector, length );
  if ( xlalErrno )
  {
    int code = xlalErrno;
    XLALClearErrno(); 
    if ( code == XLAL_EBADLEN )
    {
      ABORT( status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );
    }
    if ( code == XLAL_ENOMEM )
    {
      ABORT( status, AVFACTORIESH_EMALLOC, AVFACTORIESH_MSGEMALLOC );
    }
  }
      
  RETURN( status );
}















 

void XLALDestroyREAL4Vector ( REAL4Vector *vector )
{
  if ( ! vector )
    return;
  if ( ( ! vector->length || ! vector->data ) && ( vector->length || vector->data  ) )
    XLAL_ERROR_VOID( "XLALDestroyREAL4Vector", XLAL_EINVAL );
  if ( vector->data )
    LALFree( vector->data );
  vector->data = NULL; /* leave length non-zero to detect repeated frees */
  LALFree( vector );
  return;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALSDestroyVector ( LALStatus *status, REAL4Vector **vector )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALSDestroyVector", VECTORFACTORIESC );  
      
  /* 
   * Check vector: is it non-NULL?
   */

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

  /* 
   * Check vector: does it point to non-NULL?
   */

  ASSERT( *vector != NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Check data in vector: does it point to non-NULL
   */

  ASSERT( (*vector)->data != NULL, status,
          AVFACTORIESH_EDPTR, AVFACTORIESH_MSGEDPTR );

  /* Ok, now let's free allocated storage */

  XLALDestroyREAL4Vector ( *vector );
  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 );
    }
  }

  *vector = NULL;               /* make sure we don't point to freed struct */

  RETURN( status );
}

















 

INT2Vector * XLALCreateINT2Vector ( UINT4 length )
{
  INT2Vector * vector;
  vector = LALMalloc( sizeof( *vector ) );
  if ( ! vector )
    XLAL_ERROR_NULL( "XLALCreateINT2Vector", XLAL_ENOMEM );
  vector->length = length;
  if ( ! length ) /* zero length: set data pointer to be NULL */
    vector->data = NULL;
  else /* non-zero length: allocate memory for data */
  {
    vector->data = LALMalloc( length * sizeof( *vector->data ) );
    if ( ! vector->data )
    {
      LALFree( vector );
      XLAL_ERROR_NULL( "XLALCreateINT2Vector", XLAL_ENOMEM );
    }
  }
  return vector;
}

/* <lalVerbatim file="VectorFactoriesD"> */
void LALI2CreateVector ( LALStatus *status, INT2Vector **vector, UINT4 length ) 
{ /* </lalVerbatim> */
  /* 
   * Initialize status structure
   */

  INITSTATUS( status, "LALI2CreateVector", VECTORFACTORIESC );  
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT( length > 0, status, AVFACTORIESH_ELENGTH, AVFACTORIESH_MSGELENGTH );

  /* 
   * Check return structure: If return pointer does not point to a
   *    valid pointer then report an error 
   */

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

  ASSERT( *vector == NULL, status, AVFACTORIESH_EUPTR, AVFACTORIESH_MSGEUPTR );

  /*
   * Allocate pointer