apriori 0.2.1

data/ext/util/src/listops.c

@@ -0,0 +1,76 @@
+/*----------------------------------------------------------------------
+  File    : listops.c
+  Contents: some special list operations
+  Author  : Christian Borgelt
+  History : 2000.11.02 file created from file lists.h
+----------------------------------------------------------------------*/
+#include <stdio.h>
+#include "listops.h"
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+
+void* l_sort (void *list, LCMPFN cmpfn, void *data)
+{                               /* --- sort a list with mergesort */
+  LE *src, *dst;                /* list of source/destination lists */
+  LE **end;                     /* end of list of destination lists */
+  LE *in1, *in2;                /* input lists for merging */
+  LE **out;                     /* output list for merging */
+
+  if (!list) return list;       /* check for an empty list */
+  for (src = list; src->succ; ) {
+    dst = src; src = src->succ; /* traverse the list and split it */
+    dst->succ = NULL;           /* into a list (abused pred ptr.) of */ 
+  }                             /* single element lists (succ ptr.) */
+  while (src->pred) {           /* while more than one source list */
+    end = &dst;                 /* start list of destination lists */
+    do {                        /* merge pairs of source lists */
+      out = end;                /* start output list (merged input) */
+      in1 = src;                /* remove two (one) source list(s) */
+      in2 = src->pred;          /* and use them as input for merging */
+      if (!in2) {               /* if there is only one source list */
+        *end = in1; end = &in1->pred;
+        break;                  /* append it to the list of */
+      }                         /* output list and abort the loop */
+      src = in2->pred;          /* remove lists from list of sources */
+      while (1) {               /* source lists merge loop */
+        if (cmpfn(in1, in2, data) < 0) {
+                                /* if first list's element is smaller */
+          *out = in1;           /* move element to output list, */
+          out  = &(in1->succ);  /* advance output pointer and */ 
+          in1  = in1->succ;     /* remove element from input list */
+          if (!in1) break; }    /* if the list gets empty, abort loop */
+        else {                  /* if second list's element is smaller */
+          *out = in2;           /* move element to output list, */
+          out  = &(in2->succ);  /* advance output pointer and */
+          in2  = in2->succ;     /* remove element from input list */
+          if (!in2) break;      /* if the list gets empty, abort loop */
+        }                       /* (merge input lists into one) */
+      }
+      if (in1) *out = in1;      /* append remaining elements */
+      else     *out = in2;      /* to the output list */
+      end = &(*end)->pred;      /* advance destination list pointer */
+    } while (src);              /* while there is another source list */
+    *end = NULL;                /* terminate destination list */
+    src  = dst;                 /* transfer destination list */
+  }                             /* to source list and start over */
+  for (src->pred = NULL; src->succ; src = src->succ)
+    src->succ->pred = src;      /* set predecessor pointers */
+  return dst;                   /* return a pointer to the first */
+}  /* l_sort() */               /* element of the sorted list */
+
+/*--------------------------------------------------------------------*/
+
+void* l_reverse (void *list)
+{                               /* --- reverse a list */
+  LE *le = NULL;                /* to traverse the list elements */
+
+  while (list) {                /* while the list is not empty */
+    le       = list;            /* get the next list element */
+    list     = le->succ;        /* exchange the successor */
+    le->succ = le->pred;        /* and the predecessor */
+    le->pred = list;            /* of the list element */
+  }
+  return le;                    /* return a pointer to */
+}  /* l_reverse() */            /* the new first element */

data/ext/util/src/listops.h

@@ -0,0 +1,26 @@
+/*----------------------------------------------------------------------
+  File    : listops.h
+  Contents: some special list operations
+  Author  : Christian Borgelt
+  History : 2000.11.02 file created from file lists.h
+----------------------------------------------------------------------*/
+#ifndef __LISTOPS__
+#define __LISTOPS__
+
+/*----------------------------------------------------------------------
+  Type Definitions
+----------------------------------------------------------------------*/
+typedef struct _le {            /* --- a list element --- */
+  struct _le *succ;             /* pointer to successor */
+  struct _le *pred;             /* pointer to predecessor */
+} LE;                           /* (list element) */
+
+typedef int LCMPFN (const void *p1, const void *p2, void *data);
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+extern void* l_sort    (void *list, LCMPFN cmpfn, void *data);
+extern void* l_reverse (void *list);
+
+#endif

data/ext/util/src/makefile

