dnabasic.c

Go to the documentation of this file.

/*====================================================================*
 -  Copyright (C) 2001 Leptonica.  All rights reserved.
 -
 -  Redistribution and use in source and binary forms, with or without
 -  modification, are permitted provided that the following conditions
 -  are met:
 -  1. Redistributions of source code must retain the above copyright
 -     notice, this list of conditions and the following disclaimer.
 -  2. Redistributions in binary form must reproduce the above
 -     copyright notice, this list of conditions and the following
 -     disclaimer in the documentation and/or other materials
 -     provided with the distribution.
 -
 -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
 -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================*/
 
#ifdef HAVE_CONFIG_H
#include <config_auto.h>
#endif  /* HAVE_CONFIG_H */
 
#include <string.h>
#include <math.h>
#include "allheaders.h"
 
    /* Bounds on initial array size */
static const l_uint32  MaxDoubleArraySize = 100000000;   /* for dna */
static const l_uint32  MaxPtrArraySize = 1000000;   /* for dnaa */
static const l_int32  InitialArraySize = 50;      
    /* Static functions */
static l_int32 l_dnaExtendArray(L_DNA *da);
static l_int32 l_dnaaExtendArray(L_DNAA *daa);
 
/*--------------------------------------------------------------------------*
 *                 Dna creation, destruction, copy, clone, etc.             *
 *--------------------------------------------------------------------------*/
L_DNA *
l_dnaCreate(l_int32  n)
{
L_DNA  *da;
 
    PROCNAME("l_dnaCreate");
 
    if (n <= 0 || n > MaxDoubleArraySize)
        n = InitialArraySize;
 
    da = (L_DNA *)LEPT_CALLOC(1, sizeof(L_DNA));
    if ((da->array = (l_float64 *)LEPT_CALLOC(n, sizeof(l_float64))) == NULL) {
        l_dnaDestroy(&da);
        return (L_DNA *)ERROR_PTR("double array not made", procName, NULL);
    }
 
    da->nalloc = n;
    da->n = 0;
    da->refcount = 1;
    da->startx = 0.0;
    da->delx = 1.0;
 
    return da;
}
 
 
L_DNA *
l_dnaCreateFromIArray(l_int32  *iarray,
                      l_int32   size)
{
l_int32  i;
L_DNA   *da;
 
    PROCNAME("l_dnaCreateFromIArray");
 
    if (!iarray)
        return (L_DNA *)ERROR_PTR("iarray not defined", procName, NULL);
    if (size <= 0)
        return (L_DNA *)ERROR_PTR("size must be > 0", procName, NULL);
 
    da = l_dnaCreate(size);
    for (i = 0; i < size; i++)
        l_dnaAddNumber(da, iarray[i]);
 
    return da;
}
 
 
L_DNA *
l_dnaCreateFromDArray(l_float64  *darray,
                      l_int32     size,
                      l_int32     copyflag)
{
l_int32  i;
L_DNA   *da;
 
    PROCNAME("l_dnaCreateFromDArray");
 
    if (!darray)
        return (L_DNA *)ERROR_PTR("darray not defined", procName, NULL);
    if (size <= 0)
        return (L_DNA *)ERROR_PTR("size must be > 0", procName, NULL);
    if (copyflag != L_INSERT && copyflag != L_COPY)
        return (L_DNA *)ERROR_PTR("invalid copyflag", procName, NULL);
 
    da = l_dnaCreate(size);
    if (copyflag == L_INSERT) {
        if (da->array) LEPT_FREE(da->array);
        da->array = darray;
        da->n = size;
    } else {  /* just copy the contents */
        for (i = 0; i < size; i++)
            l_dnaAddNumber(da, darray[i]);
    }
 
    return da;
}
 
 
L_DNA *
l_dnaMakeSequence(l_float64  startval,
                  l_float64  increment,
                  l_int32    size)
{
l_int32    i;
l_float64  val;
L_DNA     *da;
 
    PROCNAME("l_dnaMakeSequence");
 
    if ((da = l_dnaCreate(size)) == NULL)
        return (L_DNA *)ERROR_PTR("da not made", procName, NULL);
 
    for (i = 0; i < size; i++) {
        val = startval + i * increment;
        l_dnaAddNumber(da, val);
    }
 
    return da;
}
 
 
void
l_dnaDestroy(L_DNA  **pda)
{
L_DNA  *da;
 
    PROCNAME("l_dnaDestroy");
 
    if (pda == NULL) {
        L_WARNING("ptr address is NULL\n", procName);
        return;
    }
 
    if ((da = *pda) == NULL)
        return;
 
        /* Decrement the ref count.  If it is 0, destroy the l_dna. */
    l_dnaChangeRefcount(da, -1);
    if (l_dnaGetRefcount(da) <= 0) {
        if (da->array)
            LEPT_FREE(da->array);
        LEPT_FREE(da);
    }
    *pda = NULL;
}
 
 
L_DNA *
l_dnaCopy(L_DNA  *da)
{
l_int32  i;
L_DNA   *dac;
 
    PROCNAME("l_dnaCopy");
 
    if (!da)
        return (L_DNA *)ERROR_PTR("da not defined", procName, NULL);
 
    if ((dac = l_dnaCreate(da->n)) == NULL)
        return (L_DNA *)ERROR_PTR("dac not made", procName, NULL);
    dac->startx = da->startx;
    dac->delx = da->delx;
 
    for (i = 0; i < da->n; i++)
        l_dnaAddNumber(dac, da->array[i]);
 
    return dac;
}
 
 
L_DNA *
l_dnaClone(L_DNA  *da)
{
    PROCNAME("l_dnaClone");
 
    if (!da)
        return (L_DNA *)ERROR_PTR("da not defined", procName, NULL);
 
    l_dnaChangeRefcount(da, 1);
    return da;
}
 
 
l_ok
l_dnaEmpty(L_DNA  *da)
{
    PROCNAME("l_dnaEmpty");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    da->n = 0;
    return 0;
}
 
 
 
