apriori 0.2.1

data/ext/math/src/gamma.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------------------
+  File    : gamma.h
+  Contents: computation of the (incomplete) gamma function
+  Author  : Christian Borgelt
+  History : 2002.07.04 file created
+            2002.08.02 function Gamma added
+            2003.05.19 incomplete Gamma function added
+            2008.03.14 more incomplete Gamma functions added
+            2008.03.17 gamma distribution functions added
+----------------------------------------------------------------------*/
+#ifndef __GAMMA__
+#define __GAMMA__
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+extern double logGamma   (double n);
+extern double Gamma      (double n);
+extern double lowerGamma (double n, double x);
+extern double upperGamma (double n, double x);
+extern double GammaP     (double n, double x);
+extern double GammaQ     (double n, double x);
+
+extern double Gammapdf   (double x,    double k, double theta);
+extern double Gammacdf   (double x,    double k, double theta);
+extern double GammacdfP  (double x,    double k, double theta);
+extern double GammacdfQ  (double x,    double k, double theta);
+extern double Gammaqtl   (double prob, double k, double theta);
+extern double GammaqtlP  (double prob, double k, double theta);
+extern double GammaqtlQ  (double prob, double k, double theta);
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define Gammacdf(x,k,t)  GammaP(k,(x)/(t))
+#define GammacdfP(x,k,t) GammaP(k,(x)/(t))
+#define GammacdfQ(x,k,t) GammaQ(k,(x)/(t))
+
+#endif

data/ext/math/src/intexp.c

@@ -0,0 +1,35 @@
+/*----------------------------------------------------------------------
+  File    : intexp.c
+  Contents: raise x to the power of n, n integer
+  Author  : Christian Borgelt
+  History : 17.05.2003 file created
+----------------------------------------------------------------------*/
+#include "intexp.h"
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+#if 0
+
+double intexp (double x, int n)
+{                               /* --- raise x to the power of n */
+  if (n <= 0) return 0;         /* check for immediate cases, otherw. */
+  if (n <= 1) return x;         /* apply the recursive formula */
+  if (n &  1) return intexp(x*x, n >> 1) *x;
+  else        return intexp(x*x, n >> 1);
+}  /* intexp() */
+
+#else /*--------------------------------------------------------------*/
+
+double intexp (double x, int n)
+{                               /* --- raise x to the power of n */
+  double r = (n & 1) ? x : 1;   /* result */
+
+  for (n >>= 1; n > 0; n >>= 1) {
+    x *= x;                     /* traverse the powers of 2 and */
+    if (n & 1) r *= x;          /* multiply them into the result */
+  }                             /* if the corr. exponent bit is set */
+  return r;                     /* return the result */
+}  /* intexp() */
+
+#endif

data/ext/math/src/intexp.h

@@ -0,0 +1,15 @@
+/*----------------------------------------------------------------------
+  File    : intexp.h
+  Contents: raise x to the power of n, n integer
+  Author  : Christian Borgelt
+  History : 17.05.2003 file created
+----------------------------------------------------------------------*/
+#ifndef __INTEXP__
+#define __INTEXP__
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+extern double intexp (double x, int n);
+
+#endif

data/ext/math/src/makefile