@@ -0,0 +1,103 @@
+#-----------------------------------------------------------------------
+# File    : makefile    (directory: util)
+# Contents: build utility modules
+# Author  : Christian Borgelt
+# History : 2000.11.04 file created from makefile in table directory
+#           2003.06.05 module params added
+#           2003.08.12 module nstats added
+#           2004.12.10 module memsys added
+#-----------------------------------------------------------------------
+CC      = gcc
+CFBASE  = -ansi -Wall -pedantic $(ADDFLAGS)
+CFLAGS  = $(CFBASE) -DNDEBUG -O3
+# CFLAGS  = $(CFBASE) -g
+# CFLAGS  = $(CFBASE) -g -DSTORAGE $(ADDINC)
+# ADDINC  = -I../../misc/src
+INC      = -I. -I$(TABLEDIR)
+
+#-----------------------------------------------------------------------
+# Build Modules
+#-----------------------------------------------------------------------
+all:        memsys.o vecops.o listops.o symtab.o nimap.o \
+            tabscan.o scform.o scan.o parse.o params.o
+
+#-----------------------------------------------------------------------
+# Memory Management System for Equally Sized Objects
+#-----------------------------------------------------------------------
+memsys.o:   memsys.h
+memsys.o:   memsys.c makefile
+	$(CC) $(CFLAGS) -c memsys.c -o $@
+
+#-----------------------------------------------------------------------
+# Vector Operations
+#-----------------------------------------------------------------------
+vecops.o:   vecops.h
+vecops.o:   vecops.c makefile
+	$(CC) $(CFLAGS) -c vecops.c -o $@
+
+#-----------------------------------------------------------------------
+# List Operations
+#-----------------------------------------------------------------------
+listops.o:  listops.h
+listops.o:  listops.c makefile
+	$(CC) $(CFLAGS) -c listops.c -o $@
+
+#-----------------------------------------------------------------------
+# Symbol Table Management
+#-----------------------------------------------------------------------
+symtab.o:   symtab.h
+symtab.o:   symtab.c makefile
+	$(CC) $(CFLAGS) -c symtab.c -o $@
+
+nimap.o:    symtab.h vecops.h
+nimap.o:    symtab.c makefile
+	$(CC) $(CFLAGS) -DNIMAPFN -c symtab.c -o $@
+
+#-----------------------------------------------------------------------
+# Numerical Statistics Management
+#-----------------------------------------------------------------------
+nstats.o:   nstats.h
+nstats.o:   nstats.c makefile
+	$(CC) $(CFLAGS) -c nstats.c -o $@
+
+nst_pars.o: nstats.h
+nst_pars.o: nstats.c makefile
+	$(CC) $(CFLAGS) -DNST_PARSE -c nstats.c -o $@
+
+#-----------------------------------------------------------------------
+# Table Scanner Management
+#-----------------------------------------------------------------------
+tabscan.o:  tabscan.h
+tabscan.o:  tabscan.c makefile
+	$(CC) $(CFLAGS) -c tabscan.c -o $@
+
+#-----------------------------------------------------------------------
+# Scanner
+#-----------------------------------------------------------------------
+scform.o:   scan.h
+scform.o:   scan.c makefile
+	$(CC) $(CFLAGS) -c scan.c -o $@
+
+scan.o:     scan.h
+scan.o:     scan.c makefile
+	$(CC) $(CFLAGS) -DSC_SCAN -c scan.c -o $@
+
+#-----------------------------------------------------------------------
+# Parser Utilities
+#-----------------------------------------------------------------------
+parse.o:    parse.h
+parse.o:    parse.c makefile
+	$(CC) $(CFLAGS) -c parse.c -o $@
+
+#-----------------------------------------------------------------------
+# Command Line Parameter Retrieval
+#-----------------------------------------------------------------------
+params.o:   params.h
+params.o:   params.c makefile
+	$(CC) $(CFLAGS) -c params.c -o $@
+
+#-----------------------------------------------------------------------
+# Clean up
+#-----------------------------------------------------------------------
+clean:
+	rm -f *.o *~ *.flc core

data/ext/util/src/memsys.c