/*--------------------------------------------------------------------------*
 *                  Dna: add/remove number and extend array                 *
 *--------------------------------------------------------------------------*/
l_ok
l_dnaAddNumber(L_DNA     *da,
               l_float64  val)
{
l_int32  n;
 
    PROCNAME("l_dnaAddNumber");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    n = l_dnaGetCount(da);
    if (n >= da->nalloc) {
        if (l_dnaExtendArray(da))
            return ERROR_INT("extension failed", procName, 1);
    }
    da->array[n] = val;
    da->n++;
    return 0;
}
 
 
static l_int32
l_dnaExtendArray(L_DNA  *da)
{
size_t  oldsize, newsize;
 
    PROCNAME("l_dnaExtendArray");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    if (da->nalloc > MaxDoubleArraySize)
        return ERROR_INT("da at maximum size; can't extend", procName, 1);
    oldsize = da->nalloc * sizeof(l_float64);
    if (da->nalloc > MaxDoubleArraySize / 2) {
        newsize = MaxDoubleArraySize * sizeof(l_float64);
        da->nalloc = MaxDoubleArraySize;
    } else {
        newsize = 2 * oldsize;
        da->nalloc *= 2;
    }
    if ((da->array = (l_float64 *)reallocNew((void **)&da->array,
                                             oldsize, newsize)) == NULL)
        return ERROR_INT("new ptr array not returned", procName, 1);
 
    return 0;
}
 
 
l_ok
l_dnaInsertNumber(L_DNA      *da,
                  l_int32    index,
                  l_float64  val)
{
l_int32  i, n;
 
    PROCNAME("l_dnaInsertNumber");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    n = l_dnaGetCount(da);
    if (index < 0 || index > n) {
        L_ERROR("index %d not in [0,...,%d]\n", procName, index, n);
        return 1;
    }
 
    if (n >= da->nalloc) {
        if (l_dnaExtendArray(da))
            return ERROR_INT("extension failed", procName, 1);
    }
    for (i = n; i > index; i--)
        da->array[i] = da->array[i - 1];
    da->array[index] = val;
    da->n++;
    return 0;
}
 
 
l_ok
l_dnaRemoveNumber(L_DNA   *da,
                  l_int32  index)
{
l_int32  i, n;
 
    PROCNAME("l_dnaRemoveNumber");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    n = l_dnaGetCount(da);
    if (index < 0 || index >= n) {
        L_ERROR("index %d not in [0,...,%d]\n", procName, index, n - 1);
        return 1;
    }
 
    for (i = index + 1; i < n; i++)
        da->array[i - 1] = da->array[i];
    da->n--;
    return 0;
}
 
 
l_ok
l_dnaReplaceNumber(L_DNA     *da,
                   l_int32    index,
                   l_float64  val)
{
l_int32  n;
 
    PROCNAME("l_dnaReplaceNumber");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    n = l_dnaGetCount(da);
    if (index < 0 || index >= n) {
        L_ERROR("index %d not in [0,...,%d]\n", procName, index, n - 1);
        return 1;
    }
 
    da->array[index] = val;
    return 0;
}
 
 
/*----------------------------------------------------------------------*
 *                             Dna accessors                            *
 *----------------------------------------------------------------------*/