@@ -0,0 +1,164 @@
+#-----------------------------------------------------------------------
+# File    : makefile    (directory: math)
+# Contents: build math utility modules
+# Author  : Christian Borgelt
+# History : 2002.07.04 file created from makefile in util directory
+#           2003.05.19 intexp, choose, zeta, quantile, and normd added
+#           2003.08.15 module radfn added
+#           2008.03.14 main programs added, quantile.c split/removed
+#           2008.03.17 gamma distribution functions added
+#-----------------------------------------------------------------------
+CC      = gcc
+CFBASE  = -ansi -Wall -pedantic $(ADDFLAGS)
+CFLAGS  = $(CFBASE) -DNDEBUG -O3
+# CFLAGS  = $(CFBASE) -g
+LDFLAGS =
+LIBS    = -lm
+
+GAMMA   = gammapdf gammacdf gammaqtl
+NORMAL  = normpdf  normcdf  normqtl
+CHI2    = chi2pdf  chi2cdf  chi2qtl
+PROGS   = $(GAMMA) $(NORMAL) $(CHI2) gamma choose zeta
+
+#-----------------------------------------------------------------------
+# Build Programs
+#-----------------------------------------------------------------------
+all:        $(PROGS)
+
+gamma:      gammain.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gammain.o -o $@
+
+choose:     chsmain.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) chsmain.o -o $@
+
+zeta:       zetamain.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) zetamain.o -o $@
+
+gammapdf:   gammapdf.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gammapdf.o -o $@
+
+gammacdf:   gammacdf.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gammacdf.o -o $@
+
+gammaqtl:   gammaqtl.o normal.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) normal.o gammaqtl.o -o $@
+
+normpdf:    normpdf.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) normpdf.o -o $@
+
+normcdf:    normcdf.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) normcdf.o -o $@
+
+normqtl:    normqtl.o gamma.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gamma.o normqtl.o -o $@
+
+chi2pdf:    chi2pdf.o gamma.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gamma.o chi2pdf.o -o $@
+
+chi2cdf:    chi2cdf.o gamma.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gamma.o chi2cdf.o -o $@
+
+chi2qtl:    chi2qtl.o gammall.o normal.o makefile
+	$(CC) $(LDFLAGS) $(LIBS) gammall.o normal.o chi2qtl.o -o $@
+
+#-----------------------------------------------------------------------
+# Programs
+#-----------------------------------------------------------------------
+gammain.o:  gamma.h
+gammain.o:  gamma.c makefile
+	$(CC) $(CFLAGS) -DGAMMA_MAIN -c gamma.c -o $@
+
+chsmain.o:  choose.h
+chsmain.o:  choose.c makefile
+	$(CC) $(CFLAGS) -DCHOOSE_MAIN -c choose.c -o $@
+
+zetamain.o: zeta.h
+zetamain.o: zeta.c makefile
+	$(CC) $(CFLAGS) -DZETA_MAIN -c zeta.c -o $@
+
+gammapdf.o: gamma.h
+gammapdf.o: gamma.c makefile
+	$(CC) $(CFLAGS) -DGAMMAPDF_MAIN -c gamma.c -o $@
+
+gammacdf.o: gamma.h
+gammacdf.o: gamma.c makefile
+	$(CC) $(CFLAGS) -DGAMMACDF_MAIN -c gamma.c -o $@
+
+gammaqtl.o: gamma.h
+gammaqtl.o: gamma.c makefile
+	$(CC) $(CFLAGS) -DGAMMAQTL_MAIN -c gamma.c -o $@
+
+normpdf.o:  normal.h
+normpdf.o:  normal.c makefile
+	$(CC) $(CFLAGS) -DNORMPDF_MAIN -c normal.c -o $@
+
+normcdf.o:  normal.h
+normcdf.o:  normal.c makefile
+	$(CC) $(CFLAGS) -DNORMCDF_MAIN -c normal.c -o $@
+
+normqtl.o:  normal.h
+normqtl.o:  normal.c makefile
+	$(CC) $(CFLAGS) -DNORMQTL_MAIN -c normal.c -o $@
+
+chi2pdf.o:  chi2.h
+chi2pdf.o:  chi2.c makefile
+	$(CC) $(CFLAGS) -DCHI2PDF_MAIN -c chi2.c -o $@
+
+chi2cdf.o:  chi2.h
+chi2cdf.o:  chi2.c makefile
+	$(CC) $(CFLAGS) -DCHI2CDF_MAIN -c chi2.c -o $@
+
+chi2qtl.o:  chi2.h
+chi2qtl.o:  chi2.c makefile
+	$(CC) $(CFLAGS) -DCHI2QTL_MAIN -c chi2.c -o $@
+
+#-----------------------------------------------------------------------
+# Mathematical Functions
+#-----------------------------------------------------------------------
+choose.o:   choose.h
+choose.o:   choose.c makefile
+	$(CC) $(CFLAGS) -c choose.c -o $@
+
+zeta.o:     zeta.h
+zeta.o:     zeta.c makefile
+	$(CC) $(CFLAGS) -c zeta.c -o $@
+
+intexp.o:   intexp.h
+intexp.o:   intexp.c makefile
+	$(CC) $(CFLAGS) -c intexp.c -o $@
+
+gamma.o:    gamma.h
+gamma.o:    gamma.c makefile
+	$(CC) $(CFLAGS) -c gamma.c -o $@
+
+gammall.o:  gamma.h
+gammall.o:  gamma.c makefile
+	$(CC) $(CFLAGS) -DGAMMAQTL -c gamma.c -o $@
+
+normal.o:   normal.h
+normal.o:   normal.c makefile
+	$(CC) $(CFLAGS) -c normal.c -o $@
+
+chi2.o:     chi2.h
+chi2.o:     chi2.c makefile
+	$(CC) $(CFLAGS) -c chi2.c -o $@
+
+chi2all.o:  chi2.h gamma.h normal.h
+chi2all.o:  chi2.c makefile
+	$(CC) $(CFLAGS) -DCHI2QTL -c chi2.c -o $@
+
+radfn.o:    radfn.h gamma.h
+radfn.o:    radfn.c makefile
+	$(CC) $(CFLAGS) -c radfn.c -o $@
+
+#-----------------------------------------------------------------------
+# Install
+#-----------------------------------------------------------------------
+install:
+	cp $(PROGS) $(HOME)/bin
+
+#-----------------------------------------------------------------------
+# Clean up
+#-----------------------------------------------------------------------
+clean:
+	rm -f $(PROGS) *.o *~ *.flc core

