alglib 0.1.1

data/ext/alglib/mlptrain.h

@@ -0,0 +1,283 @@
+/*************************************************************************
+Copyright (c) 2007-2008, Sergey Bochkanov (ALGLIB project).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+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 THE COPYRIGHT
+OWNER OR 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.
+*************************************************************************/
+
+#ifndef _mlptrain_h
+#define _mlptrain_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "mlpbase.h"
+#include "trinverse.h"
+#include "lbfgs.h"
+#include "cholesky.h"
+#include "spdsolve.h"
+
+
+struct mlpreport
+{
+    int ngrad;
+    int nhess;
+    int ncholesky;
+};
+struct mlpcvreport
+{
+    double relclserror;
+    double avgce;
+    double rmserror;
+    double avgerror;
+    double avgrelerror;
+};
+
+
+/*************************************************************************
+Neural network training  using  modified  Levenberg-Marquardt  with  exact
+Hessian calculation and regularization. Subroutine trains  neural  network
+with restarts from random positions. Algorithm is well  suited  for  small
+and medium scale problems (hundreds of weights).
+
+INPUT PARAMETERS:
+    Network     -   neural network with initialized geometry
+    XY          -   training set
+    NPoints     -   training set size
+    Decay       -   weight decay constant, >=0.001
+                    Decay term 'Decay*||Weights||^2' is added to error
+                    function.
+                    If you don't know what Decay to choose, use 0.001.
+    Restarts    -   number of restarts from random position, >0.
+                    If you don't know what Restarts to choose, use 2.
+
+OUTPUT PARAMETERS:
+    Network     -   trained neural network.
+    Info        -   return code:
+                    * -9, if internal matrix inverse subroutine failed
+                    * -2, if there is a point with class number
+                          outside of [0..NOut-1].
+                    * -1, if wrong parameters specified
+                          (NPoints<0, Restarts<1).
+                    *  2, if task has been solved.
+    Rep         -   training report
+
+  -- ALGLIB --
+     Copyright 10.03.2009 by Bochkanov Sergey
+*************************************************************************/
+void mlptrainlm(multilayerperceptron& network,
+     const ap::real_2d_array& xy,
+     int npoints,
+     double decay,
+     int restarts,
+     int& info,
+     mlpreport& rep);
+
+
+/*************************************************************************
+Neural  network  training  using  L-BFGS  algorithm  with  regularization.
+Subroutine  trains  neural  network  with  restarts from random positions.
+Algorithm  is  well  suited  for  problems  of  any dimensionality (memory
+requirements and step complexity are linear by weights number).
+
+INPUT PARAMETERS:
+    Network     -   neural network with initialized geometry
+    XY          -   training set
+    NPoints     -   training set size
+    Decay       -   weight decay constant, >=0.001
+                    Decay term 'Decay*||Weights||^2' is added to error
+                    function.
+                    If you don't know what Decay to choose, use 0.001.
+    Restarts    -   number of restarts from random position, >0.
+                    If you don't know what Restarts to choose, use 2.
+    WStep       -   stopping criterion. Algorithm stops if  step  size  is
+                    less than WStep. Recommended value - 0.01.  Zero  step
+                    size means stopping after MaxIts iterations.
+    MaxIts      -   stopping   criterion.  Algorithm  stops  after  MaxIts
+                    iterations (NOT gradient  calculations).  Zero  MaxIts
+                    means stopping when step is sufficiently small.
+
+OUTPUT PARAMETERS:
+    Network     -   trained neural network.
+    Info        -   return code:
+                    * -8, if both WStep=0 and MaxIts=0
+                    * -2, if there is a point with class number
+                          outside of [0..NOut-1].
+                    * -1, if wrong parameters specified
+                          (NPoints<0, Restarts<1).
+                    *  2, if task has been solved.
+    Rep         -   training report
+
+  -- ALGLIB --
+     Copyright 09.12.2007 by Bochkanov Sergey
+*************************************************************************/
+void mlptrainlbfgs(multilayerperceptron& network,
+     const ap::real_2d_array& xy,
+     int npoints,
+     double decay,
+     int restarts,
+     double wstep,
+     int maxits,
+     int& info,
+     mlpreport& rep);
+
+
+/*************************************************************************
+Neural network training using early stopping (base algorithm - L-BFGS with
+regularization).
+
+INPUT PARAMETERS:
+    Network     -   neural network with initialized geometry
+    TrnXY       -   training set
+    TrnSize     -   training set size
+    ValXY       -   validation set
+    ValSize     -   validation set size
+    Decay       -   weight decay constant, >=0.001
+                    Decay term 'Decay*||Weights||^2' is added to error
+                    function.
+                    If you don't know what Decay to choose, use 0.001.
+    Restarts    -   number of restarts from random position, >0.
+                    If you don't know what Restarts to choose, use 2.
+
+OUTPUT PARAMETERS:
+    Network     -   trained neural network.
+    Info        -   return code:
+                    * -2, if there is a point with class number
+                          outside of [0..NOut-1].
+                    * -1, if wrong parameters specified
+                          (NPoints<0, Restarts<1, ...).
+                    *  2, task has been solved, stopping  criterion  met -
+                          sufficiently small step size.  Not expected  (we
+                          use  EARLY  stopping)  but  possible  and not an
+                          error.
+                    *  6, task has been solved, stopping  criterion  met -
+                          increasing of validation set error.
+    Rep         -   training report
+
+NOTE:
+
+Algorithm stops if validation set error increases for  a  long  enough  or
+step size is small enought  (there  are  task  where  validation  set  may
+decrease for eternity). In any case solution returned corresponds  to  the
+minimum of validation set error.
+
+  -- ALGLIB --
+     Copyright 10.03.2009 by Bochkanov Sergey
+*************************************************************************/
+void mlptraines(multilayerperceptron& network,
+     const ap::real_2d_array& trnxy,
+     int trnsize,
+     const ap::real_2d_array& valxy,
+     int valsize,
+     double decay,
+     int restarts,
+     int& info,
+     mlpreport& rep);
+
+
+/*************************************************************************
+Cross-validation estimate of generalization error.
+
+Base algorithm - L-BFGS.
+
+INPUT PARAMETERS:
+    Network     -   neural network with initialized geometry.   Network is
+                    not changed during cross-validation -  it is used only
+                    as a representative of its architecture.
+    XY          -   training set.
+    SSize       -   training set size
+    Decay       -   weight  decay, same as in MLPTrainLBFGS
+    Restarts    -   number of restarts, >0.
+                    restarts are counted for each partition separately, so
+                    total number of restarts will be Restarts*FoldsCount.
+    WStep       -   stopping criterion, same as in MLPTrainLBFGS
+    MaxIts      -   stopping criterion, same as in MLPTrainLBFGS
+    FoldsCount  -   number of folds in k-fold cross-validation,
+                    2<=FoldsCount<=SSize.
+                    recommended value: 10.
+
+OUTPUT PARAMETERS:
+    Info        -   return code, same as in MLPTrainLBFGS
+    Rep         -   report, same as in MLPTrainLM/MLPTrainLBFGS
+    CVRep       -   generalization error estimates
+
+  -- ALGLIB --
+     Copyright 09.12.2007 by Bochkanov Sergey
+*************************************************************************/
+void mlpkfoldcvlbfgs(const multilayerperceptron& network,
+     const ap::real_2d_array& xy,
+     int npoints,
+     double decay,
+     int restarts,
+     double wstep,
+     int maxits,
+     int foldscount,
+     int& info,
+     mlpreport& rep,
+     mlpcvreport& cvrep);
+
+
+/*************************************************************************
+Cross-validation estimate of generalization error.
+
+Base algorithm - Levenberg-Marquardt.
+
+INPUT PARAMETERS:
+    Network     -   neural network with initialized geometry.   Network is
+                    not changed during cross-validation -  it is used only
+                    as a representative of its architecture.
+    XY          -   training set.
+    SSize       -   training set size
+    Decay       -   weight  decay, same as in MLPTrainLBFGS
+    Restarts    -   number of restarts, >0.
+                    restarts are counted for each partition separately, so
+                    total number of restarts will be Restarts*FoldsCount.
+    FoldsCount  -   number of folds in k-fold cross-validation,
+                    2<=FoldsCount<=SSize.
+                    recommended value: 10.
+
+OUTPUT PARAMETERS:
+    Info        -   return code, same as in MLPTrainLBFGS
+    Rep         -   report, same as in MLPTrainLM/MLPTrainLBFGS
+    CVRep       -   generalization error estimates
+
+  -- ALGLIB --
+     Copyright 09.12.2007 by Bochkanov Sergey
+*************************************************************************/
+void mlpkfoldcvlm(const multilayerperceptron& network,
+     const ap::real_2d_array& xy,
+     int npoints,
+     double decay,
+     int restarts,
+     int foldscount,
+     int& info,
+     mlpreport& rep,
+     mlpcvreport& cvrep);
+
+
+#endif