l_int32
l_dnaGetCount(L_DNA  *da)
{
    PROCNAME("l_dnaGetCount");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 0);
    return da->n;
}
 
 
l_ok
l_dnaSetCount(L_DNA   *da,
              l_int32  newcount)
{
    PROCNAME("l_dnaSetCount");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    if (newcount > da->nalloc) {
        if ((da->array = (l_float64 *)reallocNew((void **)&da->array,
                         sizeof(l_float64) * da->nalloc,
                         sizeof(l_float64) * newcount)) == NULL)
            return ERROR_INT("new ptr array not returned", procName, 1);
        da->nalloc = newcount;
    }
    da->n = newcount;
    return 0;
}
 
 
l_ok
l_dnaGetDValue(L_DNA      *da,
               l_int32     index,
               l_float64  *pval)
{
    PROCNAME("l_dnaGetDValue");
 
    if (!pval)
        return ERROR_INT("&val not defined", procName, 1);
    *pval = 0.0;
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    if (index < 0 || index >= da->n)
        return ERROR_INT("index not valid", procName, 1);
 
    *pval = da->array[index];
    return 0;
}
 
 
l_ok
l_dnaGetIValue(L_DNA    *da,
               l_int32   index,
               l_int32  *pival)
{
l_float64  val;
 
    PROCNAME("l_dnaGetIValue");
 
    if (!pival)
        return ERROR_INT("&ival not defined", procName, 1);
    *pival = 0;
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    if (index < 0 || index >= da->n)
        return ERROR_INT("index not valid", procName, 1);
 
    val = da->array[index];
    *pival = (l_int32)(val + L_SIGN(val) * 0.5);
    return 0;
}
 
 
l_ok
l_dnaSetValue(L_DNA     *da,
              l_int32    index,
              l_float64  val)
{
    PROCNAME("l_dnaSetValue");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    if (index < 0 || index >= da->n)
        return ERROR_INT("index not valid", procName, 1);
 
    da->array[index] = val;
    return 0;
}
 
 
l_ok
l_dnaShiftValue(L_DNA     *da,
                l_int32    index,
                l_float64  diff)
{
    PROCNAME("l_dnaShiftValue");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    if (index < 0 || index >= da->n)
        return ERROR_INT("index not valid", procName, 1);
 
    da->array[index] += diff;
    return 0;
}
 
 
l_int32 *
l_dnaGetIArray(L_DNA  *da)
{
l_int32   i, n, ival;
l_int32  *array;
 
    PROCNAME("l_dnaGetIArray");
 
    if (!da)
        return (l_int32 *)ERROR_PTR("da not defined", procName, NULL);
 
    n = l_dnaGetCount(da);
    if ((array = (l_int32 *)LEPT_CALLOC(n, sizeof(l_int32))) == NULL)
        return (l_int32 *)ERROR_PTR("array not made", procName, NULL);
    for (i = 0; i < n; i++) {
        l_dnaGetIValue(da, i, &ival);
        array[i] = ival;
    }
 
    return array;
}
 
 
l_float64 *
l_dnaGetDArray(L_DNA   *da,
               l_int32  copyflag)
{
l_int32     i, n;
l_float64  *array;
 
    PROCNAME("l_dnaGetDArray");
 
    if (!da)
        return (l_float64 *)ERROR_PTR("da not defined", procName, NULL);
 
    if (copyflag == L_NOCOPY) {
        array = da->array;
    } else {  /* copyflag == L_COPY */
        n = l_dnaGetCount(da);
        if ((array = (l_float64 *)LEPT_CALLOC(n, sizeof(l_float64))) == NULL)
            return (l_float64 *)ERROR_PTR("array not made", procName, NULL);
        for (i = 0; i < n; i++)
            array[i] = da->array[i];
    }
 
    return array;
}
 
 
l_int32
l_dnaGetRefcount(L_DNA  *da)
{
    PROCNAME("l_dnaGetRefcount");
 
    if (!da)
        return ERROR_INT("da not defined", procName, UNDEF);
    return da->refcount;
}
 
 
l_ok
l_dnaChangeRefcount(L_DNA   *da,
                    l_int32  delta)
{
    PROCNAME("l_dnaChangeRefcount");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    da->refcount += delta;
    return 0;
}
 
 
l_ok
l_dnaGetParameters(L_DNA     *da,
                   l_float64  *pstartx,
                   l_float64  *pdelx)
{
    PROCNAME("l_dnaGetParameters");
 
    if (pstartx) *pstartx = 0.0;
    if (pdelx) *pdelx = 1.0;
    if (!pstartx && !pdelx)
        return ERROR_INT("neither &startx nor &delx are defined", procName, 1);
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    if (pstartx) *pstartx = da->startx;
    if (pdelx) *pdelx = da->delx;
    return 0;
}
 
 
l_ok
l_dnaSetParameters(L_DNA     *da,
                   l_float64  startx,
                   l_float64  delx)
{
    PROCNAME("l_dnaSetParameters");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    da->startx = startx;
    da->delx = delx;
    return 0;
}
 
 
l_ok
l_dnaCopyParameters(L_DNA  *dad,
                    L_DNA  *das)
{
l_float64  start, binsize;
 
    PROCNAME("l_dnaCopyParameters");
 
    if (!das || !dad)
        return ERROR_INT("das and dad not both defined", procName, 1);
 
    l_dnaGetParameters(das, &start, &binsize);
    l_dnaSetParameters(dad, start, binsize);
    return 0;
}
 
 
/*----------------------------------------------------------------------*
 *                        Serialize Dna for I/O                         *
 *----------------------------------------------------------------------*/
