ArraySequenceFactories.c

Go to the documentation of this file.

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

File Name: ArraySequenceFactories.c

<lalVerbatim file="ArraySequenceFactoriesCV">
Revision: $Id: ArraySequenceFactories.m4,v 1.1 2002/05/21 17:14:38 teviet Exp $
</lalVerbatim>

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

/* <lalLaTeX>

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

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

\subsubsection*{Prototypes}
\vspace{0.1in}
\input{ArraySequenceFactoriesD}
\idx{LALZCreateArraySequence()}
\idx{LALCCreateArraySequence()}
\idx{LALDCreateArraySequence()}
\idx{LALSCreateArraySequence()}
\idx{LALI2CreateArraySequence()}
\idx{LALI4CreateArraySequence()}
\idx{LALI8CreateArraySequence()}
\idx{LALU2CreateArraySequence()}
\idx{LALU4CreateArraySequence()}
\idx{LALU8CreateArraySequence()}
\idx{LALCreateArraySequence()}
\idx{LALZDestroyArraySequence()}
\idx{LALCDestroyArraySequence()}
\idx{LALDDestroyArraySequence()}
\idx{LALSDestroyArraySequence()}
\idx{LALI2DestroyArraySequence()}
\idx{LALI4DestroyArraySequence()}
\idx{LALI8DestroyArraySequence()}
\idx{LALU2DestroyArraySequence()}
\idx{LALU4DestroyArraySequence()}
\idx{LALU8DestroyArraySequence()}
\idx{LALDestroyArraySequence()}

\subsubsection*{Description}

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

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

\subsubsection*{Algorithm}

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

\subsubsection*{Notes}

\vfill{\footnotesize\input{ArraySequenceFactoriesCV}}

</lalLaTeX> */

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