@@ -0,0 +1,84 @@
+/*----------------------------------------------------------------------
+  File    : memsys.c
+  Contents: memory management system for equally sized (small) objects
+  Author  : Christian Borgelt
+  History : 2004.12.10 file created from fpgrowth.c
+            2008.01.23 counting of used objects added
+----------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "memsys.h"
+#ifdef STORAGE
+#include "storage.h"
+#endif
+
+/*----------------------------------------------------------------------
+  Main Functions
+----------------------------------------------------------------------*/
+
+MEMSYS* ms_create (int size, int cnt)
+{                               /* --- create a memory system */
+  MEMSYS *ms;                   /* created memory system */
+
+  assert((cnt > 0)              /* check the function arguments */
+      && (size > 0) && (size % sizeof(void*) == 0));
+  ms = malloc(sizeof(MEMSYS));  /* create a memory management system */
+  if (!ms) return NULL;         /* with no free objects and */
+  ms->cnt   = cnt;              /* initialize the variables */
+  ms->size  = size /sizeof(void*);
+  ms->blksz = sizeof(MSBLOCK) +ms->cnt *size;
+  ms->free  = ms->blocks = NULL;
+  return ms;                    /* return the created memory system */
+}  /* ms_create() */
+
+/*--------------------------------------------------------------------*/
+
+void ms_delete (MEMSYS *ms)
+{                               /* --- delete a memory system */
+  MSBLOCK *block;               /* to traverse the memory blocks */
+
+  assert(ms);                   /* check the function argument */
+  while (ms->blocks) {          /* while there is another block */
+    block = ms->blocks;         /* note the memory block and */
+    ms->blocks = block->succ;   /* remove it from the block list */
+    free(block);                /* delete the memory block */
+  }
+  free(ms);                     /* delete the base structure */
+}  /* ms_delete() */
+
+/*--------------------------------------------------------------------*/
+
+void* ms_alloc (MEMSYS *ms)
+{                               /* --- allocate an object */
+  int     i;                    /* loop variable */
+  void    **obj, **tmp;         /* allocated object, buffer */
+  MSBLOCK *block;               /* new block */
+
+  assert(ms);                   /* check the function argument */
+  obj = ms->free;               /* get the head of the free list */
+  if (!obj) {                   /* if there is no free node, */
+    block = (MSBLOCK*)malloc(ms->blksz);
+    if (!block) return NULL;    /* allocate a new memory block */
+    block->succ = ms->blocks;   /* and add it at the head */
+    ms->blocks  = block;        /* of the block list */
+    ms->free    = obj = (void*)(block +1);
+    for (i = ms->cnt; --i > 0; ) {
+      tmp = obj; *tmp = obj += ms->size; }
+    *obj = NULL;                /* traverse the object vector */
+    obj  = ms->free;            /* and link the objects together, */
+  }                             /* then get the next free object */
+  ms->used++;                   /* count the allocated object */
+  ms->free = *obj;              /* remove object from the free list */
+  return (void*)obj;            /* and return the retrieved object */
+}  /* ms_alloc() */
+
+/*--------------------------------------------------------------------*/
+
+void ms_free (MEMSYS *ms, void *obj)
+{                              /* --- deallocate an f.p. tree node */
+  assert(ms && obj);           /* check the function arguments */
+  *(void**)obj = ms->free;     /* insert the freed object */
+  ms->free     = obj;          /* at the head of the free list */
+  ms->used--;                  /* count the deallocated object */
+}  /* ms_free() */

data/ext/util/src/memsys.h

@@ -0,0 +1,42 @@
+/*----------------------------------------------------------------------
+  File    : memsys.h
+  Contents: memory management system for equally sized (small) objects
+  Author  : Christian Borgelt
+  History : 2004.12.10 file created from fpgrowth.c
+            2008.01.23 counting of used blocks added
+----------------------------------------------------------------------*/
+#ifndef __MEMSYS__
+#define __MEMSYS__
+
+/*----------------------------------------------------------------------
+  Type Definitions
+----------------------------------------------------------------------*/
+typedef struct _msblock {       /* --- memory system block --- */
+  struct _msblock *succ;        /* successor block in list */
+  void            *rsvd;        /* reserved (for alignment) */
+} MSBLOCK;                      /* (memory management system block) */
+
+typedef struct {                /* --- memory management system --- */
+  int  size;                    /* size of each object */
+  int  cnt;                     /* number of objects per block */
+  int  blksz;                   /* size of a memory block */
+  int  used;                    /* number of used objects */
+  void **free;                  /* list of free objects */
+  void *blocks;                 /* allocated memory blocks */
+} MEMSYS;                       /* (memory management system) */
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+extern MEMSYS* ms_create (int size, int cnt);
+extern void    ms_delete (MEMSYS *ms);
+extern void*   ms_alloc  (MEMSYS *ms);
+extern void    ms_free   (MEMSYS *ms, void *obj);
+extern int     ms_used   (MEMSYS *ms);
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define ms_used(m)       ((m)->used)
+
+#endif