L_DNA *
l_dnaRead(const char  *filename)
{
FILE   *fp;
L_DNA  *da;
 
    PROCNAME("l_dnaRead");
 
    if (!filename)
        return (L_DNA *)ERROR_PTR("filename not defined", procName, NULL);
 
    if ((fp = fopenReadStream(filename)) == NULL)
        return (L_DNA *)ERROR_PTR("stream not opened", procName, NULL);
    da = l_dnaReadStream(fp);
    fclose(fp);
    if (!da)
        return (L_DNA *)ERROR_PTR("da not read", procName, NULL);
    return da;
}
 
 
L_DNA *
l_dnaReadStream(FILE  *fp)
{
l_int32    i, n, index, ret, version;
l_float64  val, startx, delx;
L_DNA     *da;
 
    PROCNAME("l_dnaReadStream");
 
    if (!fp)
        return (L_DNA *)ERROR_PTR("stream not defined", procName, NULL);
 
    ret = fscanf(fp, "\nL_Dna Version %d\n", &version);
    if (ret != 1)
        return (L_DNA *)ERROR_PTR("not a l_dna file", procName, NULL);
    if (version != DNA_VERSION_NUMBER)
        return (L_DNA *)ERROR_PTR("invalid l_dna version", procName, NULL);
    if (fscanf(fp, "Number of numbers = %d\n", &n) != 1)
        return (L_DNA *)ERROR_PTR("invalid number of numbers", procName, NULL);
    if (n < 0)
        return (L_DNA *)ERROR_PTR("num doubles < 0", procName, NULL);
    if (n > MaxDoubleArraySize)
        return (L_DNA *)ERROR_PTR("too many doubles", procName, NULL);
    if (n == 0) L_INFO("the dna is empty\n", procName);
 
    if ((da = l_dnaCreate(n)) == NULL)
        return (L_DNA *)ERROR_PTR("da not made", procName, NULL);
    for (i = 0; i < n; i++) {
        if (fscanf(fp, "  [%d] = %lf\n", &index, &val) != 2) {
            l_dnaDestroy(&da);
            return (L_DNA *)ERROR_PTR("bad input data", procName, NULL);
        }
        l_dnaAddNumber(da, val);
    }
 
        /* Optional data */
    if (fscanf(fp, "startx = %lf, delx = %lf\n", &startx, &delx) == 2)
        l_dnaSetParameters(da, startx, delx);
    return da;
}
 
 
L_DNA *
l_dnaReadMem(const l_uint8  *data,
             size_t          size)
{
FILE   *fp;
L_DNA  *da;
 
    PROCNAME("l_dnaReadMem");
 
    if (!data)
        return (L_DNA *)ERROR_PTR("data not defined", procName, NULL);
    if ((fp = fopenReadFromMemory(data, size)) == NULL)
        return (L_DNA *)ERROR_PTR("stream not opened", procName, NULL);
 
    da = l_dnaReadStream(fp);
    fclose(fp);
    if (!da) L_ERROR("dna not read\n", procName);
    return da;
}
 
 
l_ok
l_dnaWrite(const char  *filename,
           L_DNA       *da)
{
l_int32  ret;
FILE    *fp;
 
    PROCNAME("l_dnaWrite");
 
    if (!filename)
        return ERROR_INT("filename not defined", procName, 1);
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    if ((fp = fopenWriteStream(filename, "w")) == NULL)
        return ERROR_INT("stream not opened", procName, 1);
    ret = l_dnaWriteStream(fp, da);
    fclose(fp);
    if (ret)
        return ERROR_INT("da not written to stream", procName, 1);
    return 0;
}
 
 
l_ok
l_dnaWriteStream(FILE   *fp,
                 L_DNA  *da)
{
l_int32    i, n;
l_float64  startx, delx;
 
    PROCNAME("l_dnaWriteStream");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    if (!fp)
        return l_dnaWriteStderr(da);
 
    n = l_dnaGetCount(da);
    fprintf(fp, "\nL_Dna Version %d\n", DNA_VERSION_NUMBER);
    fprintf(fp, "Number of numbers = %d\n", n);
    for (i = 0; i < n; i++)
        fprintf(fp, "  [%d] = %f\n", i, da->array[i]);
    fprintf(fp, "\n");
 
        /* Optional data */
    l_dnaGetParameters(da, &startx, &delx);
    if (startx != 0.0 || delx != 1.0)
        fprintf(fp, "startx = %f, delx = %f\n", startx, delx);
 
    return 0;
}
 
 
l_ok
l_dnaWriteStderr(L_DNA  *da)
{
l_int32    i, n;
l_float64  startx, delx;
 
    PROCNAME("l_dnaWriteStderr");
 
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    n = l_dnaGetCount(da);
    lept_stderr("\nL_Dna Version %d\n", DNA_VERSION_NUMBER);
    lept_stderr("Number of numbers = %d\n", n);
    for (i = 0; i < n; i++)
        lept_stderr("  [%d] = %f\n", i, da->array[i]);
    lept_stderr("\n");
 
        /* Optional data */
    l_dnaGetParameters(da, &startx, &delx);
    if (startx != 0.0 || delx != 1.0)
        lept_stderr("startx = %f, delx = %f\n", startx, delx);
 
    return 0;
}
 
 
l_ok
l_dnaWriteMem(l_uint8  **pdata,
              size_t    *psize,
              L_DNA     *da)
{
l_int32  ret;
FILE    *fp;
 
    PROCNAME("l_dnaWriteMem");
 
    if (pdata) *pdata = NULL;
    if (psize) *psize = 0;
    if (!pdata)
        return ERROR_INT("&data not defined", procName, 1);
    if (!psize)
        return ERROR_INT("&size not defined", procName, 1);
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
#if HAVE_FMEMOPEN
    if ((fp = open_memstream((char **)pdata, psize)) == NULL)
        return ERROR_INT("stream not opened", procName, 1);
    ret = l_dnaWriteStream(fp, da);
    fputc('\0', fp);
    fclose(fp);
    *psize = *psize - 1;
#else
    L_INFO("work-around: writing to a temp file\n", procName);
  #ifdef _WIN32
    if ((fp = fopenWriteWinTempfile()) == NULL)
        return ERROR_INT("tmpfile stream not opened", procName, 1);
  #else
    if ((fp = tmpfile()) == NULL)
        return ERROR_INT("tmpfile stream not opened", procName, 1);
  #endif  /* _WIN32 */
    ret = l_dnaWriteStream(fp, da);
    rewind(fp);
    *pdata = l_binaryReadStream(fp, psize);
    fclose(fp);
#endif  /* HAVE_FMEMOPEN */
    return ret;
}
 
 
/*--------------------------------------------------------------------------*
 *                       Dnaa creation, destruction                         *
 *--------------------------------------------------------------------------*/