data/ext/math/src/math.mak

@@ -0,0 +1,48 @@
+#-----------------------------------------------------------------------
+# File    : math.mak
+# Contents: build math utility modules
+# Author  : Christian Borgelt
+# History : 26.01.2003 file created
+#           19.05.2003 intexp, choose, zeta, quantile, and normd added
+#           15.08.2003 module radfn added
+#-----------------------------------------------------------------------
+CC      = cl.exe
+LD      = link.exe
+DEFS    = /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS"
+CFLAGS  = /nologo /W3 /EHsc /O2 $(DEFS) /FD /c /D _CRT_SECURE_NO_DEPRECATE
+
+#-----------------------------------------------------------------------
+# Build Modules
+#-----------------------------------------------------------------------
+all:        intexp.obj choose.obj gamma.obj zeta.obj quantile.obj \
+            normd.obj radfn.obj
+
+#-----------------------------------------------------------------------
+# Gamma Function
+#-----------------------------------------------------------------------
+intexp.obj:   intexp.h intexp.c math.mak
+	$(CC) $(CFLAGS) intexp.c /Fo$@
+
+choose.obj:   choose.h choose.c math.mak
+	$(CC) $(CFLAGS) choose.c /Fo$@
+
+gamma.obj:    gamma.h gamma.c math.mak
+	$(CC) $(CFLAGS) gamma.c /Fo$@
+
+zeta.obj:     zeta.h zeta.c math.mak
+	$(CC) $(CFLAGS) zeta.c /Fo$@
+
+quantile.obj: quantile.h quantile.c math.mak
+	$(CC) $(CFLAGS) quantile.c /Fo$@
+
+normd.obj:    normd.h normd.c math.mak
+	$(CC) $(CFLAGS) normd.c /Fo$@
+
+radfn.obj:    radfn.h radfn.c math.mak
+	$(CC) $(CFLAGS) radfn.c /Fo$@
+
+#-----------------------------------------------------------------------
+# Clean up
+#-----------------------------------------------------------------------
+clean:
+	-@erase /Q *~ *.obj *.idb *.pch

data/ext/math/src/normal.c