/* <lalVerbatim file="ArraySequenceFactoriesNRCSID"> */
NRCSID( ARRAYSEQUENCEFACTORIESC, "$Id: ArraySequenceFactories.m4,v 1.1 2002/05/21 17:14:38 teviet Exp $" );
/* </lalVerbatim> */
















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALZCreateArraySequence ( LALStatus *status, COMPLEX16ArraySequence **aseq, CreateArraySequenceIn *in ) 
{ /* </lalVerbatim> */
  UINT4 i;

  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALZCreateArraySequence", ARRAYSEQUENCEFACTORIESC );     
  ATTATCHSTATUSPTR( status );

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
  ASSERT (in->dimLength, status,
          SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR); 
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check dimension lengths: report error any are 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */
#ifndef NDEBUG
  for ( i = 0; i < in->dimLength->length; i++ )
  {
    ASSERT (in->dimLength->data[i] > 0, status,
            SEQFACTORIESH_EALENGTH, SEQFACTORIESH_MSGEALENGTH); 
  }
#endif

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

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*aseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Allocate pointer
   */

  *aseq = ( COMPLEX16ArraySequence * ) LALMalloc( sizeof( COMPLEX16ArraySequence ) );
  if ( NULL == *aseq )
  {
    ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
  }

  (*aseq)->length = in->length;
  (*aseq)->arrayDim = 1;
  (*aseq)->dimLength = NULL;    /* NULL dimLength until allocated */
  (*aseq)->data   = NULL;       /* NULL data until allocated */

  /* 
   * Allocate dimLength
   */
  {
    LALU4CreateVector( status->statusPtr, &((*aseq)->dimLength),
                       in->dimLength->length );
    BEGINFAIL( status ) {
      LALFree ((void *) *aseq);
      ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
    } ENDFAIL( status );
    for ( i = 0; i < in->dimLength->length; i++ )
      (*aseq)->arrayDim *= (*aseq)->dimLength->data[i]
        = in->dimLength->data[i];
  }

  /* 
   * Allocate storage 
   */
  {
    size_t tlength;
    tlength = (*aseq)->length * (*aseq)->arrayDim * sizeof( COMPLEX16 );
    (*aseq)->data = ( COMPLEX16 * ) LALMalloc (tlength);
  }

  if (NULL == (*aseq)->data)
  {
    /* Must free storage pointed to by *aseq */
    TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
         status );
    LALFree ((void *) *aseq);
    ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
  }

  /* We be done: Normal exit */

  DETATCHSTATUSPTR( status );
  RETURN (status);
}















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALZDestroyArraySequence ( LALStatus *status, COMPLEX16ArraySequence **aseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALZDestroyArraySequence", ARRAYSEQUENCEFACTORIESC );
  ATTATCHSTATUSPTR( status );
      
  /* 
   * Check aseq: is it non-NULL?
   */

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

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

  ASSERT (*aseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check dimLength in aseq: does it point to non-NULL?
   */

  ASSERT ((*aseq)->dimLength != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  ASSERT ((*aseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
       status );
  LALFree ( (*aseq)->data ); /* free allocated data */
  LALFree ( *aseq );          /* free aseq struct itself */

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

  DETATCHSTATUSPTR( status );
  RETURN (status);
}

















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALCCreateArraySequence ( LALStatus *status, COMPLEX8ArraySequence **aseq, CreateArraySequenceIn *in ) 
{ /* </lalVerbatim> */
  UINT4 i;

  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALCCreateArraySequence", ARRAYSEQUENCEFACTORIESC );     
  ATTATCHSTATUSPTR( status );

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
  ASSERT (in->dimLength, status,
          SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR); 
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check dimension lengths: report error any are 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */
#ifndef NDEBUG
  for ( i = 0; i < in->dimLength->length; i++ )
  {
    ASSERT (in->dimLength->data[i] > 0, status,
            SEQFACTORIESH_EALENGTH, SEQFACTORIESH_MSGEALENGTH); 
  }
#endif

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

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*aseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Allocate pointer
   */

  *aseq = ( COMPLEX8ArraySequence * ) LALMalloc( sizeof( COMPLEX8ArraySequence ) );
  if ( NULL == *aseq )
  {
    ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
  }

  (*aseq)->length = in->length;
  (*aseq)->arrayDim = 1;
  (*aseq)->dimLength = NULL;    /* NULL dimLength until allocated */
  (*aseq)->data   = NULL;       /* NULL data until allocated */

  /* 
   * Allocate dimLength
   */
  {
    LALU4CreateVector( status->statusPtr, &((*aseq)->dimLength),
                       in->dimLength->length );
    BEGINFAIL( status ) {
      LALFree ((void *) *aseq);
      ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
    } ENDFAIL( status );
    for ( i = 0; i < in->dimLength->length; i++ )
      (*aseq)->arrayDim *= (*aseq)->dimLength->data[i]
        = in->dimLength->data[i];
  }

  /* 
   * Allocate storage 
   */
  {
    size_t tlength;
    tlength = (*aseq)->length * (*aseq)->arrayDim * sizeof( COMPLEX8 );
    (*aseq)->data = ( COMPLEX8 * ) LALMalloc (tlength);
  }

  if (NULL == (*aseq)->data)
  {
    /* Must free storage pointed to by *aseq */
    TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
         status );
    LALFree ((void *) *aseq);
    ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
  }

  /* We be done: Normal exit */

  DETATCHSTATUSPTR( status );
  RETURN (status);
}















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALCDestroyArraySequence ( LALStatus *status, COMPLEX8ArraySequence **aseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALCDestroyArraySequence", ARRAYSEQUENCEFACTORIESC );
  ATTATCHSTATUSPTR( status );
      
  /* 
   * Check aseq: is it non-NULL?
   */

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

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

  ASSERT (*aseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check dimLength in aseq: does it point to non-NULL?
   */

  ASSERT ((*aseq)->dimLength != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  ASSERT ((*aseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
       status );
  LALFree ( (*aseq)->data ); /* free allocated data */
  LALFree ( *aseq );          /* free aseq struct itself */

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

  DETATCHSTATUSPTR( status );
  RETURN (status);
}

















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALDCreateArraySequence ( LALStatus *status, REAL8ArraySequence **aseq, CreateArraySequenceIn *in ) 
{ /* </lalVerbatim> */
  UINT4 i;

  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALDCreateArraySequence", ARRAYSEQUENCEFACTORIESC );     
  ATTATCHSTATUSPTR( status );

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
  ASSERT (in->dimLength, status,
          SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR); 
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check dimension lengths: report error any are 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */
#ifndef NDEBUG
  for ( i = 0; i < in->dimLength->length; i++ )
  {
    ASSERT (in->dimLength->data[i] > 0, status,
            SEQFACTORIESH_EALENGTH, SEQFACTORIESH_MSGEALENGTH); 
  }
#endif

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

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*aseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Allocate pointer
   */

  *aseq = ( REAL8ArraySequence * ) LALMalloc( sizeof( REAL8ArraySequence ) );
  if ( NULL == *aseq )
  {
    ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
  }

  (*aseq)->length = in->length;
  (*aseq)->arrayDim = 1;
  (*aseq)->dimLength = NULL;    /* NULL dimLength until allocated */
  (*aseq)->data   = NULL;       /* NULL data until allocated */

  /* 
   * Allocate dimLength
   */
  {
    LALU4CreateVector( status->statusPtr, &((*aseq)->dimLength),
                       in->dimLength->length );
    BEGINFAIL( status ) {
      LALFree ((void *) *aseq);
      ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
    } ENDFAIL( status );
    for ( i = 0; i < in->dimLength->length; i++ )
      (*aseq)->arrayDim *= (*aseq)->dimLength->data[i]
        = in->dimLength->data[i];
  }

  /* 
   * Allocate storage 
   */
  {
    size_t tlength;
    tlength = (*aseq)->length * (*aseq)->arrayDim * sizeof( REAL8 );
    (*aseq)->data = ( REAL8 * ) LALMalloc (tlength);
  }

  if (NULL == (*aseq)->data)
  {
    /* Must free storage pointed to by *aseq */
    TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
         status );
    LALFree ((void *) *aseq);
    ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
  }

  /* We be done: Normal exit */

  DETATCHSTATUSPTR( status );
  RETURN (status);
}















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALDDestroyArraySequence ( LALStatus *status, REAL8ArraySequence **aseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALDDestroyArraySequence", ARRAYSEQUENCEFACTORIESC );
  ATTATCHSTATUSPTR( status );
      
  /* 
   * Check aseq: is it non-NULL?
   */

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

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

  ASSERT (*aseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check dimLength in aseq: does it point to non-NULL?
   */

  ASSERT ((*aseq)->dimLength != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  ASSERT ((*aseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
       status );
  LALFree ( (*aseq)->data ); /* free allocated data */
  LALFree ( *aseq );          /* free aseq struct itself */

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

  DETATCHSTATUSPTR( status );
  RETURN (status);
}

















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALSCreateArraySequence ( LALStatus *status, REAL4ArraySequence **aseq, CreateArraySequenceIn *in ) 
{ /* </lalVerbatim> */
  UINT4 i;

  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALSCreateArraySequence", ARRAYSEQUENCEFACTORIESC );     
  ATTATCHSTATUSPTR( status );

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
  ASSERT (in->dimLength, status,
          SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR); 
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check dimension lengths: report error any are 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */
#ifndef NDEBUG
  for ( i = 0; i < in->dimLength->length; i++ )
  {
    ASSERT (in->dimLength->data[i] > 0, status,
            SEQFACTORIESH_EALENGTH, SEQFACTORIESH_MSGEALENGTH); 
  }
#endif

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

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*aseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Allocate pointer
   */

  *aseq = ( REAL4ArraySequence * ) LALMalloc( sizeof( REAL4ArraySequence ) );
  if ( NULL == *aseq )
  {
    ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
  }

  (*aseq)->length = in->length;
  (*aseq)->arrayDim = 1;
  (*aseq)->dimLength = NULL;    /* NULL dimLength until allocated */
  (*aseq)->data   = NULL;       /* NULL data until allocated */

  /* 
   * Allocate dimLength
   */
  {
    LALU4CreateVector( status->statusPtr, &((*aseq)->dimLength),
                       in->dimLength->length );
    BEGINFAIL( status ) {
      LALFree ((void *) *aseq);
      ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
    } ENDFAIL( status );
    for ( i = 0; i < in->dimLength->length; i++ )
      (*aseq)->arrayDim *= (*aseq)->dimLength->data[i]
        = in->dimLength->data[i];
  }

  /* 
   * Allocate storage 
   */
  {
    size_t tlength;
    tlength = (*aseq)->length * (*aseq)->arrayDim * sizeof( REAL4 );
    (*aseq)->data = ( REAL4 * ) LALMalloc (tlength);
  }

  if (NULL == (*aseq)->data)
  {
    /* Must free storage pointed to by *aseq */
    TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
         status );
    LALFree ((void *) *aseq);
    ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
  }

  /* We be done: Normal exit */

  DETATCHSTATUSPTR( status );
  RETURN (status);
}















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALSDestroyArraySequence ( LALStatus *status, REAL4ArraySequence **aseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALSDestroyArraySequence", ARRAYSEQUENCEFACTORIESC );
  ATTATCHSTATUSPTR( status );
      
  /* 
   * Check aseq: is it non-NULL?
   */

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

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

  ASSERT (*aseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check dimLength in aseq: does it point to non-NULL?
   */

  ASSERT ((*aseq)->dimLength != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  ASSERT ((*aseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
       status );
  LALFree ( (*aseq)->data ); /* free allocated data */
  LALFree ( *aseq );          /* free aseq struct itself */

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

  DETATCHSTATUSPTR( status );
  RETURN (status);
}

















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALI2CreateArraySequence ( LALStatus *status, INT2ArraySequence **aseq, CreateArraySequenceIn *in ) 
{ /* </lalVerbatim> */
  UINT4 i;

  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALI2CreateArraySequence", ARRAYSEQUENCEFACTORIESC );    
  ATTATCHSTATUSPTR( status );

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
  ASSERT (in->dimLength, status,
          SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR); 
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check dimension lengths: report error any are 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */
#ifndef NDEBUG
  for ( i = 0; i < in->dimLength->length; i++ )
  {
    ASSERT (in->dimLength->data[i] > 0, status,
            SEQFACTORIESH_EALENGTH, SEQFACTORIESH_MSGEALENGTH); 
  }
#endif

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

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*aseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Allocate pointer
   */

  *aseq = ( INT2ArraySequence * ) LALMalloc( sizeof( INT2ArraySequence ) );
  if ( NULL == *aseq )
  {
    ABORT( status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC );
  }

  (*aseq)->length = in->length;
  (*aseq)->arrayDim = 1;
  (*aseq)->dimLength = NULL;    /* NULL dimLength until allocated */
  (*aseq)->data   = NULL;       /* NULL data until allocated */

  /* 
   * Allocate dimLength
   */
  {
    LALU4CreateVector( status->statusPtr, &((*aseq)->dimLength),
                       in->dimLength->length );
    BEGINFAIL( status ) {
      LALFree ((void *) *aseq);
      ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
    } ENDFAIL( status );
    for ( i = 0; i < in->dimLength->length; i++ )
      (*aseq)->arrayDim *= (*aseq)->dimLength->data[i]
        = in->dimLength->data[i];
  }

  /* 
   * Allocate storage 
   */
  {
    size_t tlength;
    tlength = (*aseq)->length * (*aseq)->arrayDim * sizeof( INT2 );
    (*aseq)->data = ( INT2 * ) LALMalloc (tlength);
  }

  if (NULL == (*aseq)->data)
  {
    /* Must free storage pointed to by *aseq */
    TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
         status );
    LALFree ((void *) *aseq);
    ABORT (status, SEQFACTORIESH_EMALLOC, SEQFACTORIESH_MSGEMALLOC);
  }

  /* We be done: Normal exit */

  DETATCHSTATUSPTR( status );
  RETURN (status);
}















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALI2DestroyArraySequence ( LALStatus *status, INT2ArraySequence **aseq )
{ /* </lalVerbatim> */
  /* 
   * Initialize status
   */

  INITSTATUS( status, "LALI2DestroyArraySequence", ARRAYSEQUENCEFACTORIESC );
  ATTATCHSTATUSPTR( status );
      
  /* 
   * Check aseq: is it non-NULL?
   */

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR); 

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

  ASSERT (*aseq != NULL,status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Check dimLength in aseq: does it point to non-NULL?
   */

  ASSERT ((*aseq)->dimLength != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  ASSERT ((*aseq)->data != NULL, status,
          SEQFACTORIESH_EDPTR, SEQFACTORIESH_MSGEDPTR);

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

  TRY( LALU4DestroyVector( status->statusPtr, &((*aseq)->dimLength) ),
       status );
  LALFree ( (*aseq)->data ); /* free allocated data */
  LALFree ( *aseq );          /* free aseq struct itself */

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

  DETATCHSTATUSPTR( status );
  RETURN (status);
}

















/* <lalVerbatim file="ArraySequenceFactoriesD"> */
void LALI4CreateArraySequence ( LALStatus *status, INT4ArraySequence **aseq, CreateArraySequenceIn *in ) 
{ /* </lalVerbatim> */
  UINT4 i;

  /* 
   * Initialize status
   */
  INITSTATUS( status, "LALI4CreateArraySequence", ARRAYSEQUENCEFACTORIESC );    
  ATTATCHSTATUSPTR( status );

  /* Check input structure: report if NULL */

  ASSERT (in != NULL, status, SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR);
  ASSERT (in->dimLength, status,
          SEQFACTORIESH_EINPTR, SEQFACTORIESH_MSGEINPTR); 
      
  /* Check sequence length: report error if 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */

  ASSERT (in->length > 0, status,
          SEQFACTORIESH_ESLENGTH, SEQFACTORIESH_MSGESLENGTH);

  /* Check dimension lengths: report error any are 0 
   * Use of unsigned for length means we can't check if negative
   * length was passed
   */
#ifndef NDEBUG
  for ( i = 0; i < in->dimLength->length; i++ )
  {
    ASSERT (in->dimLength->data[i] > 0, status,
            SEQFACTORIESH_EALENGTH, SEQFACTORIESH_MSGEALENGTH); 
  }
#endif

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

  ASSERT (aseq != NULL, status, SEQFACTORIESH_EVPTR, SEQFACTORIESH_MSGEVPTR);
  ASSERT (*aseq == NULL, status, SEQFACTORIESH_EUPTR, SEQFACTORIESH_MSGEUPTR);

  /*
   * Allocate pointer
   */

  *aseq = ( INT4ArraySequence * ) LALMalloc( sizeof( INT4ArraySequence ) );
  if (