L_DNAA *
l_dnaaCreate(l_int32  n)
{
L_DNAA  *daa;
 
    PROCNAME("l_dnaaCreate");
 
    if (n <= 0 || n > MaxPtrArraySize)
        n = InitialArraySize;
 
    daa = (L_DNAA *)LEPT_CALLOC(1, sizeof(L_DNAA));
    if ((daa->dna = (L_DNA **)LEPT_CALLOC(n, sizeof(L_DNA *))) == NULL) {
        l_dnaaDestroy(&daa);
        return (L_DNAA *)ERROR_PTR("l_dna ptr array not made", procName, NULL);
    }
    daa->nalloc = n;
    daa->n = 0;
    return daa;
}
 
 
L_DNAA *
l_dnaaCreateFull(l_int32  nptr,
                 l_int32  n)
{
l_int32  i;
L_DNAA  *daa;
L_DNA   *da;
 
    daa = l_dnaaCreate(nptr);
    for (i = 0; i < nptr; i++) {
        da = l_dnaCreate(n);
        l_dnaaAddDna(daa, da, L_INSERT);
    }
 
    return daa;
}
 
 
l_ok
l_dnaaTruncate(L_DNAA  *daa)
{
l_int32  i, n, nn;
L_DNA   *da;
 
    PROCNAME("l_dnaaTruncate");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
 
    n = l_dnaaGetCount(daa);
    for (i = n - 1; i >= 0; i--) {
        da = l_dnaaGetDna(daa, i, L_CLONE);
        if (!da)
            continue;
        nn = l_dnaGetCount(da);
        l_dnaDestroy(&da);  /* the clone */
        if (nn == 0)
            l_dnaDestroy(&daa->dna[i]);
        else
            break;
    }
    daa->n = i + 1;
    return 0;
}
 
 
void
l_dnaaDestroy(L_DNAA  **pdaa)
{
l_int32  i;
L_DNAA  *daa;
 
    PROCNAME("l_dnaaDestroy");
 
    if (pdaa == NULL) {
        L_WARNING("ptr address is NULL!\n", procName);
        return;
    }
 
    if ((daa = *pdaa) == NULL)
        return;
 
    for (i = 0; i < daa->n; i++)
        l_dnaDestroy(&daa->dna[i]);
    LEPT_FREE(daa->dna);
    LEPT_FREE(daa);
    *pdaa = NULL;
}
 
 
/*--------------------------------------------------------------------------*
 *                             Add Dna to Dnaa                              *
 *--------------------------------------------------------------------------*/