data/ext/alglib/nearunityunit.cpp

@@ -0,0 +1,91 @@
+
+#include <stdafx.h>
+#include "nearunityunit.h"
+
+double log1p(double x)
+{
+    double result;
+    double z;
+    double lp;
+    double lq;
+
+    z = 1.0+x;
+    if( z<0.70710678118654752440||z>1.41421356237309504880 )
+    {
+        result = log(z);
+        return result;
+    }
+    z = x*x;
+    lp = 4.5270000862445199635215E-5;
+    lp = lp*x+4.9854102823193375972212E-1;
+    lp = lp*x+6.5787325942061044846969E0;
+    lp = lp*x+2.9911919328553073277375E1;
+    lp = lp*x+6.0949667980987787057556E1;
+    lp = lp*x+5.7112963590585538103336E1;
+    lp = lp*x+2.0039553499201281259648E1;
+    lq = 1.0000000000000000000000E0;
+    lq = lq*x+1.5062909083469192043167E1;
+    lq = lq*x+8.3047565967967209469434E1;
+    lq = lq*x+2.2176239823732856465394E2;
+    lq = lq*x+3.0909872225312059774938E2;
+    lq = lq*x+2.1642788614495947685003E2;
+    lq = lq*x+6.0118660497603843919306E1;
+    z = -0.5*z+x*(z*lp/lq);
+    result = x+z;
+    return result;
+}
+
+
+double expm1(double x)
+{
+    double result;
+    double r;
+    double xx;
+    double ep;
+    double eq;
+
+    if( x<-0.5||x>0.5 )
+    {
+        result = exp(x)-1.0;
+        return result;
+    }
+    xx = x*x;
+    ep = 1.2617719307481059087798E-4;
+    ep = ep*xx+3.0299440770744196129956E-2;
+    ep = ep*xx+9.9999999999999999991025E-1;
+    eq = 3.0019850513866445504159E-6;
+    eq = eq*xx+2.5244834034968410419224E-3;
+    eq = eq*xx+2.2726554820815502876593E-1;
+    eq = eq*xx+2.0000000000000000000897E0;
+    r = x*ep;
+    r = r/(eq-r);
+    result = r+r;
+    return result;
+}
+
+
+double cosm1(double x)
+{
+    double result;
+    double xx;
+    double c;
+
+    if( x<-0.25*ap::pi()||x>0.25*ap::pi() )
+    {
+        result = cos(x)-1;
+        return result;
+    }
+    xx = x*x;
+    c = 4.7377507964246204691685E-14;
+    c = c*xx-1.1470284843425359765671E-11;
+    c = c*xx+2.0876754287081521758361E-9;
+    c = c*xx-2.7557319214999787979814E-7;
+    c = c*xx+2.4801587301570552304991E-5;
+    c = c*xx-1.3888888888888872993737E-3;
+    c = c*xx+4.1666666666666666609054E-2;
+    result = -0.5*xx+xx*xx*c;
+    return result;
+}
+
+
+