@@ -0,0 +1,387 @@
+/*----------------------------------------------------------------------
+  File    : normal.c
+  Contents: normal distribution functions
+  Author  : Christian Borgelt
+  History : 2002.11.04 file created
+            2008.03.14 quantile function, main function added
+            2008.03.15 cumulative distribution function added
+----------------------------------------------------------------------*/
+#if defined(NORMPDF_MAIN) \
+ || defined(NORMCDF_MAIN) \
+ || defined(NORMQTL_MAIN)
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+#include <float.h>
+#include <assert.h>
+#include <math.h>
+#include "normal.h"
+
+/*----------------------------------------------------------------------
+  Preprocessor Definitions
+----------------------------------------------------------------------*/
+#define SQRT_2      1.41421356237309504880168872421  /* \sqrt(2) */
+#define _1_SQRT_2PI 0.39894228040143267793994605993  /* 1/\sqrt(2\pi) */
+
+/*----------------------------------------------------------------------
+  Functions
+----------------------------------------------------------------------*/
+
+double unitpdf (double x)
+{                               /* --- probability density function */
+  return exp(-0.5*x*x) *_1_SQRT_2PI;
+}  /* unitpdf() */
+
+/*--------------------------------------------------------------------*/
+
+double unitcdfP (double x)
+{                               /* --- cumulative distribution fn. */
+  double y, z, u;               /* square, absolute value of x */
+
+  if (x >   8.572) return 1.0;  /* if outside proper interval, */
+  if (x < -37.519) return 0.0;  /* return the limiting values */
+  z = fabs(x);                  /* exploit the symmetry */
+  if (z < 0.5*2.2204460492503131e-16)
+    return 0.5;                 /* treat 0 as a special case */
+  if (z < 0.66291) {            /* if fairly close to zero */
+    y = x*x;                    /* compute the square of x */
+    z = ((((     0.065682337918207449113
+        *y +     2.2352520354606839287)
+        *y +   161.02823106855587881)
+        *y +  1067.6894854603709582)
+        *y + 18154.981253343561249)
+      / ((((
+         y +    47.20258190468824187)
+        *y +   976.09855173777669322)
+        *y + 10260.932208618978205)
+        *y + 45507.789335026729956);
+    return 0.5 +x *z;           /* compute with rational function */
+  }                             
+  if (z < 4*SQRT_2) {           /* if medium value */
+    u = (((((((( 1.0765576773720192317e-8
+        *z +     0.39894151208813466764)
+        *z +     8.8831497943883759412)
+        *z +    93.506656132177855979)
+        *z +   597.27027639480026226)
+        *z +  2494.5375852903726711)
+        *z +  6848.1904505362823326)
+        *z + 11602.651437647350124)
+        *z +  9842.7148383839780218)
+      / ((((((((
+         z +    22.266688044328115691)
+        *z +   235.38790178262499861)
+        *z +  1519.377599407554805)
+        *z +  6485.558298266760755)
+        *z + 18615.571640885098091)
+        *z + 34900.952721145977266)
+        *z + 38912.003286093271411)
+        *z + 19685.429676859990727);
+    z = u *exp(-0.5*x*x); }     /* compute with rational function */
+  else {                        /* if tail value */
+    y = 1 /(x*x);               /* compute the inverse square of x */
+    u = (((((    0.02307344176494017303
+        *y +     0.21589853405795699)
+        *y +     0.1274011611602473639)
+        *y +     0.022235277870649807)
+        *y +     0.001421619193227893466)
+        *y +     2.9112874951168792e-5)
+      / (((((
+         y +     1.28426009614491121)
+        *y +     0.468238212480865118)
+        *y +     0.0659881378689285515)
+        *y +     0.00378239633202758244)
+        *y +     7.29751555083966205e-5);
+    z = (((_1_SQRT_2PI) -y*u) /z) *exp(-0.5*x*x);
+  }                             /* compute with rational function */
+  return (x > 0) ? 1-z : z;     /* exploit the symmetry */
+}  /* unitcdfP() */
+
+/*----------------------------------------------------------------------
+References: - W.J. Cody.
+              Rational Chebyshev Approximations for the Error Function.
+              Mathematics of Computation, 23(107):631-637, 1969
+            - W. Fraser and J.F Hart.
+              On the Computation of Rational Approximations
+              to Continuous Functions.
+              Communications of the ACM 5, 1962
+            - W.J. Kennedy Jr. and J.E. Gentle.
+              Statistical Computing.
+              Marcel Dekker, 1980
+----------------------------------------------------------------------*/
+#if 0
+
+double unitqtlP (double prob)
+{                               /* --- quantile of normal distrib. */
+  double p, x;                  /*     with mean 0 and variance 1 */
+
+  assert((prob >= 0) && (prob <= 1));  /* check the function argument */
+  if (prob >= 1.0) return  DBL_MAX; /* check for limiting values */
+  if (prob <= 0.0) return -DBL_MAX; /* and return extrema */
+  if (prob == 0.5) return 0;    /* treat prob = 0.5 as a special case */
+  p = (prob > 0.5) ? 1-prob : prob; /* transform to left tail if nec. */
+  if (p < 1e-20) return (prob < 0.5) ? -10 : 10;
+  x = sqrt(log(1/(p*p)));       /* compute quotient of polynomials */
+  x += ((((-0.453642210148e-4   /* (rational function approximation) */
+       *x  -0.0204231210245)
+       *x  -0.342242088547)
+       *x  -1.0)
+       *x  -0.322232431088)
+     / (((( 0.0038560700634
+       *x  +0.103537752850)
+       *x  +0.531103462366)
+       *x  +0.588581570495)
+       *x  +0.0993484626060);
+  return (prob < 0.5) ? -x : x; /* retransform to right tail if nec. */
+}  /* unitqtlP() */
+
+#else /*--------------------------------------------------------------*/
+
+double unitqtlP (double prob)
+{                               /* --- quantile of normal distrib. */
+  double p, x;                  /*     with mean 0 and variance 1 */
+
+  assert((prob >= 0) && (prob <= 1));  /* check the function argument */
+  if (prob >= 1.0) return  DBL_MAX; /* check for limiting values */
+  if (prob <= 0.0) return -DBL_MAX; /* and return extrema */
+  p = prob -0.5;
+  if (fabs(p) <= 0.425) {       /* if not tail */
+    x = 0.180625 - p*p;         /* get argument of rational function */
+    x = (((((((2509.0809287301226727
+        *x +  33430.575583588128105)
+        *x +  67265.770927008700853)
+        *x +  45921.953931549871457)
+        *x +  13731.693765509461125)
+        *x +   1971.5909503065514427)
+        *x +    133.14166789178437745)
+        *x +      3.387132872796366608)
+      / (((((((5226.495278852854561
+        *x +  28729.085735721942674)
+        *x +  39307.89580009271061)
+        *x +  21213.794301586595867)
+        *x +   5394.1960214247511077)
+        *x +    687.1870074920579083)
+        *x +     42.313330701600911252)
+        *x +      1.0);         /* evaluate the rational function */
+    return p *x;                /* and return the computed value */
+  }
+  p = (prob > 0.5) ? 1-prob : prob;
+  x = sqrt(-log(p));            /* transform to left tail if nec. */
+  if (x <= 5) {                 /* if not extreme tail */
+    x -= 1.6;                   /* get argument of rational function */
+    x = (((((((  7.7454501427834140764e-4
+        *x +     0.0227238449892691845833)
+        *x +     0.24178072517745061177)
+        *x +     1.27045825245236838258)
+        *x +     3.64784832476320460504)
+        *x +     5.7694972214606914055)
+        *x +     4.6303378461565452959)
+        *x +     1.42343711074968357734)
+      / (((((((  1.05075007164441684324e-9
+        *x +     5.475938084995344946e-4)
+        *x +     0.0151986665636164571966)
+        *x +     0.14810397642748007459)
+        *x +     0.68976733498510000455)
+        *x +     1.6763848301838038494)
+        *x +     2.05319162663775882187)
+        *x +     1.0); }        /* evaluate the rational function */
+  else {                        /* if extreme tail */
+    x -= 5;                     /* get argument of rational function */
+    x = (((((((  2.01033439929228813265e-7
+        *x +     2.71155556874348757815e-5)
+        *x +     0.0012426609473880784386)
+        *x +     0.026532189526576123093)
+        *x +     0.29656057182850489123)
+        *x +     1.7848265399172913358)
+        *x +     5.4637849111641143699)
+        *x +     6.6579046435011037772)
+      / (((((((    2.04426310338993978564e-15
+        *x +     1.4215117583164458887e-7)
+        *x +     1.8463183175100546818e-5)
+        *x +     7.868691311456132591e-4)
+        *x +     0.0148753612908506148525)
+        *x +     0.13692988092273580531)
+        *x +     0.59983220655588793769)
+        *x +     1.0);          /* evaluate the rational function */
+  }
+  return (prob < 0.5) ? -x : x; /* retransform to right tail if nec. */
+}  /* unitqtlP() */
+
+#endif
+/*----------------------------------------------------------------------
+References: - R.E. Odeh and J.O. Evans.
+              The percentage points of the normal distribution.
+              Applied Statistics 22:96--97, 1974
+            - J.D. Beasley and S.G. Springer.
+              Algorithm AS 111:
+              The percentage points of the normal distribution.
+              Applied Statistics 26:118--121, 1977
+            - M.J. Wichura
+              Algorithm AS 241:
+              The percentage points of the normal distribution.
+              Applied Statistics 37:477--484, 1988
+----------------------------------------------------------------------*/
+
+double unitrand (double randfn(void))
+{                               /* --- compute N(0,1) distrib. number */
+  static double b;              /* buffer for random number */
+  double x, y, r;               /* coordinates and radius */
+
+  if (b != 0.0) {               /* if the buffer is full, */
+    x = b; b = 0; return x; }   /* return the buffered number */
+  do {                          /* pick a random point */
+    x = 2.0*randfn()-1.0;       /* in the unit square [-1,1]^2 */
+    y = 2.0*randfn()-1.0;       /* and check whether it lies */
+    r = x*x +y*y;               /* inside the unit circle */
+  } while ((r > 1) || (r == 0));
+  r = sqrt(-2*log(r)/r);        /* factor for Box-Muller transform */
+  b = x *r;                     /* save one of the random numbers */
+  return y *r;                  /* and return the other */
+}  /* unitrand() */
+
+/*----------------------------------------------------------------------
+Source for the polar method to generate normally distributed numbers:
+D.E. Knuth.
+The Art of Computer Programming, Vol. 2: Seminumerical Algorithms
+Addison-Wesley, Reading, MA, USA 1998
+pp. 122-123
+----------------------------------------------------------------------*/
+
+double normpdf (double x, double mean, double var)
+{                               /* --- probability density function */
+  assert(var >= 0);             /* check the function arguments */
+  if (var == 1) return unitpdf(x-mean);
+  return unitpdf((x-mean) /sqrt(var));
+}  /* normpdf() */
+
+/*--------------------------------------------------------------------*/
+
+double normcdfP (double x, double mean, double var)
+{                               /* --- cumulative distribution fn. */
+  assert(var >= 0);             /* check the function arguments */
+  if (var == 1) return unitcdf(x-mean);
+  return unitcdf((x-mean) /sqrt(var));
+}  /* normcdfP() */
+
+/*--------------------------------------------------------------------*/
+
+double normcdfQ (double x, double mean, double var)
+{                               /* --- cumulative distribution fn. */
+  assert(var >= 0);             /* check the function arguments */
+  if (var == 1) return unitcdfP(mean-x);
+  return unitcdfP((mean-x) /sqrt(var));
+}  /* normcdfQ() */
+
+/*--------------------------------------------------------------------*/
+
+double normqtlP (double prob, double mean, double var)
+{                               /* --- quantile of normal distrib. */
+  assert((var  >  0)            /* check the function arguments */
+      && (prob >= 0) && (prob <= 1));
+  if (var == 1) return mean +unitqtl(prob);
+  return mean +unitqtlP(prob) *sqrt(var);
+}  /* normqtlP() */
+
+/*--------------------------------------------------------------------*/
+
+double normqtlQ (double prob, double mean, double var)
+{                               /* --- quantile of normal distrib. */
+  assert((var  >  0)            /* check the function arguments */
+      && (prob >= 0) && (prob <= 1));
+  if (var == 1) return mean -unitqtlP(prob);
+  return mean -unitqtlP(prob) *sqrt(var);
+}  /* normqtlQ() */
+
+/*--------------------------------------------------------------------*/
+
+double normrand (double randfn(void), double mean, double var)
+{                               /* --- cumulative distribution fn. */
+  assert(var >= 0);             /* check the function arguments */
+  if (var == 1) return mean +unitrand(randfn);
+  return mean +unitrand(randfn) *sqrt(var);
+}  /* normrand() */
+
+/*----------------------------------------------------------------------
+  Main Functions
+----------------------------------------------------------------------*/
+#ifdef NORMPDF_MAIN
+
+int main (int argc, char *argv[])
+{                               /* --- main function */
+  double mean = 0;              /* mean value */
+  double var  = 1;              /* variance */
+  double x;                     /* argument value */
+
+  if ((argc < 2) || (argc > 4)){/* if wrong number of arguments */
+    printf("usage: %s arg [mean variance]\n", argv[0]);
+    printf("compute probability density function "
+           "of the normal distribution\n");
+    return 0;                   /* print a usage message */
+  }                             /* and abort the program */
+  x = atof(argv[1]);            /* get the argument value */
+  if (argc > 2) mean = atof(argv[2]);
+  if (argc > 3) var  = atof(argv[3]);
+  if (var  < 0) {               /* get the parameters */
+    printf("%s: invalid variance\n", argv[0]); return -1; }
+  printf("normal: f(%.16g; %.16g, %.16g) = %.16g\n",
+         x, mean, var, normpdf(x, mean, var));
+  return 0;                     /* compute and print density */
+}  /* main() */
+
+#endif
+/*--------------------------------------------------------------------*/
+#ifdef NORMCDF_MAIN
+
+int main (int argc, char *argv[])
+{                               /* --- main function */
+  double mean = 0;              /* mean value */
+  double var  = 1;              /* variance */
+  double x;                     /* argument value */
+
+  if ((argc < 2) || (argc > 4)){/* if wrong number of arguments */
+    printf("usage: %s arg [mean variance]\n", argv[0]);
+    printf("compute cumulative distribution function "
+           "of the normal distribution\n");
+    return 0;                   /* print a usage message */
+  }                             /* and abort the program */
+  x = atof(argv[1]);            /* get the argument value */
+  if (argc > 2) mean = atof(argv[2]);
+  if (argc > 3) var  = atof(argv[3]);
+  if (var  < 0) {               /* get the parameters */
+    printf("%s: invalid variance\n", argv[0]); return -1; }
+  printf("normal: F(% .16g; %.16g, %.16g) = %.16g\n",
+         x, mean, var, normcdfP(x, mean, var));
+  printf("    1 - F(% .16g; %.16g, %.16g) = %.16g\n",
+         x, mean, var, normcdfQ(x, mean, var));
+  return 0;                     /* compute and print probability */
+}  /* main() */
+
+#endif
+/*--------------------------------------------------------------------*/
+#ifdef NORMQTL_MAIN
+
+int main (int argc, char *argv[])
+{                               /* --- main function */
+  double mean = 0;              /* mean value */
+  double var  = 1;              /* variance */
+  double prob;                  /* probability */
+
+  if ((argc < 2) || (argc > 4)){/* if wrong number of arguments */
+    printf("usage: %s prob [mean variance]\n", argv[0]);
+    printf("compute quantile of the normal distribution\n");
+    return 0;                   /* print a usage message */
+  }                             /* and abort the program */
+  prob = atof(argv[1]);         /* get the probability */
+  if ((prob < 0) || (prob > 1)) {
+    printf("%s: invalid probability\n", argv[0]); return -1; }
+  if (argc > 2) mean = atof(argv[2]);
+  if (argc > 3) var  = atof(argv[3]);
+  if (var  < 0) {               /* get the parameters */
+    printf("%s: invalid variance\n", argv[0]); return -1; }
+  printf("normal: F(% .16g; %.16g, %.16g) = %.16g\n",
+         normqtlP(prob, mean, var), mean, var, prob);
+  printf("    1 - F(% .16g; %.16g, %.16g) = %.16g\n",
+         normqtlQ(prob, mean, var), mean, var, prob);
+  return 0;                     /* compute and print quantile */
+}  /* main() */
+
+#endif