l_ok
l_dnaaAddDna(L_DNAA  *daa,
             L_DNA   *da,
             l_int32  copyflag)
{
l_int32  n;
L_DNA   *dac;
 
    PROCNAME("l_dnaaAddDna");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
 
    if (copyflag == L_INSERT) {
        dac = da;
    } else if (copyflag == L_COPY) {
        if ((dac = l_dnaCopy(da)) == NULL)
            return ERROR_INT("dac not made", procName, 1);
    } else if (copyflag == L_CLONE) {
        dac = l_dnaClone(da);
    } else {
        return ERROR_INT("invalid copyflag", procName, 1);
    }
 
    n = l_dnaaGetCount(daa);
    if (n >= daa->nalloc) {
        if (l_dnaaExtendArray(daa)) {
            if (copyflag != L_INSERT)
                l_dnaDestroy(&dac);
            return ERROR_INT("extension failed", procName, 1);
        }
    }
    daa->dna[n] = dac;
    daa->n++;
    return 0;
}
 
 
static l_int32
l_dnaaExtendArray(L_DNAA  *daa)
{
size_t  oldsize, newsize;
 
    PROCNAME("l_dnaaExtendArray");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
    if (daa->nalloc > MaxPtrArraySize)  /* belt & suspenders */
        return ERROR_INT("daa has too many ptrs", procName, 1);
    oldsize = daa->nalloc * sizeof(L_DNA *);
    newsize = 2 * oldsize;
    if (newsize > 8 * MaxPtrArraySize)
        return ERROR_INT("newsize > 8 MB; too large", procName, 1);
 
    if ((daa->dna = (L_DNA **)reallocNew((void **)&daa->dna,
                                         oldsize, newsize)) == NULL)
        return ERROR_INT("new ptr array not returned", procName, 1);
 
    daa->nalloc *= 2;
    return 0;
}
 
 
/*----------------------------------------------------------------------*
 *                           DNumaa accessors                           *
 *----------------------------------------------------------------------*/