data/ext/alglib/nearunityunit.h

@@ -0,0 +1,17 @@
+
+#ifndef _nearunityunit_h
+#define _nearunityunit_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+double log1p(double x);
+
+
+double expm1(double x);
+
+
+double cosm1(double x);
+
+
+#endif

data/ext/alglib/normaldistr.cpp

@@ -0,0 +1,377 @@
+/*************************************************************************
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier
+
+Contributors:
+    * Sergey Bochkanov (ALGLIB project). Translation from C to
+      pseudocode.
+
+See subroutines comments for additional copyrights.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+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 THE COPYRIGHT
+OWNER OR 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.
+*************************************************************************/
+
+#include <stdafx.h>
+#include "normaldistr.h"
+
+/*************************************************************************
+Error function
+
+The integral is
+
+                          x
+                           -
+                2         | |          2
+  erf(x)  =  --------     |    exp( - t  ) dt.
+             sqrt(pi)   | |
+                         -
+                          0
+
+For 0 <= |x| < 1, erf(x) = x * P4(x**2)/Q5(x**2); otherwise
+erf(x) = 1 - erfc(x).
+
+
+ACCURACY:
+
+                     Relative error:
+arithmetic   domain     # trials      peak         rms
+   IEEE      0,1         30000       3.7e-16     1.0e-16
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier
+*************************************************************************/
+double erf(double x)
+{
+    double result;
+    double xsq;
+    double s;
+    double p;
+    double q;
+
+    s = ap::sign(x);
+    x = fabs(x);
+    if( x<0.5 )
+    {
+        xsq = x*x;
+        p = 0.007547728033418631287834;
+        p = 0.288805137207594084924010+xsq*p;
+        p = 14.3383842191748205576712+xsq*p;
+        p = 38.0140318123903008244444+xsq*p;
+        p = 3017.82788536507577809226+xsq*p;
+        p = 7404.07142710151470082064+xsq*p;
+        p = 80437.3630960840172832162+xsq*p;
+        q = 0.0;
+        q = 1.00000000000000000000000+xsq*q;
+        q = 38.0190713951939403753468+xsq*q;
+        q = 658.070155459240506326937+xsq*q;
+        q = 6379.60017324428279487120+xsq*q;
+        q = 34216.5257924628539769006+xsq*q;
+        q = 80437.3630960840172826266+xsq*q;
+        result = s*1.1283791670955125738961589031*x*p/q;
+        return result;
+    }
+    if( x>=10 )
+    {
+        result = s;
+        return result;
+    }
+    result = s*(1-erfc(x));
+    return result;
+}
+
+
+/*************************************************************************
+Complementary error function
+
+ 1 - erf(x) =
+
+                          inf.
+                            -
+                 2         | |          2
+  erfc(x)  =  --------     |    exp( - t  ) dt
+              sqrt(pi)   | |
+                          -
+                           x
+
+
+For small x, erfc(x) = 1 - erf(x); otherwise rational
+approximations are computed.
+
+
+ACCURACY:
+
+                     Relative error:
+arithmetic   domain     # trials      peak         rms
+   IEEE      0,26.6417   30000       5.7e-14     1.5e-14
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier
+*************************************************************************/
+double erfc(double x)
+{
+    double result;
+    double p;
+    double q;
+
+    if( x<0 )
+    {
+        result = 2-erfc(-x);
+        return result;
+    }
+    if( x<0.5 )
+    {
+        result = 1.0-erf(x);
+        return result;
+    }
+    if( x>=10 )
+    {
+        result = 0;
+        return result;
+    }
+    p = 0.0;
+    p = 0.5641877825507397413087057563+x*p;
+    p = 9.675807882987265400604202961+x*p;
+    p = 77.08161730368428609781633646+x*p;
+    p = 368.5196154710010637133875746+x*p;
+    p = 1143.262070703886173606073338+x*p;
+    p = 2320.439590251635247384768711+x*p;
+    p = 2898.0293292167655611275846+x*p;
+    p = 1826.3348842295112592168999+x*p;
+    q = 1.0;
+    q = 17.14980943627607849376131193+x*q;
+    q = 137.1255960500622202878443578+x*q;
+    q = 661.7361207107653469211984771+x*q;
+    q = 2094.384367789539593790281779+x*q;
+    q = 4429.612803883682726711528526+x*q;
+    q = 6089.5424232724435504633068+x*q;
+    q = 4958.82756472114071495438422+x*q;
+    q = 1826.3348842295112595576438+x*q;
+    result = exp(-ap::sqr(x))*p/q;
+    return result;
+}
+
+
+/*************************************************************************
+Normal distribution function
+
+Returns the area under the Gaussian probability density
+function, integrated from minus infinity to x:
+
+                           x
+                            -
+                  1        | |          2
+   ndtr(x)  = ---------    |    exp( - t /2 ) dt
+              sqrt(2pi)  | |
+                          -
+                         -inf.
+
+            =  ( 1 + erf(z) ) / 2
+            =  erfc(z) / 2
+
+where z = x/sqrt(2). Computation is via the functions
+erf and erfc.
+
+
+ACCURACY:
+
+                     Relative error:
+arithmetic   domain     # trials      peak         rms
+   IEEE     -13,0        30000       3.4e-14     6.7e-15
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier
+*************************************************************************/
+double normaldistribution(double x)
+{
+    double result;
+
+    result = 0.5*(erf(x/1.41421356237309504880)+1);
+    return result;
+}
+
+
+/*************************************************************************
+Inverse of the error function
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier
+*************************************************************************/
+double inverf(double e)
+{
+    double result;
+
+    result = invnormaldistribution(0.5*(e+1))/sqrt(double(2));
+    return result;
+}
+
+
+/*************************************************************************
+Inverse of Normal distribution function
+
+Returns the argument, x, for which the area under the
+Gaussian probability density function (integrated from
+minus infinity to x) is equal to y.
+
+
+For small arguments 0 < y < exp(-2), the program computes
+z = sqrt( -2.0 * log(y) );  then the approximation is
+x = z - log(z)/z  - (1/z) P(1/z) / Q(1/z).
+There are two rational functions P/Q, one for 0 < y < exp(-32)
+and the other for y up to exp(-2).  For larger arguments,
+w = y - 0.5, and  x/sqrt(2pi) = w + w**3 R(w**2)/S(w**2)).
+
+ACCURACY:
+
+                     Relative error:
+arithmetic   domain        # trials      peak         rms
+   IEEE     0.125, 1        20000       7.2e-16     1.3e-16
+   IEEE     3e-308, 0.135   50000       4.6e-16     9.8e-17
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 1988, 1992, 2000 by Stephen L. Moshier
+*************************************************************************/
+double invnormaldistribution(double y0)
+{
+    double result;
+    double expm2;
+    double s2pi;
+    double x;
+    double y;
+    double z;
+    double y2;
+    double x0;
+    double x1;
+    int code;
+    double p0;
+    double q0;
+    double p1;
+    double q1;
+    double p2;
+    double q2;
+
+    expm2 = 0.13533528323661269189;
+    s2pi = 2.50662827463100050242;
+    if( y0<=0 )
+    {
+        result = -ap::maxrealnumber;
+        return result;
+    }
+    if( y0>=1 )
+    {
+        result = ap::maxrealnumber;
+        return result;
+    }
+    code = 1;
+    y = y0;
+    if( y>1.0-expm2 )
+    {
+        y = 1.0-y;
+        code = 0;
+    }
+    if( y>expm2 )
+    {
+        y = y-0.5;
+        y2 = y*y;
+        p0 = -59.9633501014107895267;
+        p0 = 98.0010754185999661536+y2*p0;
+        p0 = -56.6762857469070293439+y2*p0;
+        p0 = 13.9312609387279679503+y2*p0;
+        p0 = -1.23916583867381258016+y2*p0;
+        q0 = 1;
+        q0 = 1.95448858338141759834+y2*q0;
+        q0 = 4.67627912898881538453+y2*q0;
+        q0 = 86.3602421390890590575+y2*q0;
+        q0 = -225.462687854119370527+y2*q0;
+        q0 = 200.260212380060660359+y2*q0;
+        q0 = -82.0372256168333339912+y2*q0;
+        q0 = 15.9056225126211695515+y2*q0;
+        q0 = -1.18331621121330003142+y2*q0;
+        x = y+y*y2*p0/q0;
+        x = x*s2pi;
+        result = x;
+        return result;
+    }
+    x = sqrt(-2.0*log(y));
+    x0 = x-log(x)/x;
+    z = 1.0/x;
+    if( x<8.0 )
+    {
+        p1 = 4.05544892305962419923;
+        p1 = 31.5251094599893866154+z*p1;
+        p1 = 57.1628192246421288162+z*p1;
+        p1 = 44.0805073893200834700+z*p1;
+        p1 = 14.6849561928858024014+z*p1;
+        p1 = 2.18663306850790267539+z*p1;
+        p1 = -1.40256079171354495875*0.1+z*p1;
+        p1 = -3.50424626827848203418*0.01+z*p1;
+        p1 = -8.57456785154685413611*0.0001+z*p1;
+        q1 = 1;
+        q1 = 15.7799883256466749731+z*q1;
+        q1 = 45.3907635128879210584+z*q1;
+        q1 = 41.3172038254672030440+z*q1;
+        q1 = 15.0425385692907503408+z*q1;
+        q1 = 2.50464946208309415979+z*q1;
+        q1 = -1.42182922854787788574*0.1+z*q1;
+        q1 = -3.80806407691578277194*0.01+z*q1;
+        q1 = -9.33259480895457427372*0.0001+z*q1;
+        x1 = z*p1/q1;
+    }
+    else
+    {
+        p2 = 3.23774891776946035970;
+        p2 = 6.91522889068984211695+z*p2;
+        p2 = 3.93881025292474443415+z*p2;
+        p2 = 1.33303460815807542389+z*p2;
+        p2 = 2.01485389549179081538*0.1+z*p2;
+        p2 = 1.23716634817820021358*0.01+z*p2;
+        p2 = 3.01581553508235416007*0.0001+z*p2;
+        p2 = 2.65806974686737550832*0.000001+z*p2;
+        p2 = 6.23974539184983293730*0.000000001+z*p2;
+        q2 = 1;
+        q2 = 6.02427039364742014255+z*q2;
+        q2 = 3.67983563856160859403+z*q2;
+        q2 = 1.37702099489081330271+z*q2;
+        q2 = 2.16236993594496635890*0.1+z*q2;
+        q2 = 1.34204006088543189037*0.01+z*q2;
+        q2 = 3.28014464682127739104*0.0001+z*q2;
+        q2 = 2.89247864745380683936*0.000001+z*q2;
+        q2 = 6.79019408009981274425*0.000000001+z*q2;
+        x1 = z*p2/q2;
+    }
+    x = x0-x1;
+    if( code!=0 )
+    {
+        x = -x;
+    }
+    result = x;
+    return result;
+}
+
+
+