data/ext/util/src/nstats.c

@@ -0,0 +1,288 @@
+/*----------------------------------------------------------------------
+  File    : nstats.c
+  Contents: management of normalization statistics
+  Author  : Christian Borgelt
+  History : 2003.08.12 file created
+            2004.08.12 description and parse function added
+----------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <float.h>
+#include <math.h>
+#include <assert.h>
+#include "nstats.h"
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define BLKSIZE   64            /* block size for parsing */
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+
+NSTATS* nst_create (int dim)
+{                               /* --- create numerical statistics */
+  NSTATS *nst;                  /* created statistics structure */
+  double *p;                    /* to organize the memory */
+
+  assert(dim > 0);              /* check the function argument */
+  nst = (NSTATS*)malloc(sizeof(NSTATS) +(6*dim -1) *sizeof(double));
+  if (!nst) return NULL;        /* create a statistics structure */
+  nst->dim  = dim;              /* and initialize the fields */
+  nst->reg  = 0;
+  nst->offs = p = nst->facs +dim;
+  nst->mins = p += dim;
+  nst->maxs = p += dim;         /* organize the vectors */
+  nst->sums = p += dim;
+  nst->sqrs = p += dim;
+  while (--dim >= 0) {          /* traverse the vectors */
+    nst->mins[dim] = DBL_MAX; nst->maxs[dim] = -DBL_MAX;
+    nst->sums[dim] = nst->sqrs[dim] = nst->offs[dim] = 0;
+    nst->facs[dim] = 1;         /* initialize the ranges of values */
+  }                             /* and the aggregation variables */
+  return nst;                   /* return created structure */
+}  /* nst_create() */
+
+/*--------------------------------------------------------------------*/
+
+void nst_delete (NSTATS *nst)
+{ free(nst); }                  /* --- delete numerical statistics */
+
+/*--------------------------------------------------------------------*/
+
+void nst_reg (NSTATS *nst, const double *vec, double weight)
+{                               /* --- register a data vector */
+  int    i;                     /* loop variable */
+  double *min, *max;            /* to traverse the min./max. values */
+  double *sum, *sqr;            /* to traverse the value sums */
+  double *off, *fac;            /* to traverse the offsets/scales */
+  double t;                     /* temporary buffer */
+
+  assert(nst && vec);           /* check the function arguments */
+  sum = nst->sums;              /* get the vectors for the sums */
+  sqr = nst->sqrs;              /* and the sums of squares */
+  if (!vec) {                   /* if to terminate registration */
+    off = nst->offs;            /* get the offsets and */
+    fac = nst->facs;            /* the scaling factors */
+    if (nst->reg <= 0)          /* if no patterns are registered */
+      for (i = nst->dim; --i >= 0; ) { off[i] = 0; fac[i] = 1; }
+    else {                      /* if patterns have been registered */
+      for (i = nst->dim; --i >= 0; ) {      /* traverse the vectors */
+        off[i] = sum[i] /nst->reg;
+        t      = sqr[i] -off[i] *sum[i];
+        fac[i] = (t > 0) ? sqrt(nst->reg /t) : 1;
+      }                         /* estimate the parameters */
+    }
+    if (weight < 0) {           /* if to reinitialize registration */
+      for (i = nst->dim; --i >= 0; )
+        sum[i] = sqr[i] = 0;    /* reinitialize the vectors */
+      nst->reg = 0;             /* and the pattern counter */
+    } }
+  else {                        /* if to register a data vector */
+    min = nst->mins;            /* get the minimal */
+    max = nst->maxs;            /* and the maximal values */
+    for (i = nst->dim; --i >= 0; ) {
+      if (vec[i] < min[i]) min[i] = vec[i];
+      if (vec[i] > max[i]) max[i] = vec[i];
+      sum[i] += vec[i];         /* update the ranges of values */
+      sqr[i] += vec[i] *vec[i]; /* and sum the values */
+    }                           /* and their squares */
+    nst->reg += weight;         /* count the pattern */
+  }
+}  /* nst_reg() */
+
+/*--------------------------------------------------------------------*/
+
+void nst_range (NSTATS *nst, int idx, double min, double max)
+{                               /* --- set range of values */
+  int i;                        /* loop variable */
+
+  assert(nst && (idx < nst->dim));  /* check the arguments */
+  if (idx < 0) { i = nst->dim; idx = 0; }
+  else         { i = idx +1; }  /* get index range to set */
+  while (--i >= idx) {          /* and traverse it */
+    nst->mins[i] = min;         /* set the minimal */
+    nst->maxs[i] = max;         /* and the maximal value */
+  }                             /* for all dimensions in range */
+}  /* nst_range() */
+
+/*--------------------------------------------------------------------*/
+
+void nst_expand (NSTATS *nst, int idx, double factor)
+{                               /* --- expand range of values */
+  int    i;                     /* loop variable */
+  double t;                     /* change of minimal/maximal value */
+
+  assert(nst                    /* check the function arguments */
+     && (idx < nst->dim) && (factor >= 0));
+  if (idx < 0) { i = nst->dim; idx = 0; }
+  else         { i = idx +1; }  /* get index range to expand */
+  while (--i >= idx) {          /* and traverse it */
+    t = (nst->maxs[i] -nst->mins[i]) *(factor -1) *0.5;
+    nst->mins[i] -= t;          /* adapt the minimal */
+    nst->maxs[i] += t;          /* and   the maximal value */
+  }                             /* for all dimensions in range */
+}  /* nst_expand() */
+
+/*--------------------------------------------------------------------*/
+
+void nst_scale (NSTATS *nst, int idx, double off, double fac)
+{                               /* --- set (linear) scaling */
+  int i;                        /* loop variable */
+
+  assert(nst && (idx < nst->dim));  /* check the arguments */
+  if (idx < 0) { i = nst->dim; idx = 0; }
+  else         { i = idx +1; }  /* get index range to set */
+  while (--i >= idx) {          /* and traverse it */
+    nst->offs[i] = off;         /* set the offset */
+    nst->facs[i] = fac;         /* and the scaling factor */
+  }                             /* for all dimensions in range */
+}  /* nst_scale() */
+
+/*--------------------------------------------------------------------*/
+
+void nst_norm (NSTATS *nst, const double *vec, double *res)
+{                               /* --- normalize a data vector */
+  int    i;                     /* loop variable */
+  double *off, *fac;            /* to traverse the scaling parameters */
+
+  assert(nst && vec && res);    /* check the function arguments */
+  off = nst->offs +(i = nst->dim);
+  fac = nst->facs + i;          /* get the scaling parameters */
+  res += i; vec += i;           /* and the data vectors */
+  while (--i >= 0) *--res = *--fac * (*--vec - *--off);
+}  /* nst_norm() */             /* scale the vector */
+
+/*--------------------------------------------------------------------*/
+
+void nst_inorm (NSTATS *nst, const double *vec, double *res)
+{                               /* --- inverse normalize a vector */
+  int    i;                     /* loop variable */
+  double *off, *fac;            /* to traverse the scaling parameters */
+
+  assert(nst && vec && res);    /* check the function arguments */
+  off = nst->offs +(i = nst->dim);
+  fac = nst->facs + i;          /* get the scaling parameters */
+  res += i; vec += i;           /* and the data vectors */
+  while (--i >= 0) *--res = *--vec / *--fac + *--off;
+}  /* nst_inorm() */            /* scale the vector */
+
+/*--------------------------------------------------------------------*/
+
+void nst_center (NSTATS *nst, double *vec)
+{                               /* --- get center of data space */
+  int    i;                     /* loop variable */
+  double *min, *max;            /* to traverse the ranges */
+
+  assert(nst && vec);           /* check the function arguments */
+  min = nst->mins;              /* get the range variables, */
+  max = nst->maxs;              /* traverse the dimensions, */
+  for (i = nst->dim; --i >= 0;) /* and compute the center vector */
+    vec[i] = 0.5 *(max[i] +min[i]);
+}  /* nst_center() */
+
+/*--------------------------------------------------------------------*/
+
+void nst_spans (NSTATS *nst, double *vec)
+{                               /* --- get spans of dimensions */
+  int    i;                     /* loop variable */
+  double *min, *max;            /* to traverse the ranges */
+
+  assert(nst && vec);           /* check the function arguments */
+  min = nst->mins;            
+  max = nst->maxs;              /* get the range variables, */ 
+  for (i = nst->dim; --i >= 0;) /* traverse the dimensions, */ 
+    vec[i] = max[i] -min[i];    /* and compute the spans */
+}  /* nst_spans() */
+
+/*--------------------------------------------------------------------*/
+
+int nst_desc (NSTATS *nst, FILE *file, const char *indent, int maxlen)
+{                               /* --- describe norm. statistics */
+  int  i;                       /* loop variable */
+  int  pos, ind;                /* position in output line */
+  char buf[64];                 /* buffer for output */
+
+  for (i = nst->dim; --i >= 0;) /* check for non-identity scaling */
+    if ((nst->offs[i] != 0) || (nst->facs[i] != 1)) break;
+  if (i < 0) return 0;          /* if all identity scaling, abort */
+
+  fputs(indent,        file);   /* write the indentation and */
+  fputs("scales   = ", file);   /* start the scaling parameters */
+  for (ind = 0; indent[ind]; ind++);
+  pos = ind +9;                 /* compute the starting position */
+  for (i = 0; i < nst->dim; i++) {
+    pos += sprintf(buf, "[%g, %g]", nst->offs[i], nst->facs[i]);
+    if (i > 0) {                /* format the scaling parameters */
+      if (pos +3 <= maxlen) { fputs(", ", file);      pos += 2;   }
+      else { fprintf(file, ",\n%s         ", indent); pos  = ind; }
+    }                           /* print separator and indentation */
+    fputs(buf, file);           /* print formatted offset and factor */
+  }
+  fputs(";\n", file);           /* terminate the list */
+  return ferror(file) ? -1 : 0; /* return the write status */
+}  /* nst_desc() */
+
+/*--------------------------------------------------------------------*/
+#ifdef NST_PARSE
+
+static int _parse (SCAN *scan, int dim, double **buf)
+{                               /* --- parse normalization statistics */
+  int    k, n = 0;              /* loop variable, counter */
+  double *p;                    /* to access the statistics elements */
+
+  assert(scan);                 /* check the function arguments */
+  if ((sc_token(scan) != T_ID)  /* check whether 'scales' follows */
+  ||  (strcmp(sc_value(scan), "scales") != 0))
+    ERR_STR("scales");          /* if not, abort the function */
+  GET_TOK();                    /* consume 'scales' */
+  GET_CHR('=');                 /* consume '=' */
+  for (k = 0; (dim <= 0) || (k < dim); k++) {
+    if (k > 0) { GET_CHR(',');} /* if not first, consume ',' */
+    if (k >= n) {               /* if the statistics vector is full */
+      if (dim > 0) n  = dim;    /* compute the new vector size */
+      else         n += (n > BLKSIZE) ? n >> 1 : BLKSIZE;
+      p = (double*)realloc(*buf, (n+n) *sizeof(double));
+      if (!p) ERROR(E_NOMEM);   /* enlarge the buffer vector */
+      *buf = p;                 /* and set the new vector, */
+    }                           /* then note factor and offset */
+    p = *buf +k +k;             /* get the element to set */
+    GET_CHR('[');               /* consume '[' */
+    if (sc_token(scan) != T_NUM) ERROR(E_NUMEXP);
+    p[0] = strtod(sc_value(scan), NULL);
+    GET_TOK();                  /* consume the offset */
+    GET_CHR(',');               /* consume '[' */
+    if (sc_token(scan) != T_NUM) ERROR(E_NUMEXP);
+    p[1] = strtod(sc_value(scan), NULL);
+    GET_TOK();                  /* consume the factor */
+    GET_CHR(']');               /* consume '[' */
+    if ((dim <= 0) && (sc_token(scan) != ',')) {
+      k++; break; }             /* check for more scaling params. */
+  }
+  GET_CHR(';');                 /* consume ';' */
+  return k;                     /* return 'ok' */
+}  /* _parse() */
+
+/*--------------------------------------------------------------------*/
+
+NSTATS* nst_parse (SCAN *scan, int dim)
+{                               /* --- parse normalization statistics */
+  NSTATS *nst;                  /* created normalization statistics */
+  double *buf = NULL;           /* buffer for reading */
+
+  assert(scan);                 /* check the function arguments */
+  dim = _parse(scan,dim, &buf); /* parse normalization statistics */
+  if (dim < 0) { if (buf) free(buf); return NULL; }
+  nst = nst_create(dim);        /* create a statistics structure */
+  if (!nst)    { free(buf); return NULL; }
+  for (buf += dim +dim; --dim >= 0; ) {
+    nst->facs[dim] = *--buf;    /* copy the buffered values */
+    nst->offs[dim] = *--buf;    /* into the corresponding vectors */
+  }
+  free(buf);                    /* delete the read buffer */
+  return nst;                   /* return the created structure */
+}  /* nst_parse() */
+
+#endif