l_int32
l_dnaaGetCount(L_DNAA  *daa)
{
    PROCNAME("l_dnaaGetCount");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 0);
    return daa->n;
}
 
 
l_int32
l_dnaaGetDnaCount(L_DNAA   *daa,
                    l_int32  index)
{
    PROCNAME("l_dnaaGetDnaCount");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 0);
    if (index < 0 || index >= daa->n)
        return ERROR_INT("invalid index into daa", procName, 0);
    return l_dnaGetCount(daa->dna[index]);
}
 
 
l_int32
l_dnaaGetNumberCount(L_DNAA  *daa)
{
L_DNA   *da;
l_int32  n, sum, i;
 
    PROCNAME("l_dnaaGetNumberCount");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 0);
 
    n = l_dnaaGetCount(daa);
    for (sum = 0, i = 0; i < n; i++) {
        da = l_dnaaGetDna(daa, i, L_CLONE);
        sum += l_dnaGetCount(da);
        l_dnaDestroy(&da);
    }
 
    return sum;
}
 
 
L_DNA *
l_dnaaGetDna(L_DNAA  *daa,
             l_int32  index,
             l_int32  accessflag)
{
    PROCNAME("l_dnaaGetDna");
 
    if (!daa)
        return (L_DNA *)ERROR_PTR("daa not defined", procName, NULL);
    if (index < 0 || index >= daa->n)
        return (L_DNA *)ERROR_PTR("index not valid", procName, NULL);
 
    if (accessflag == L_COPY)
        return l_dnaCopy(daa->dna[index]);
    else if (accessflag == L_CLONE)
        return l_dnaClone(daa->dna[index]);
    else
        return (L_DNA *)ERROR_PTR("invalid accessflag", procName, NULL);
}
 
 
l_ok
l_dnaaReplaceDna(L_DNAA  *daa,
                 l_int32  index,
                 L_DNA   *da)
{
l_int32  n;
 
    PROCNAME("l_dnaaReplaceDna");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
    if (!da)
        return ERROR_INT("da not defined", procName, 1);
    n = l_dnaaGetCount(daa);
    if (index < 0 || index >= n)
        return ERROR_INT("index not valid", procName, 1);
 
    l_dnaDestroy(&daa->dna[index]);
    daa->dna[index] = da;
    return 0;
}
 
 
l_ok
l_dnaaGetValue(L_DNAA     *daa,
               l_int32     i,
               l_int32     j,
               l_float64  *pval)
{
l_int32  n;
L_DNA   *da;
 
    PROCNAME("l_dnaaGetValue");
 
    if (!pval)
        return ERROR_INT("&val not defined", procName, 1);
    *pval = 0.0;
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
    n = l_dnaaGetCount(daa);
    if (i < 0 || i >= n)
        return ERROR_INT("invalid index into daa", procName, 1);
    da = daa->dna[i];
    if (j < 0 || j >= da->n)
        return ERROR_INT("invalid index into da", procName, 1);
    *pval = da->array[j];
    return 0;
}
 
 
l_ok
l_dnaaAddNumber(L_DNAA    *daa,
                l_int32    index,
                l_float64  val)
{
l_int32  n;
L_DNA   *da;
 
    PROCNAME("l_dnaaAddNumber");
 
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
    n = l_dnaaGetCount(daa);
    if (index < 0 || index >= n)
        return ERROR_INT("invalid index in daa", procName, 1);
 
    da = l_dnaaGetDna(daa, index, L_CLONE);
    l_dnaAddNumber(da, val);
    l_dnaDestroy(&da);
    return 0;
}
 
 
/*----------------------------------------------------------------------*
 *                        Serialize Dna for I/O                         *
 *----------------------------------------------------------------------*/
L_DNAA *
l_dnaaRead(const char  *filename)
{
FILE    *fp;
L_DNAA  *daa;
 
    PROCNAME("l_dnaaRead");
 
    if (!filename)
        return (L_DNAA *)ERROR_PTR("filename not defined", procName, NULL);
 
    if ((fp = fopenReadStream(filename)) == NULL)
        return (L_DNAA *)ERROR_PTR("stream not opened", procName, NULL);
    daa = l_dnaaReadStream(fp);
    fclose(fp);
    if (!daa)
        return (L_DNAA *)ERROR_PTR("daa not read", procName, NULL);
    return daa;
}
 
 
L_DNAA *
l_dnaaReadStream(FILE  *fp)
{
l_int32    i, n, index, ret, version;
L_DNA     *da;
L_DNAA    *daa;
 
    PROCNAME("l_dnaaReadStream");
 
    if (!fp)
        return (L_DNAA *)ERROR_PTR("stream not defined", procName, NULL);
 
    ret = fscanf(fp, "\nL_Dnaa Version %d\n", &version);
    if (ret != 1)
        return (L_DNAA *)ERROR_PTR("not a l_dna file", procName, NULL);
    if (version != DNA_VERSION_NUMBER)
        return (L_DNAA *)ERROR_PTR("invalid l_dnaa version", procName, NULL);
    if (fscanf(fp, "Number of L_Dna = %d\n\n", &n) != 1)
        return (L_DNAA *)ERROR_PTR("invalid number of l_dna", procName, NULL);
    if (n < 0)
        return (L_DNAA *)ERROR_PTR("num l_dna <= 0", procName, NULL);
    if (n > MaxPtrArraySize)
        return (L_DNAA *)ERROR_PTR("too many l_dna", procName, NULL);
    if (n == 0) L_INFO("the dnaa is empty\n", procName);
 
    if ((daa = l_dnaaCreate(n)) == NULL)
        return (L_DNAA *)ERROR_PTR("daa not made", procName, NULL);
    for (i = 0; i < n; i++) {
        if (fscanf(fp, "L_Dna[%d]:", &index) != 1) {
            l_dnaaDestroy(&daa);
            return (L_DNAA *)ERROR_PTR("invalid l_dna header", procName, NULL);
        }
        if ((da = l_dnaReadStream(fp)) == NULL) {
            l_dnaaDestroy(&daa);
            return (L_DNAA *)ERROR_PTR("da not made", procName, NULL);
        }
        l_dnaaAddDna(daa, da, L_INSERT);
    }
 
    return daa;
}
 
 
L_DNAA *
l_dnaaReadMem(const l_uint8  *data,
              size_t          size)
{
FILE    *fp;
L_DNAA  *daa;
 
    PROCNAME("l_dnaaReadMem");
 
    if (!data)
        return (L_DNAA *)ERROR_PTR("data not defined", procName, NULL);
    if ((fp = fopenReadFromMemory(data, size)) == NULL)
        return (L_DNAA *)ERROR_PTR("stream not opened", procName, NULL);
 
    daa = l_dnaaReadStream(fp);
    fclose(fp);
    if (!daa) L_ERROR("daa not read\n", procName);
    return daa;
}
 
 
l_ok
l_dnaaWrite(const char  *filename,
            L_DNAA      *daa)
{
l_int32  ret;
FILE    *fp;
 
    PROCNAME("l_dnaaWrite");
 
    if (!filename)
        return ERROR_INT("filename not defined", procName, 1);
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
 
    if ((fp = fopenWriteStream(filename, "w")) == NULL)
        return ERROR_INT("stream not opened", procName, 1);
    ret = l_dnaaWriteStream(fp, daa);
    fclose(fp);
    if (ret)
        return ERROR_INT("daa not written to stream", procName, 1);
    return 0;
}
 
 
l_ok
l_dnaaWriteStream(FILE    *fp,
                  L_DNAA  *daa)
{
l_int32  i, n;
L_DNA   *da;
 
    PROCNAME("l_dnaaWriteStream");
 
    if (!fp)
        return ERROR_INT("stream not defined", procName, 1);
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
 
    n = l_dnaaGetCount(daa);
    fprintf(fp, "\nL_Dnaa Version %d\n", DNA_VERSION_NUMBER);
    fprintf(fp, "Number of L_Dna = %d\n\n", n);
    for (i = 0; i < n; i++) {
        if ((da = l_dnaaGetDna(daa, i, L_CLONE)) == NULL)
            return ERROR_INT("da not found", procName, 1);
        fprintf(fp, "L_Dna[%d]:", i);
        l_dnaWriteStream(fp, da);
        l_dnaDestroy(&da);
    }
 
    return 0;
}
 
 
l_ok
l_dnaaWriteMem(l_uint8  **pdata,
               size_t    *psize,
               L_DNAA    *daa)
{
l_int32  ret;
FILE    *fp;
 
    PROCNAME("l_dnaaWriteMem");
 
    if (pdata) *pdata = NULL;
    if (psize) *psize = 0;
    if (!pdata)
        return ERROR_INT("&data not defined", procName, 1);
    if (!psize)
        return ERROR_INT("&size not defined", procName, 1);
    if (!daa)
        return ERROR_INT("daa not defined", procName, 1);
 
#if HAVE_FMEMOPEN
    if ((fp = open_memstream((char **)pdata, psize)) == NULL)
        return ERROR_INT("stream not opened", procName, 1);
    ret = l_dnaaWriteStream(fp, daa);
    fputc('\0', fp);
    fclose(fp);
    *psize = *psize - 1;
#else
    L_INFO("work-around: writing to a temp file\n", procName);
  #ifdef _WIN32
    if ((fp = fopenWriteWinTempfile()) == NULL)
        return ERROR_INT("tmpfile stream not opened", procName, 1);
  #else
    if ((fp = tmpfile()) == NULL)
        return ERROR_INT("tmpfile stream not opened", procName, 1);
  #endif  /* _WIN32 */
    ret = l_dnaaWriteStream(fp, daa);
    rewind(fp);
    *pdata = l_binaryReadStream(fp, psize);
    fclose(fp);
#endif  /* HAVE_FMEMOPEN */
    return ret;
}