LCOV - code coverage report
Current view: top level - sc/source/core/opencl - opinlinefun_statistical.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 85 0.0 %
Date: 2014-04-14 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  */
       9             : 
      10             : #ifndef SC_OPENCL_OPINLINFUN_statistical
      11             : #define SC_OPENCL_OPINLINFUN_statistical
      12           0 : std::string MinDecl = "#define Min 2.22507e-308\n";
      13           0 : std::string F_PIDecl="#define F_PI 3.1415926\n";
      14           0 : std::string fBigInvDecl ="#define fBigInv  2.22045e-016\n";
      15           0 : std::string fMachEpsDecl ="#define fMachEps  2.22045e-016\n";
      16           0 : std::string fLogDblMaxDecl ="#define fLogDblMax  log(1.79769e+308)\n";
      17           0 : std::string fHalfMachEpsDecl ="#define fHalfMachEps  0.5*2.22045e-016\n";
      18           0 : std::string fMaxGammaArgumentDecl=
      19             : "#define fMaxGammaArgument 171.624376956302\n";
      20           0 : std::string GetValueDecl=
      21             : "double  GetValue( double x,double fp,double fDF );\n";
      22           0 : std::string GetValue=
      23             : "double  GetValue( double x,double fp,double fDF )\n"
      24             : "{\n"
      25             : "    return fp - 2 * GetTDist(x, fDF);\n"
      26             : "}\n";
      27           0 : std::string GetGammaSeriesDecl=
      28             : "double GetGammaSeries( double fA, double fX );\n";
      29           0 : std::string GetGammaSeries =
      30             : "double GetGammaSeries( double fA, double fX )\n"
      31             : "{\n"
      32             : "    double fDenomfactor = fA;\n"
      33             : "     double fSummand = 1.0/fA;\n"
      34             : "    double fSum = fSummand;\n"
      35             : "    int nCount=1;\n"
      36             : "    do\n"
      37             : "    {\n"
      38             : "        fDenomfactor = fDenomfactor + 1.0;\n"
      39             : "        fSummand = fSummand * fX/fDenomfactor;\n"
      40             : "        fSum = fSum + fSummand;\n"
      41             : "        nCount = nCount+1;\n"
      42             : "    } while ( fSummand/fSum > fHalfMachEps && nCount<=10000);\n"
      43             : "    if (nCount>10000)\n"
      44             : "    {\n"
      45             : "    }\n"
      46             : "    return fSum;\n"
      47             : "}\n";
      48           0 : std::string GetGammaContFractionDecl =  "double GetGammaContFraction( double "
      49             : "fA, double fX );\n";
      50           0 : std::string GetGammaContFraction =
      51             : "double GetGammaContFraction( double fA, double fX )\n"
      52             : "{\n"
      53             : "    double fBig = 1.0/fBigInv;\n"
      54             : "    double fCount = 0.0;\n"
      55             : "    double fNum = 0.0;\n"
      56             : "    double fY = 1.0 - fA;\n"
      57             : "    double fDenom = fX + 2.0-fA;\n"
      58             : "    double fPk = 0.0;\n"
      59             : "    double fPkm1 = fX + 1.0;\n"
      60             : "    double fPkm2 = 1.0;\n"
      61             : "    double fQk = 1.0;\n"
      62             : "    double fQkm1 = fDenom * fX;\n"
      63             : "    double fQkm2 = fX;\n"
      64             : "    double fApprox = fPkm1/fQkm1;\n"
      65             : "    bool bFinished = false;\n"
      66             : "    double fR = 0.0;\n"
      67             : "    do\n"
      68             : "    {\n"
      69             : "        fCount = fCount +1.0;\n"
      70             : "        fY = fY+ 1.0;\n"
      71             : "        fNum = fY * fCount;\n"
      72             : "        fDenom = fDenom +2.0;\n"
      73             : "        fPk = fPkm1 * fDenom  -  fPkm2 * fNum;\n"
      74             : "        fQk = fQkm1 * fDenom  -  fQkm2 * fNum;\n"
      75             : "        if (fQk != 0.0)\n"
      76             : "        {\n"
      77             : "            fR = fPk/fQk;\n"
      78             : "            bFinished = (fabs( (fApprox - fR)/fR ) <= fHalfMachEps);\n"
      79             : "            fApprox = fR;\n"
      80             : "        }\n"
      81             : "        fPkm2 = fPkm1;\n"
      82             : "        fPkm1 = fPk;\n"
      83             : "        fQkm2 = fQkm1;\n"
      84             : "        fQkm1 = fQk;\n"
      85             : "        if (fabs(fPk) > fBig)\n"
      86             : "        {\n"
      87             : "            fPkm2 = fPkm2 * fBigInv;\n"
      88             : "            fPkm1 = fPkm1 * fBigInv;\n"
      89             : "            fQkm2 = fQkm2 * fBigInv;\n"
      90             : "            fQkm1 = fQkm1 * fBigInv;\n"
      91             : "        }\n"
      92             : "    } while (!bFinished && fCount<10000);\n"
      93             : "    if (!bFinished)\n"
      94             : "    {\n"
      95             : "    }\n"
      96             : "    return fApprox;\n"
      97             : "}\n";
      98           0 : std::string GetLowRegIGammaDecl = "double GetLowRegIGamma( double "
      99             : "fA, double fX );\n";
     100           0 : std::string GetLowRegIGamma =
     101             : "double GetLowRegIGamma( double fA, double fX )\n"
     102             : "{\n"
     103             : "    double fLnFactor = fA * log(fX) - fX - lgamma(fA);\n"
     104             : "    double fFactor = exp(fLnFactor);\n"
     105             : "    if (fX>fA+1.0) \n"
     106             : "        return 1.0 - fFactor * GetGammaContFraction(fA,fX);\n"
     107             : "    else\n"
     108             : "        return fFactor * GetGammaSeries(fA,fX);\n"
     109             : "}\n";
     110           0 : std::string GetGammaDistDecl = "double GetGammaDist( double fX, double "
     111             : "fAlpha, double fLambda );\n";
     112           0 : std::string GetGammaDist =
     113             : "double GetGammaDist( double fX, double fAlpha, double fLambda )\n"
     114             : "{\n"
     115             : "    if (fX <= 0.0)\n"
     116             : "        return 0.0;\n"
     117             : "    else\n"
     118             : "        return GetLowRegIGamma( fAlpha, fX / fLambda);\n"
     119             : "}\n";
     120           0 : std::string GetGammaDistPDFDecl =  "double GetGammaDistPDF( double fX"
     121             : ", double fAlpha, double fLambda );\n";
     122           0 : std::string GetGammaDistPDF =
     123             : "double GetGammaDistPDF( double fX, double fAlpha, double fLambda )\n"
     124             : "{\n"
     125             : "    if (fX < 0.0)\n"
     126             : "        return 0.0;\n"
     127             : "    else if (fX == 0)\n"
     128             : "    {\n"
     129             : "        if (fAlpha < 1.0)\n"
     130             : "        {\n"
     131             : "            return HUGE_VAL;\n"
     132             : "        }\n"
     133             : "        else if (fAlpha == 1)\n"
     134             : "        {\n"
     135             : "            return (1.0 / fLambda);\n"
     136             : "        }\n"
     137             : "        else\n"
     138             : "        {\n"
     139             : "            return 0.0;\n"
     140             : "        }\n"
     141             : "    }\n"
     142             : "    else\n"
     143             : "    {\n"
     144             : "        double fXr = fX / fLambda;\n"
     145             : "        if (fXr > 1.0)\n"
     146             : "        {\n"
     147             : "            if (log(fXr) * (fAlpha-1.0) < fLogDblMax &&"
     148             : "fAlpha < fMaxGammaArgument)\n"
     149             : "            {\n"
     150             : "                return pow( fXr, fAlpha-1.0) * exp(-fXr) / "
     151             : "fLambda / tgamma(fAlpha);\n"
     152             : "            }\n"
     153             : "            else\n"
     154             : "            {\n"
     155             : "                return exp( (fAlpha-1.0) * log(fXr) - fXr - "
     156             : "log(fLambda) - lgamma(fAlpha));\n"
     157             : "            }\n"
     158             : "        }\n"
     159             : "        else\n"
     160             : "        {\n"
     161             : "            if (fAlpha<fMaxGammaArgument)\n"
     162             : "            {\n"
     163             : "                return pow( fXr, fAlpha-1.0) * exp(-fXr) / "
     164             : "fLambda / tgamma(fAlpha);\n"
     165             : "            }\n"
     166             : "            else\n"
     167             : "            {\n"
     168             : "                return pow( fXr, fAlpha-1.0) * exp(-fXr) / "
     169             : "fLambda / exp( lgamma(fAlpha));\n"
     170             : "            }\n"
     171             : "        }\n"
     172             : "    }\n"
     173             : "}\n";
     174           0 : std::string GetBetaDistDecl =
     175             : "double GetBetaDist(double fXin, double fAlpha, double fBeta);\n";
     176           0 : std::string GetBetaDist =
     177             : "double GetBetaDist(double fXin, double fAlpha, double fBeta)\n"
     178             : "{\n"
     179             : "    if (fXin <= 0.0)\n"
     180             : "        return 0.0;\n"
     181             : "    if (fXin >= 1.0)\n"
     182             : "        return 1.0;\n"
     183             : "    if (fBeta == 1.0)\n"
     184             : "        return pow(fXin, fAlpha);\n"
     185             : "    if (fAlpha == 1.0)\n"
     186             : "        return -expm1(fBeta * log1p(-fXin));\n"
     187             : "    double fResult;\n"
     188             : "    double fY = (0.5-fXin)+0.5;\n"
     189             : "    double flnY = log1p(-fXin);\n"
     190             : "    double fX = fXin;\n"
     191             : "    double flnX = log(fXin);\n"
     192             : "    double fA = fAlpha;\n"
     193             : "    double fB = fBeta;\n"
     194             : "    bool bReflect = fXin > fAlpha*pow((fAlpha+fBeta),-1.0);\n"
     195             : "    if (bReflect)\n"
     196             : "    {\n"
     197             : "        fA = fBeta;\n"
     198             : "        fB = fAlpha;\n"
     199             : "        fX = fY;\n"
     200             : "        fY = fXin;\n"
     201             : "        flnX = flnY;\n"
     202             : "        flnY = log(fXin);\n"
     203             : "    }\n"
     204             : "    fResult = lcl_GetBetaHelperContFrac(fX,fA,fB)*pow(fA,-1.0);\n"
     205             : "    double fP = fA*pow((fA+fB),-1.0);\n"
     206             : "    double fQ = fB*pow((fA+fB),-1.0);\n"
     207             : "    if (fA > 1.0 && fB > 1.0 && fP < 0.97 && fQ < 0.97)\n"
     208             : "        fResult *= GetBetaDistPDF(fX,fA,fB)*fX*fY;\n"
     209             : "    else\n"
     210             : "        fResult *= pow(exp(1.0),(fA*flnX + fB*flnY - GetLogBeta(fA,fB)));\n"
     211             : "    if (bReflect)\n"
     212             : "        fResult = 0.5 - fResult + 0.5;\n"
     213             : "    if (fResult > 1.0)\n"
     214             : "        fResult = 1.0;\n"
     215             : "    if (fResult < 0.0)\n"
     216             : "        fResult = 0.0;\n"
     217             : "    return fResult;\n"
     218             : "}\n";
     219             : 
     220           0 : std::string GetFDistDecl =
     221             :     "double GetFDist(double x, double fF1, double fF2);\n";
     222           0 : std::string GetFDist =
     223             : "double GetFDist(double x, double fF1, double fF2)\n"
     224             : "{\n"
     225             : "    double arg = fF2*pow((fF2+fF1*x),-1.0);\n"
     226             : "    double alpha = fF2*pow(2.0,-1.0);\n"
     227             : "    double beta = fF1*pow(2.0,-1.0);\n"
     228             : "    return (GetBetaDist(arg, alpha, beta));\n"
     229             : "}\n";
     230           0 : std::string GetGammaInvValueDecl = "double"
     231             : " GetGammaInvValue(double fAlpha,double fBeta,double fX1 );\n";
     232           0 : std::string GetGammaInvValue =
     233             : "double GetGammaInvValue(double fAlpha,double fBeta,double fX1 )\n"
     234             : "{\n"
     235             : "    if (fX1 <= 0.0)\n"
     236             : "        return 0.0;\n"
     237             : "    else\n"
     238             : "    {\n"
     239             : "        double fX=fX1*pow(fBeta,-1.0);\n"
     240             : "        double fLnFactor = fAlpha * log(fX) - fX - lgamma(fAlpha);\n"
     241             : "        double fFactor = exp(fLnFactor);\n"
     242             : "        if (fX>fAlpha+1.0)\n"
     243             : "            return 1.0 - fFactor * GetGammaContFraction(fAlpha,fX);\n"
     244             : "        else\n"
     245             : "            return fFactor * GetGammaSeries(fAlpha,fX);\n"
     246             : "    }\n"
     247             : "}\n";
     248           0 : std::string GetFInvValueDecl = "double GetFInvValue(double fF1,double fF2"
     249             : ",double fX1 );";
     250           0 : std::string GetFInvValue =
     251             : "double GetFInvValue(double fF1,double fF2,double fX1 )\n"
     252             : "{\n"
     253             : "    double arg = fF2*pow((fF2+fF1*fX1),-1.0);\n"
     254             : "    double alpha = fF2*pow(2.0,-1.0);\n"
     255             : "    double beta = fF1*pow(2.0,-1.0);\n"
     256             : "    double fXin,fAlpha,fBeta;\n"
     257             : "        fXin=arg;fAlpha=alpha;fBeta=beta;\n"
     258             : "    if (fXin <= 0.0)\n"
     259             : "        return 0.0;\n"
     260             : "    if (fXin >= 1.0)\n"
     261             : "        return 1.0;\n"
     262             : "    if (fBeta == 1.0)\n"
     263             : "        return pow(fXin, fAlpha);\n"
     264             : "    if (fAlpha == 1.0)\n"
     265             : "        return -expm1(fBeta * log1p(-fXin));\n"
     266             : "    double fResult;\n"
     267             : "    double fY = (0.5-fXin)+0.5;\n"
     268             : "    double flnY = log1p(-fXin);\n"
     269             : "    double fX = fXin;\n"
     270             : "    double flnX = log(fXin);\n"
     271             : "    double fA = fAlpha;\n"
     272             : "    double fB = fBeta;\n"
     273             : "    bool bReflect = fXin > fAlpha*pow((fAlpha+fBeta),-1.0);\n"
     274             : "    if (bReflect)\n"
     275             : "    {\n"
     276             : "        fA = fBeta;\n"
     277             : "        fB = fAlpha;\n"
     278             : "        fX = fY;\n"
     279             : "        fY = fXin;\n"
     280             : "        flnX = flnY;\n"
     281             : "        flnY = log(fXin);\n"
     282             : "    }\n"
     283             : "    fResult = lcl_GetBetaHelperContFrac(fX,fA,fB);\n"
     284             : "    fResult = fResult*pow(fA,-1.0);\n"
     285             : "    double fP = fA*pow((fA+fB),-1.0);\n"
     286             : "    double fQ = fB*pow((fA+fB),-1.0);\n"
     287             : "    double fTemp;\n"
     288             : "    if (fA > 1.0 && fB > 1.0 && fP < 0.97 && fQ < 0.97)\n"
     289             : "        fTemp = GetBetaDistPDF(fX,fA,fB)*fX*fY;\n"
     290             : "    else\n"
     291             : "        fTemp = exp(fA*flnX + fB*flnY - GetLogBeta(fA,fB));\n"
     292             : "    fResult *= fTemp;\n"
     293             : "    if (bReflect)\n"
     294             : "        fResult = 0.5 - fResult + 0.5;\n"
     295             : "    if (fResult > 1.0)\n"
     296             : "        fResult = 1.0;\n"
     297             : "    if (fResult < 0.0)\n"
     298             : "        fResult = 0.0;\n"
     299             : "    return fResult;\n"
     300             : "}\n";
     301           0 : std::string GetBinomDistPMFDecl =
     302             :     "double GetBinomDistPMF(double x, double n, double p);";
     303           0 : std::string GetBinomDistPMF =
     304             : "double GetBinomDistPMF(double x, double n, double p)\n"
     305             : "{\n"
     306             : "   double q = (0.5 - p) + 0.5;\n"
     307             : "   double fFactor = pow(q, n);\n"
     308             : "   if (fFactor <= Min)\n"
     309             : "   {\n"
     310             : "       fFactor = pow(p, n);\n"
     311             : "       if (fFactor <= Min)\n"
     312             : "           return GetBetaDistPDF(p, x + 1.0, n - x + 1.0)*pow((n + 1.0),-1.0);\n"
     313             : "       else\n"
     314             : "       {\n"
     315             : "           uint max = (uint)(n - x);\n"
     316             : "           for (uint i = 0; i < max && fFactor > 0.0; ++i)\n"
     317             : "               fFactor *= (n - i)*pow((i + 1),-1.0)*q*pow(p,-1.0);\n"
     318             : "           return fFactor;\n"
     319             : "       }\n"
     320             : "   }\n"
     321             : "   else\n"
     322             : "   {\n"
     323             : "       uint max = (uint)x;\n"
     324             : "       for (uint i = 0; i < max && fFactor > 0.0; ++i)\n"
     325             : "           fFactor *= (n - i)*pow((i + 1),-1.0)*p*pow(q,-1.0);\n"
     326             : "       return fFactor;\n"
     327             : "   }\n"
     328             : "}\n";
     329             : 
     330             : 
     331           0 : std::string lcl_GetBinomDistRangeDecl =
     332             :     "double lcl_GetBinomDistRange(double n, \n"
     333             : "double xs, double xe, double fFactor, double p, double q);";
     334           0 : std::string lcl_GetBinomDistRange=
     335             : "double lcl_GetBinomDistRange(double n, double xs, double xe,\n"
     336             : "   double fFactor, double p, double q)\n"
     337             : "{\n"
     338             : "   uint i;\n"
     339             : "   double fSum;\n"
     340             : "   uint nXs = (uint)xs;\n"
     341             : "   for (i = 1; i <= nXs && fFactor > 0.0; ++i)\n"
     342             : "       fFactor *= (n - i + 1)*pow(i,-1.0)*p*pow(q,-1.0);\n"
     343             : "   fSum = fFactor;\n"
     344             : "   uint nXe =(uint)xe;\n"
     345             : "   for (i = nXs + 1; i <= nXe && fFactor > 0.0; ++i)\n"
     346             : "   {\n"
     347             : "       fFactor *= (n - i + 1)*pow(i,-1.0)*p*pow(q,-1.0);\n"
     348             : "       fSum += fFactor;\n"
     349             : "   }\n"
     350             : "   return (fSum > 1.0) ? 1.0 : fSum;\n"
     351             : "}\n";
     352             : 
     353           0 : std::string GetLogGammaDecl = "double GetLogGamma(double fZ);\n";
     354           0 : std::string GetLogGamma =
     355             : "double GetLogGamma(double fZ)\n"
     356             : "{\n"
     357             : "   if (fZ >= fMaxGammaArgument)\n"
     358             : "       return lcl_GetLogGammaHelper(fZ);\n"
     359             : "   if (fZ >= 1.0)\n"
     360             : "       return log(lcl_GetGammaHelper(fZ));\n"
     361             : "   if (fZ >= 0.5)\n"
     362             : "       return log( lcl_GetGammaHelper(fZ+1) *pow(fZ,-1.0));\n"
     363             : "   return lcl_GetLogGammaHelper(fZ+2) - log(fZ+1) - log(fZ);\n"
     364             : "}\n";
     365             : 
     366             : 
     367           0 : std::string GetChiDistDecl = "double GetChiDist(double fX, double fDF);\n";
     368           0 : std::string GetChiDist =
     369             : "double GetChiDist(double fX, double fDF)\n"
     370             : "{\n"
     371             : "   if (fX <= 0.0)\n"
     372             : "       return  1.0;\n"
     373             : "   else\n"
     374             : "       return GetUpRegIGamma( fDF*pow(2.0,-1.0), fX*pow(2.0,-1.0));\n"
     375             : "}\n";
     376             : 
     377             : 
     378           0 : std::string GetChiSqDistCDFDecl =
     379             : "double GetChiSqDistCDF(double fX, double fDF);\n";
     380           0 : std::string GetChiSqDistCDF =
     381             : "double GetChiSqDistCDF(double fX, double fDF)\n"
     382             : "{\n"
     383             : "   if (fX <= 0.0)\n"
     384             : "       return 0.0;"
     385             : "   else\n"
     386             : "       return GetLowRegIGamma( fDF*pow(2.0,-1.0), fX*pow(2.0,-1.0));\n"
     387             : "}\n";
     388             : 
     389             : 
     390           0 : std::string GetChiSqDistPDFDecl=
     391             : "double GetChiSqDistPDF(double fX, double fDF);\n";
     392           0 : std::string GetChiSqDistPDF =
     393             : "double GetChiSqDistPDF(double fX, double fDF)\n"
     394             : "{\n"
     395             : "   double fValue;\n"
     396             : "   if (fX <= 0.0)\n"
     397             : "       return 0.0;\n"
     398             : "   if (fDF*fX > 1391000.0)\n"
     399             : "   {\n"
     400             : "       fValue = exp((0.5*fDF - 1) * log(fX*0.5) - 0.5 * fX - log(2.0)"
     401             : " - lgamma(0.5*fDF));\n"
     402             : "   }\n"
     403             : "   else\n"
     404             : "   {\n"
     405             : "       double fCount;\n"
     406             : "       if (fmod(fDF,2.0)<0.5)\n"
     407             : "       {\n"
     408             : "           fValue = 0.5;\n"
     409             : "           fCount = 2.0;\n"
     410             : "       }\n"
     411             : "       else\n"
     412             : "       {\n"
     413             : "           fValue = pow(sqrt(fX*2*F_PI),-1.0);\n"
     414             : "           fCount = 1.0;\n"
     415             : "       }\n"
     416             : "       while ( fCount < fDF)\n"
     417             : "       {\n"
     418             : "           fValue *= (fX *pow(fCount,-1.0));\n"
     419             : "           fCount += 2.0;\n"
     420             : "       }\n"
     421             : "       if (fX>=1425.0)\n"
     422             : "           fValue = exp(log(fValue)-fX*pow(2,-1.0));\n"
     423             : "       else\n"
     424             : "           fValue *= exp(-fX*pow(2,-1.0));\n"
     425             : "   }\n"
     426             : "    return fValue;\n"
     427             : "}\n";
     428             : 
     429             : 
     430           0 : std::string lcl_IterateInverseBetaInvDecl =
     431             : "static double lcl_IterateInverseBetaInv(double fp, double fAlpha, \n"
     432             : "   double fBeta, double fAx, double fBx, bool *rConvError );\n";
     433           0 : std::string lcl_IterateInverseBetaInv =
     434             : "static double lcl_IterateInverseBetaInv(double fp, double fAlpha, \n"
     435             : "   double fBeta, double fAx, double fBx, bool *rConvError )\n"
     436             : "{\n"
     437             : "   *rConvError = false;\n"
     438             : "    double fYEps = 1.0E-307;\n"
     439             : "    double fXEps = fMachEps;\n"
     440             : "   if(!(fAx < fBx))\n"
     441             : "   {\n"
     442             : "       //print error\n"
     443             : "   }\n"
     444             : "   double fAy = fp - GetBetaDist(fAx, fAlpha, fBeta);\n"
     445             : "   double fBy = fp - GetBetaDist(fBx, fAlpha, fBeta);\n"
     446             : "   double fTemp;\n"
     447             : "   unsigned short nCount;\n"
     448             : "   for (nCount = 0; nCount < 1000 && !lcl_HasChangeOfSign(fAy,fBy);"
     449             : " nCount++)\n"
     450             : "   {\n"
     451             : "       if (fabs(fAy) <= fabs(fBy))\n"
     452             : "       {\n"
     453             : "           fTemp = fAx;\n"
     454             : "           fAx += 2.0 * (fAx - fBx);\n"
     455             : "           if (fAx < 0.0)\n"
     456             : "               fAx = 0.0;\n"
     457             : "           fBx = fTemp;\n"
     458             : "           fBy = fAy;\n"
     459             : "           fAy = fp - GetBetaDist(fAx, fAlpha, fBeta);\n"
     460             : "       }\n"
     461             : "       else\n"
     462             : "       {\n"
     463             : "           fTemp = fBx;\n"
     464             : "           fBx += 2.0 * (fBx - fAx);\n"
     465             : "           fAx = fTemp;\n"
     466             : "           fAy = fBy;\n"
     467             : "           fBy = fp - GetBetaDist(fBx, fAlpha, fBeta);\n"
     468             : "       }\n"
     469             : "   }\n"
     470             : "   if (fAy == 0.0)\n"
     471             : "       return fAx;\n"
     472             : "   if (fBy == 0.0)\n"
     473             : "       return fBx;\n"
     474             : "   if (!lcl_HasChangeOfSign( fAy, fBy))\n"
     475             : "   {\n"
     476             : "       *rConvError = true;\n"
     477             : "       return 0.0;\n"
     478             : "   }\n"
     479             : "   double fPx = fAx;\n"
     480             : "   double fPy = fAy;\n"
     481             : "   double fQx = fBx;\n"
     482             : "   double fQy = fBy;\n"
     483             : "   double fRx = fAx;\n"
     484             : "   double fRy = fAy;\n"
     485             : "   double fSx = 0.5 * (fAx + fBx);\n"
     486             : "   bool bHasToInterpolate = true;\n"
     487             : "   nCount = 0;\n"
     488             : "   while ( nCount < 500 && fabs(fRy) > fYEps &&\n"
     489             : "               (fBx-fAx) > fmax( fabs(fAx), fabs(fBx)) * fXEps )\n"
     490             : "   {\n"
     491             : "       if (bHasToInterpolate)\n"
     492             : "       {\n"
     493             : "           if (fPy!=fQy && fQy!=fRy && fRy!=fPy)\n"
     494             : "           {\n"
     495             : "               fSx = fPx*fRy*fQy*pow(fRy-fPy,-1.0)*pow(fQy-fPy,-1.0)\n"
     496             : "                   + fRx*fQy*fPy*pow(fQy-fRy,-1.0)*pow(fPy-fRy,-1.0)\n"
     497             : "                   + fQx*fPy*fRy*pow(fPy-fQy,-1.0)*pow(fRy-fQy,-1.0);\n"
     498             : "               bHasToInterpolate = (fAx < fSx) && (fSx < fBx);\n"
     499             : "           }\n"
     500             : "           else\n"
     501             : "               bHasToInterpolate = false;\n"
     502             : "       }\n"
     503             : "       if(!bHasToInterpolate)\n"
     504             : "       {\n"
     505             : "           fSx = 0.5 * (fAx + fBx);\n"
     506             : "           fPx = fAx; fPy = fAy;\n"
     507             : "           fQx = fBx; fQy = fBy;\n"
     508             : "           bHasToInterpolate = true;\n"
     509             : "       }\n"
     510             : "       fPx = fQx; fQx = fRx; fRx = fSx;\n"
     511             : "       fPy = fQy; fQy = fRy; fRy = fp - GetBetaDist(fSx, fAlpha, fBeta);\n"
     512             : "       if (lcl_HasChangeOfSign( fAy, fRy))\n"
     513             : "       {\n"
     514             : "           fBx = fRx; fBy = fRy;\n"
     515             : "       }\n"
     516             : "       else\n"
     517             : "       {\n"
     518             : "           fAx = fRx; fAy = fRy;\n"
     519             : "       }\n"
     520             : "       bHasToInterpolate = bHasToInterpolate && (fabs(fRy) *"
     521             : " 2.0 <= fabs(fQy));\n"
     522             : "       ++nCount;\n"
     523             : "   }\n"
     524             : "   return fRx;\n"
     525             : "}\n";
     526             : 
     527             : 
     528           0 : std::string lcl_IterateInverseChiInvDecl =
     529             : "static double lcl_IterateInverseChiInv"
     530             : "(double fp, double fdf, double fAx, double fBx, bool *rConvError);\n";
     531           0 : std::string lcl_IterateInverseChiInv =
     532             : "static double lcl_IterateInverseChiInv"
     533             : "(double fp, double fdf, double fAx, double fBx, bool *rConvError)\n"
     534             : "{\n"
     535             : "   *rConvError = false;\n"
     536             : "    double fYEps = 1.0E-307;\n"
     537             : "    double fXEps = fMachEps;\n"
     538             : "   if(!(fAx < fBx))\n"
     539             : "   {\n"
     540             : "       //print error\n"
     541             : "   }"
     542             : "   double fAy = fp - GetChiDist(fAx, fdf);\n"
     543             : "   double fBy = fp - GetChiDist(fBx, fdf);\n"
     544             : "   double fTemp;\n"
     545             : "   unsigned short nCount;\n"
     546             : "   for (nCount = 0; nCount < 1000 && "
     547             : "!lcl_HasChangeOfSign(fAy,fBy); nCount++)\n"
     548             : "   {\n"
     549             : "       if (fabs(fAy) <= fabs(fBy))\n"
     550             : "       {\n"
     551             : "           fTemp = fAx;\n"
     552             : "           fAx += 2.0 * (fAx - fBx);\n"
     553             : "           if (fAx < 0.0)\n"
     554             : "               fAx = 0.0;\n"
     555             : "           fBx = fTemp;\n"
     556             : "           fBy = fAy;\n"
     557             : "           fAy = fp - GetChiDist(fAx, fdf);\n"
     558             : "       }\n"
     559             : "       else\n"
     560             : "       {\n"
     561             : "           fTemp = fBx;\n"
     562             : "           fBx += 2.0 * (fBx - fAx);\n"
     563             : "           fAx = fTemp;\n"
     564             : "           fAy = fBy;\n"
     565             : "           fBy = fp - GetChiDist(fBx, fdf);\n"
     566             : "       }\n"
     567             : "   }\n"
     568             : "   if (fAy == 0.0)\n"
     569             : "       return fAx;\n"
     570             : "   if (fBy == 0.0)\n"
     571             : "       return fBx;\n"
     572             : "   if (!lcl_HasChangeOfSign( fAy, fBy))\n"
     573             : "   {\n"
     574             : "       *rConvError = true;\n"
     575             : "       return 0.0;\n"
     576             : "   }\n"
     577             : "   double fPx = fAx;\n"
     578             : "   double fPy = fAy;\n"
     579             : "   double fQx = fBx;\n"
     580             : "   double fQy = fBy;\n"
     581             : "   double fRx = fAx;\n"
     582             : "   double fRy = fAy;\n"
     583             : "   double fSx = 0.5 * (fAx + fBx);\n"
     584             : "   bool bHasToInterpolate = true;\n"
     585             : "   nCount = 0;\n"
     586             : "   while ( nCount < 500 && fabs(fRy) > fYEps &&\n"
     587             : "       (fBx-fAx) > fmax( fabs(fAx), fabs(fBx)) * fXEps )\n"
     588             : "   {\n"
     589             : "       if (bHasToInterpolate)\n"
     590             : "       {\n"
     591             : "           if (fPy!=fQy && fQy!=fRy && fRy!=fPy)\n"
     592             : "           {\n"
     593             : "               fSx = fPx * fRy * fQy*pow(fRy-fPy,-1.0)*pow(fQy-fPy,-1.0)\n"
     594             : "                   + fRx * fQy * fPy*pow(fQy-fRy,-1.0)*pow(fPy-fRy,-1.0)\n"
     595             : "                   + fQx * fPy * fRy*pow(fPy-fQy,-1.0)*pow(fRy-fQy,-1.0);\n"
     596             : "               bHasToInterpolate = (fAx < fSx) && (fSx < fBx);\n"
     597             : "           }\n"
     598             : "           else\n"
     599             : "               bHasToInterpolate = false;\n"
     600             : "       }\n"
     601             : "       if(!bHasToInterpolate)\n"
     602             : "       {\n"
     603             : "           fSx = 0.5 * (fAx + fBx);\n"
     604             : "           fPx = fAx; fPy = fAy;\n"
     605             : "           fQx = fBx; fQy = fBy;\n"
     606             : "           bHasToInterpolate = true;\n"
     607             : "       }\n"
     608             : "       fPx = fQx; fQx = fRx; fRx = fSx;\n"
     609             : "       fPy = fQy; fQy = fRy; fRy = fp - GetChiDist(fSx, fdf);\n"
     610             : "       if (lcl_HasChangeOfSign( fAy, fRy))\n"
     611             : "       {\n"
     612             : "           fBx = fRx; fBy = fRy;\n"
     613             : "       }\n"
     614             : "       else\n"
     615             : "       {\n"
     616             : "           fAx = fRx; fAy = fRy;\n"
     617             : "       }\n"
     618             : "       bHasToInterpolate = bHasToInterpolate && (fabs(fRy)"
     619             : " * 2.0 <= fabs(fQy));\n"
     620             : "       ++nCount;\n"
     621             : "   }\n"
     622             : "   return fRx;\n"
     623             : "}\n";
     624             : 
     625           0 : std::string lcl_IterateInverseChiSQInvDecl =
     626             : "static double lcl_IterateInverseChiSQInv( double fp, double fdf, \n"
     627             : "   double fAx, double fBx, bool *rConvError );\n";
     628           0 : std::string lcl_IterateInverseChiSQInv =
     629             : "static double lcl_IterateInverseChiSQInv( double fp, double fdf, \n"
     630             : "   double fAx, double fBx, bool *rConvError )\n"
     631             : "{\n"
     632             : "   *rConvError = false;\n"
     633             : "    double fYEps = 1.0E-307;\n"
     634             : "    double fXEps = fMachEps;\n"
     635             : 
     636             : "    if(!(fAx < fBx))\n"
     637             : "    {\n"
     638             : "        //print error\n"
     639             : "    }\n"
     640             : "    double fAy = fp - GetChiSqDistCDF(fAx, fdf);\n"
     641             : "    double fBy = fp - GetChiSqDistCDF(fBx, fdf);\n"
     642             : "    double fTemp;\n"
     643             : "    unsigned short nCount;\n"
     644             : "    for (nCount = 0; nCount < 1000 && !lcl_HasChangeOfSign(fAy,fBy);"
     645             : " nCount++)\n"
     646             : "    {\n"
     647             : "       if (fabs(fAy) <= fabs(fBy))\n"
     648             : "       {\n"
     649             : "           fTemp = fAx;\n"
     650             : "           fAx += 2.0 * (fAx - fBx);\n"
     651             : "           if (fAx < 0.0)\n"
     652             : "               fAx = 0.0;\n"
     653             : "           fBx = fTemp;\n"
     654             : "           fBy = fAy;\n"
     655             : "           fAy = fp - GetChiSqDistCDF(fAx, fdf);\n"
     656             : "       }\n"
     657             : "       else\n"
     658             : "       {\n"
     659             : "           fTemp = fBx;\n"
     660             : "           fBx += 2.0 * (fBx - fAx);\n"
     661             : "           fAx = fTemp;\n"
     662             : "           fAy = fBy;\n"
     663             : "           fBy = fp - GetChiSqDistCDF(fBx, fdf);\n"
     664             : "       }\n"
     665             : "   }\n"
     666             : "   if (fAy == 0.0)\n"
     667             : "       return fAx;\n"
     668             : "   if (fBy == 0.0)\n"
     669             : "       return fBx;\n"
     670             : "   if (!lcl_HasChangeOfSign( fAy, fBy))\n"
     671             : "   {\n"
     672             : "       *rConvError = true;\n"
     673             : "       return 0.0;\n"
     674             : "   }\n"
     675             : "   double fPx = fAx;\n"
     676             : "   double fPy = fAy;\n"
     677             : "   double fQx = fBx;\n"
     678             : "   double fQy = fBy;\n"
     679             : "   double fRx = fAx;\n"
     680             : "   double fRy = fAy;\n"
     681             : "   double fSx = 0.5 * (fAx + fBx);\n"
     682             : "   bool bHasToInterpolate = true;\n"
     683             : "   nCount = 0;\n"
     684             : "   while ( nCount < 500 && fabs(fRy) > fYEps &&\n"
     685             : "       (fBx-fAx) > fmax( fabs(fAx), fabs(fBx)) * fXEps )\n"
     686             : "   {\n"
     687             : "       if (bHasToInterpolate)\n"
     688             : "       {\n"
     689             : "           if (fPy!=fQy && fQy!=fRy && fRy!=fPy)\n"
     690             : "           {\n"
     691             : "               fSx = fPx * fRy * fQy / (fRy-fPy) / (fQy-fPy)\n"
     692             : "                   + fRx * fQy * fPy / (fQy-fRy) / (fPy-fRy)\n"
     693             : "                   + fQx * fPy * fRy / (fPy-fQy) / (fRy-fQy);\n"
     694             : "               bHasToInterpolate = (fAx < fSx) && (fSx < fBx);\n"
     695             : "           }\n"
     696             : "           else\n"
     697             : "               bHasToInterpolate = false;\n"
     698             : "       }\n"
     699             : "       if(!bHasToInterpolate)\n"
     700             : "       {\n"
     701             : "           fSx = 0.5 * (fAx + fBx);\n"
     702             : "           fPx = fAx; fPy = fAy;\n"
     703             : "           fQx = fBx; fQy = fBy;\n"
     704             : "           bHasToInterpolate = true;\n"
     705             : "       }\n"
     706             : "       fPx = fQx; fQx = fRx; fRx = fSx;\n"
     707             : "       fPy = fQy; fQy = fRy; fRy = fp - GetChiSqDistCDF(fSx, fdf);\n"
     708             : "       if (lcl_HasChangeOfSign( fAy, fRy))\n"
     709             : "       {\n"
     710             : "           fBx = fRx; fBy = fRy;\n"
     711             : "       }\n"
     712             : "       else\n"
     713             : "       {\n"
     714             : "           fAx = fRx; fAy = fRy;\n"
     715             : "       }\n"
     716             : "       bHasToInterpolate = bHasToInterpolate && (fabs(fRy) * 2.0"
     717             : " <= fabs(fQy));\n"
     718             : "       ++nCount;\n"
     719             : "   }\n"
     720             : "   return fRx;\n"
     721             : "}\n";
     722             : 
     723           0 : std::string gaussinvDecl = "double gaussinv(double x);\n";
     724           0 : std::string gaussinv =
     725             : "double gaussinv(double x)\n"
     726             : "{\n"
     727             : "    double q,t,z;\n"
     728             : "    q=x-0.5;\n"
     729             : "    if(fabs(q)<=.425)\n"
     730             : "    {\n"
     731             : "        t=0.180625-q*q;\n"
     732             : "        z=\n"
     733             : "            q*\n"
     734             : "            (\n"
     735             : "            (\n"
     736             : "            (\n"
     737             : "            (\n"
     738             : "            (\n"
     739             : "            (\n"
     740             : "            (\n"
     741             : "            t*2509.0809287301226727+33430.575583588128105\n"
     742             : "            )\n"
     743             : "            *t+67265.770927008700853\n"
     744             : "            )\n"
     745             : "            *t+45921.953931549871457\n"
     746             : "            )\n"
     747             : "            *t+13731.693765509461125\n"
     748             : "            )\n"
     749             : "            *t+1971.5909503065514427\n"
     750             : "            )\n"
     751             : "            *t+133.14166789178437745\n"
     752             : "            )\n"
     753             : "            *t+3.387132872796366608\n"
     754             : "            )\n"
     755             : "            *pow\n"
     756             : "            (\n"
     757             : "            (\n"
     758             : "            (\n"
     759             : "            (\n"
     760             : "            (\n"
     761             : "            (\n"
     762             : "            (\n"
     763             : "            t*5226.495278852854561+28729.085735721942674\n"
     764             : "            )\n"
     765             : "            *t+39307.89580009271061\n"
     766             : "            )\n"
     767             : "            *t+21213.794301586595867\n"
     768             : "            )\n"
     769             : "            *t+5394.1960214247511077\n"
     770             : "            )\n"
     771             : "            *t+687.1870074920579083\n"
     772             : "            )\n"
     773             : "            *t+42.313330701600911252\n"
     774             : "            )\n"
     775             : "            *t+1.0\n"
     776             : "            , -1.0);\n"
     777             : "    }\n"
     778             : "    else\n"
     779             : "    {\n"
     780             : "        if(q>0) t=1-x;\n"
     781             : "        else        t=x;\n"
     782             : "        t=sqrt(-log(t));\n"
     783             : "        if(t<=5.0)\n"
     784             : "        {\n"
     785             : "            t+=-1.6;\n"
     786             : "            z=\n"
     787             : "                (\n"
     788             : "                (\n"
     789             : "                (\n"
     790             : "                (\n"
     791             : "                (\n"
     792             : "                (\n"
     793             : "                (\n"
     794             : "                t*7.7454501427834140764e-4+0.0227238449892691845833\n"
     795             : "                )\n"
     796             : "                *t+0.24178072517745061177\n"
     797             : "                )\n"
     798             : "                *t+1.27045825245236838258\n"
     799             : "                )\n"
     800             : "                *t+3.64784832476320460504\n"
     801             : "                )\n"
     802             : "                *t+5.7694972214606914055\n"
     803             : "                )\n"
     804             : "                *t+4.6303378461565452959\n"
     805             : "                )\n"
     806             : "                *t+1.42343711074968357734\n"
     807             : "                )\n"
     808             : "                *pow\n"
     809             : "                (\n"
     810             : "                (\n"
     811             : "                (\n"
     812             : "                (\n"
     813             : "                (\n"
     814             : "                (\n"
     815             : "                (\n"
     816             : "                t*1.05075007164441684324e-9+5.475938084995344946e-4\n"
     817             : "                )\n"
     818             : "                *t+0.0151986665636164571966\n"
     819             : "                )\n"
     820             : "                *t+0.14810397642748007459\n"
     821             : "                )\n"
     822             : "                *t+0.68976733498510000455\n"
     823             : "                )\n"
     824             : "                *t+1.6763848301838038494\n"
     825             : "                )\n"
     826             : "                *t+2.05319162663775882187\n"
     827             : "                )\n"
     828             : "                *t+1.0\n"
     829             : "                , -1.0);\n"
     830             : "        }\n"
     831             : "        else\n"
     832             : "        {\n"
     833             : "            t+=-5.0;\n"
     834             : "            z=\n"
     835             : "                (\n"
     836             : "                (\n"
     837             : "                (\n"
     838             : "                (\n"
     839             : "                (\n"
     840             : "                (\n"
     841             : "                (\n"
     842             : "                t*2.01033439929228813265e-7+2.71155556874348757815e-5\n"
     843             : "                )\n"
     844             : "                *t+0.0012426609473880784386\n"
     845             : "                )\n"
     846             : "                *t+0.026532189526576123093\n"
     847             : "                )\n"
     848             : "                *t+0.29656057182850489123\n"
     849             : "                )\n"
     850             : "                *t+1.7848265399172913358\n"
     851             : "                )\n"
     852             : "                *t+5.4637849111641143699\n"
     853             : "                )\n"
     854             : "                *t+6.6579046435011037772\n"
     855             : "                )\n"
     856             : "                *pow\n"
     857             : "                (\n"
     858             : "                (\n"
     859             : "                (\n"
     860             : "                (\n"
     861             : "                (\n"
     862             : "                (\n"
     863             : "                (\n"
     864             : "                t*2.04426310338993978564e-15+1.4215117583164458887e-7\n"
     865             : "                )\n"
     866             : "                *t+1.8463183175100546818e-5\n"
     867             : "                )\n"
     868             : "                *t+7.868691311456132591e-4\n"
     869             : "                )\n"
     870             : "                *t+0.0148753612908506148525\n"
     871             : "                )\n"
     872             : "                *t+0.13692988092273580531\n"
     873             : "                )\n"
     874             : "                *t+0.59983220655588793769\n"
     875             : "                )\n"
     876             : "                *t+1.0\n"
     877             : "                , -1.0);\n"
     878             : "        }\n"
     879             : "        if(q<0.0) z=-z;\n"
     880             : "    }\n"
     881             : "    return z;\n"
     882             : "}\n";
     883             : 
     884           0 : std::string lcl_GetLogGammaHelperDecl=
     885             : "static double lcl_GetLogGammaHelper(double fZ);\n";
     886           0 : std::string lcl_GetLogGammaHelper =
     887             : "static double lcl_GetLogGammaHelper(double fZ)\n"
     888             : "{\n"
     889             : "    double fg = 6.024680040776729583740234375;\n"
     890             : "   double fZgHelp = fZ + fg - 0.5;\n"
     891             : "   return log( lcl_getLanczosSum(fZ)) + (fZ-0.5) * log(fZgHelp) - fZgHelp;\n"
     892             : "}\n";
     893           0 : std::string lcl_GetGammaHelperDecl=
     894             : "static double lcl_GetGammaHelper(double fZ);\n";
     895           0 : std::string lcl_GetGammaHelper =
     896             : "static double lcl_GetGammaHelper(double fZ)\n"
     897             : "{\n"
     898             : "   double fGamma = lcl_getLanczosSum(fZ);\n"
     899             : "   double fg = 6.024680040776729583740234375;\n"
     900             : "   double fZgHelp = fZ + fg - 0.5;\n"
     901             : "   double fHalfpower = pow( fZgHelp, fZ*pow(2,-1.0) - 0.25);\n"
     902             : "   fGamma *= fHalfpower;\n"
     903             : "   fGamma = fGamma*pow(exp(fZgHelp),-1.0);\n"
     904             : "   fGamma *= fHalfpower;\n"
     905             : "   fGamma = 120.4;\n"
     906             : "   if (fZ <= 20.0 && fZ == (int)fZ)\n"
     907             : "   {\n"
     908             : "     fGamma = (int)(fGamma+0.5);\n"
     909             : "   }\n"
     910             : "   return fGamma;\n"
     911             : "}\n";
     912           0 : std::string lcl_getLanczosSumDecl=
     913             : "static double lcl_getLanczosSum(double fZ);\n";
     914           0 : std::string lcl_getLanczosSum =
     915             : "static double lcl_getLanczosSum(double fZ)          \n"
     916             : "{                                                   \n"
     917             : "    double fNum[13] ={                        \n"
     918             : "        23531376880.41075968857200767445163675473,  \n"
     919             : "        42919803642.64909876895789904700198885093,  \n"
     920             : "        35711959237.35566804944018545154716670596,  \n"
     921             : "        17921034426.03720969991975575445893111267,  \n"
     922             : "        6039542586.35202800506429164430729792107,   \n"
     923             : "        1439720407.311721673663223072794912393972,  \n"
     924             : "        248874557.8620541565114603864132294232163,  \n"
     925             : "        31426415.58540019438061423162831820536287,  \n"
     926             : "        2876370.628935372441225409051620849613599,  \n"
     927             : "        186056.2653952234950402949897160456992822,  \n"
     928             : "        8071.672002365816210638002902272250613822,  \n"
     929             : "        210.8242777515793458725097339207133627117,  \n"
     930             : "        2.506628274631000270164908177133837338626   \n"
     931             : "        };                                          \n"
     932             : "    double fDenom[13] = {                     \n"
     933             : "        0,\n"
     934             : "        39916800,\n"
     935             : "        120543840,\n"
     936             : "        150917976,\n"
     937             : "        105258076,\n"
     938             : "        45995730,\n"
     939             : "        13339535,\n"
     940             : "        2637558,\n"
     941             : "        357423,\n"
     942             : "        32670,\n"
     943             : "        1925,\n"
     944             : "        66,\n"
     945             : "        1\n"
     946             : "        };\n"
     947             : "    double fSumNum;\n"
     948             : "    double fSumDenom;\n"
     949             : "    int nI;\n"
     950             : "    if (fZ<=1.0)\n"
     951             : "    {\n"
     952             : "        fSumNum = fNum[12];\n"
     953             : "        fSumDenom = fDenom[12];\n"
     954             : "        nI = 11;\n"
     955             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     956             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     957             : "        nI = 10;\n"
     958             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     959             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     960             : "        nI = 9;\n"
     961             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     962             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     963             : "        nI = 8;\n"
     964             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     965             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     966             : "        nI = 7;\n"
     967             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     968             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     969             : "        nI = 6;\n"
     970             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     971             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     972             : "        nI = 5;\n"
     973             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     974             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     975             : "        nI = 4;\n"
     976             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     977             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     978             : "        nI = 3;\n"
     979             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     980             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     981             : "        nI = 2;\n"
     982             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     983             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     984             : "        nI = 1;\n"
     985             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     986             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     987             : "        nI = 0;\n"
     988             : "        fSumNum = fSumNum*fZ+fNum[nI];\n"
     989             : "        fSumDenom = fSumDenom*fZ+fDenom[nI];\n"
     990             : "    }\n"
     991             : "    if (fZ>1.0)\n"
     992             : "    {\n"
     993             : "        double fZInv = pow(fZ,-1.0);\n"
     994             : "        fSumNum = fNum[0];\n"
     995             : "        fSumDenom = fDenom[0];\n"
     996             : "        nI = 1;\n"
     997             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
     998             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
     999             : "        nI = 2;\n"
    1000             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1001             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1002             : "        nI = 3;\n"
    1003             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1004             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1005             : "        nI = 4;\n"
    1006             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1007             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1008             : "        nI = 5;\n"
    1009             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1010             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1011             : "        nI = 6;\n"
    1012             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1013             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1014             : "        nI = 7;\n"
    1015             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1016             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1017             : "        nI = 8;\n"
    1018             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1019             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1020             : "        nI = 9;\n"
    1021             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1022             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1023             : "        nI = 10;\n"
    1024             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1025             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1026             : "        nI = 11;\n"
    1027             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1028             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1029             : "        nI = 12;\n"
    1030             : "        fSumNum = fSumNum*fZInv+fNum[nI];\n"
    1031             : "        fSumDenom = fSumDenom*fZInv+fDenom[nI];\n"
    1032             : "     }\n"
    1033             : "     return fSumNum*pow(fSumDenom,-1.0);\n"
    1034             : "}\n";
    1035             : 
    1036           0 : std::string GetUpRegIGammaDecl=
    1037             : " double GetUpRegIGamma( double fA, double fX ) ;\n";
    1038           0 : std::string GetUpRegIGamma =
    1039             : "double GetUpRegIGamma( double fA, double fX )\n"
    1040             : "{\n"
    1041             : "    double fLnFactor= fA*log(fX)-fX-lgamma(fA);\n"
    1042             : "    double fFactor = exp(fLnFactor); \n"
    1043             : "    if (fX>fA+1.0) \n"
    1044             : "            return fFactor * GetGammaContFraction(fA,fX);\n"
    1045             : "    else \n"
    1046             : "            return 1.0 -fFactor * GetGammaSeries(fA,fX);\n"
    1047             : "}\n";
    1048             : 
    1049           0 : std::string lcl_HasChangeOfSignDecl=
    1050             : "static inline bool lcl_HasChangeOfSign( double u, double w );\n";
    1051           0 : std::string lcl_HasChangeOfSign =
    1052             : "static inline bool lcl_HasChangeOfSign( double u, double w )\n"
    1053             : "{\n"
    1054             : "    return (u < 0.0 && w > 0.0) || (u > 0.0 && w < 0.0);\n"
    1055             : "}\n";
    1056             : 
    1057           0 : std::string GetTDistDecl=" double GetTDist(double T, double fDF);\n";
    1058           0 : std::string GetTDist =
    1059             : "double GetTDist(double T, double fDF)\n"
    1060             : "{\n"
    1061             : "    return 0.5 * GetBetaDist(fDF*pow(fDF+T*T,-1.0),fDF*pow(2.0,-1.0), 0.5);\n"
    1062             : "}\n";
    1063             : 
    1064           0 : std::string GetBetaDecl=" double GetBeta(double fAlpha, double fBeta);\n";
    1065           0 : std::string GetBeta =
    1066             : "double GetBeta(double fAlpha, double fBeta)\n"
    1067             : "{\n"
    1068             : "    double fA;\n"
    1069             : "    double fB;\n"
    1070             : "    fAlpha>fBeta?(fA = fAlpha,fB = fBeta):(fA = fBeta,fB = fAlpha);\n"
    1071             : "    double fAB = fA + fB;\n"
    1072             : 
    1073             : "    if (fAB < fMaxGammaArgument)\n"
    1074             : "        return tgamma(fA)*pow(tgamma(fAB),-1.0)*tgamma(fB);\n"
    1075             : "    double fgm = 5.524680040776729583740234375;\n"
    1076             : "    double fLanczos = lcl_getLanczosSum(fA)*lcl_getLanczosSum(fB)\n"
    1077             : "        *pow(lcl_getLanczosSum(fAB),-1.0);\n"
    1078             : "    fLanczos *= sqrt(((fAB + fgm)*pow(fA + fgm,-1.0))*pow(fB + fgm,-1.0));\n"
    1079             : "    return fLanczos * pow(exp(1.0),(-fA*log1p(fB*pow(fA + fgm,-1.0)))"
    1080             : "                    - fB*log1p(fA*pow(fB + fgm,-1.0)) - fgm);\n"
    1081             : "}\n";
    1082             : 
    1083           0 : std::string GetLogBetaDecl=
    1084             : " double GetLogBeta(double fAlpha, double fBeta);\n";
    1085           0 : std::string GetLogBeta =
    1086             : "double GetLogBeta(double fAlpha, double fBeta)\n"
    1087             : "{\n"
    1088             : "    double fA;\n"
    1089             : "    double fB;\n"
    1090             : "    fAlpha>fBeta?(fA = fAlpha,fB = fBeta):(fA = fBeta,fB = fAlpha);\n"
    1091             : "    double fgm = 5.524680040776729583740234375;\n"
    1092             : 
    1093             : "    double fLanczos = lcl_getLanczosSum(fA)*lcl_getLanczosSum(fB)*\n"
    1094             : "        pow(lcl_getLanczosSum(fA + fB),-1.0);\n"
    1095             : "    double fResult= -fA *log1p(fB*pow(fA + fgm,-1.0))"
    1096             : "-fB *log1p(fA*pow(fB + fgm,-1.0))-fgm;\n"
    1097             : "    fResult += log(fLanczos)+0.5*(log(fA + fB + fgm) - log(fA + fgm)\n"
    1098             : "        - log(fB + fgm));\n"
    1099             : "    return fResult;\n"
    1100             : "}\n";
    1101             : 
    1102           0 : std::string GetBetaDistPDFDecl=
    1103             : "double GetBetaDistPDF(double fX, double fA, double fB);\n";
    1104           0 : std::string GetBetaDistPDF =
    1105             : "double GetBetaDistPDF(double fX, double fA, double fB)\n"
    1106             : "{\n"
    1107             : "    if (fA == 1.0) \n"
    1108             : "    {\n"
    1109             : "        if (fB == 1.0)\n"
    1110             : "            return 1.0;\n"
    1111             : "        if (fB == 2.0)\n"
    1112             : "            return -2.0*fX + 2.0;\n"
    1113             : "        if (fX == 1.0 && fB < 1.0)\n"
    1114             : "        {\n"
    1115             : "            return HUGE_VAL;\n"
    1116             : "        }\n"
    1117             : "        if (fX <= 0.01)\n"
    1118             : "            return fB + fB * expm1((fB-1.0) * log1p(-fX));\n"
    1119             : "        else \n"
    1120             : "            return fB * pow(0.5-fX+0.5,fB-1.0);\n"
    1121             : "    }\n"
    1122             : "    if (fB == 1.0) \n"
    1123             : "    {\n"
    1124             : "    if (fA == 2.0)\n"
    1125             : "        return fA * fX;\n"
    1126             : "        if (fX == 0.0 && fA < 1.0)\n"
    1127             : "        {\n"
    1128             : "            return HUGE_VAL;\n"
    1129             : "        }\n"
    1130             : "        return fA * pow(fX,fA-1);\n"
    1131             : "    }\n"
    1132             : "    if (fX <= 0.0)\n"
    1133             : "    {\n"
    1134             : "        if (fA < 1.0 && fX == 0.0)\n"
    1135             : "        {\n"
    1136             : "            return HUGE_VAL;\n"
    1137             : "        }\n"
    1138             : "        else\n"
    1139             : "            return 0.0;\n"
    1140             : "    }\n"
    1141             : "    if (fX >= 1.0)\n"
    1142             : "    {\n"
    1143             : "        if (fB < 1.0 && fX == 1.0)\n"
    1144             : "        {\n"
    1145             : "            return HUGE_VAL;\n"
    1146             : "        }\n"
    1147             : "        else \n"
    1148             : "        return 0.0;\n"
    1149             : "    }\n"
    1150             : "    double fLogDblMax = log( 1.79769e+308 );\n"
    1151             : "    double fLogDblMin = log( 2.22507e-308 );\n"
    1152             : "    double fLogY = (fX < 0.1) ? log1p(-fX) : log(0.5-fX+0.5);\n"
    1153             : "    double fLogX = log(fX);\n"
    1154             : "    double fAm1LogX = (fA-1.0) * fLogX;\n"
    1155             : "    double fBm1LogY = (fB-1.0) * fLogY;\n"
    1156             : "    double fLogBeta = GetLogBeta(fA,fB);\n"
    1157             : "    if (   fAm1LogX < fLogDblMax  && fAm1LogX > fLogDblMin\n"
    1158             : "        && fBm1LogY < fLogDblMax  && fBm1LogY > fLogDblMin\n"
    1159             : "        && fLogBeta < fLogDblMax  && fLogBeta > fLogDblMin\n"
    1160             : "        && fAm1LogX + fBm1LogY < fLogDblMax && fAm1LogX + fBm1LogY > \n"
    1161             : "           fLogDblMin)\n"
    1162             : "        return pow(fX,fA-1.0)*pow(0.5-fX+0.5,fB-1.0)"
    1163             : "*pow(GetBeta(fA,fB),-1.0);\n"
    1164             : "    else \n"
    1165             : "         return exp( fAm1LogX + fBm1LogY - fLogBeta);\n"
    1166             : "}\n";
    1167             : 
    1168           0 : std::string lcl_GetBetaHelperContFracDecl=
    1169             : "double lcl_GetBetaHelperContFrac(double fX, double fA, double fB);\n";
    1170           0 : std::string lcl_GetBetaHelperContFrac =
    1171             : "double lcl_GetBetaHelperContFrac(double fX, double fA, double fB)\n"
    1172             : "{   \n"
    1173             : 
    1174             : "    double a1, b1, a2, b2, fnorm, apl2m, d2m, d2m1, cfnew, cf;\n"
    1175             : "    a1 = 1.0; b1 = 1.0;\n"
    1176             : "    b2 = 1.0 - (fA+fB)*pow(fA+1.0,-1.0)*fX;\n"
    1177             : "    b2==0.0?(a2 = 0.0,fnorm = 1.0,cf = 1.0):\n"
    1178             : "        (a2 = 1.0,fnorm = pow(b2,-1.0),cf = a2*fnorm);\n"
    1179             : "    cfnew = 1.0;\n"
    1180             : "    double rm = 1.0;\n"
    1181             : "    double fMaxIter = 50000.0;\n"
    1182             : "    bool bfinished = false;\n"
    1183             : "    do\n"
    1184             : "    {\n"
    1185             : "      apl2m = fA + 2.0*rm;\n"
    1186             : "      d2m = (rm*(fB-rm))*fX*pow(apl2m*(apl2m-1.0),-1.0);\n"
    1187             : "      d2m1 = -((fA+rm)*(fA+rm+fB))*fX*pow(apl2m*(apl2m+1.0),-1.0);\n"
    1188             : "      a1 = (a2+d2m*a1)*fnorm;\n"
    1189             : "      b1 = (b2+d2m*b1)*fnorm;\n"
    1190             : "      a2 = a1 + d2m1*a2*fnorm;\n"
    1191             : "      b2 = b1 + d2m1*b2*fnorm;\n"
    1192             : "      if (b2 != 0.0) \n"
    1193             : "      {\n"
    1194             : "        fnorm = pow(b2,-1.0);\n"
    1195             : "        cfnew = a2*fnorm;\n"
    1196             : "        bfinished = (fabs(cf-cfnew) < fabs(cf)*fMachEps);\n"
    1197             : "      }\n"
    1198             : "      cf = cfnew;\n"
    1199             : "      rm += 1.0;\n"
    1200             : "     }\n"
    1201             : "    while (rm < fMaxIter && !bfinished);\n"
    1202             : "    return cf;\n"
    1203             : "}\n";
    1204             : 
    1205           0 : std::string lcl_IterateInverseDecl=
    1206             : "double lcl_IterateInverse("
    1207             : "double fAx, double fBx, bool* rConvError,double fp,double fDF );\n";
    1208           0 : std::string lcl_IterateInverse =
    1209             : "double lcl_IterateInverse( "
    1210             : "double fAx, double fBx, bool* rConvError,double fp,double fDF )\n"
    1211             : "{\n"
    1212             : "    *rConvError = false;\n"
    1213             : "    double fYEps = 1.0E-307;\n"
    1214             : "    double fXEps =DBL_EPSILON;\n"
    1215             : "    if(fAx>fBx)\n"
    1216             : "      return DBL_MAX;\n"
    1217             : "    double fAy = GetValue(fAx,fp,fDF);\n"
    1218             : "    double fBy = GetValue(fBx,fp,fDF);\n"
    1219             : "    double fTemp;\n"
    1220             : "    unsigned short nCount;\n"
    1221             : "    double inter;\n"
    1222             : "    bool sign;\n"
    1223             : "    for (nCount =0;nCount<1000&&!lcl_HasChangeOfSign(fAy,fBy);nCount++)\n"
    1224             : "    {\n"
    1225             : "        inter = 2.0 * (fAx - fBx);\n"
    1226             : "        if (fabs(fAy) <= fabs(fBy)) \n"
    1227             : "        {\n"
    1228             : "            sign = true;\n"
    1229             : "            fTemp = fAx;\n"
    1230             : "            fAx += inter;\n"
    1231             : "            if (fAx < 0.0)\n"
    1232             : "                fAx = 0.0;\n"
    1233             : "            fBx = fTemp;\n"
    1234             : "            fBy = fAy;\n"
    1235             : "            fTemp = fAx;\n"
    1236             : "        }\n"
    1237             : "        else\n"
    1238             : "        {\n"
    1239             : "            sign = false;\n"
    1240             : "            fTemp = fBx;\n"
    1241             : "            fBx -= inter;\n"
    1242             : "            fAx = fTemp;\n"
    1243             : "            fAy = fBy;\n"
    1244             : "            fTemp = fBx;\n"
    1245             : "        }\n"
    1246             : "        fTemp = GetValue(fTemp,fp,fDF);\n"
    1247             : "        sign?(fAy = fTemp):(fBy = fTemp);\n"
    1248             : "    }\n"
    1249             : "    if (fAy == 0.0)\n"
    1250             : "        return fAx;\n"
    1251             : "    if (fBy == 0.0)\n"
    1252             : "        return fBx;\n"
    1253             : "    if (!lcl_HasChangeOfSign( fAy, fBy))\n"
    1254             : "    {\n"
    1255             : "        *rConvError = true;\n"
    1256             : "        return 0.0;\n"
    1257             : "    }\n"
    1258             : "    double fPx = fAx;\n"
    1259             : "    double fPy = fAy;\n"
    1260             : "    double fQx = fBx;\n"
    1261             : "    double fQy = fBy;\n"
    1262             : "    double fRx = fAx;\n"
    1263             : "    double fRy = fAy;\n"
    1264             : "    double fSx = 0.5 * (fAx + fBx); \n"
    1265             : "    bool bHasToInterpolate = true;\n"
    1266             : "    nCount = 0;\n"
    1267             : "    while ( nCount < 500 && fabs(fRy) > fYEps &&\n"
    1268             : "            (fBx-fAx) > max( fabs(fAx), fabs(fBx)) * fXEps )\n"
    1269             : "    {\n"
    1270             : "        if (bHasToInterpolate)\n"
    1271             : "        {\n"
    1272             : "           if (fPy!=fQy && fQy!=fRy && fRy!=fPy)\n"
    1273             : "           {\n"
    1274             : "               fSx = fPx * fRy * fQy * pow(fRy-fPy,-1.0)*pow(fQy-fPy,-1.0)\n"
    1275             : "                   + fRx * fQy * fPy * pow(fQy-fRy,-1.0)*pow(fPy-fRy,-1.0)\n"
    1276             : "                   + fQx * fPy * fRy * pow(fPy-fQy,-1.0)*pow(fRy-fQy,-1.0);\n"
    1277             : "               bHasToInterpolate = (fAx < fSx) && (fSx < fBx);\n"
    1278             : "           }\n"
    1279             : "            else\n"
    1280             : "                bHasToInterpolate = false;\n"
    1281             : "        }\n"
    1282             : "        if(!bHasToInterpolate)\n"
    1283             : "        {\n"
    1284             : "            fSx = 0.5 * (fAx + fBx);\n"
    1285             : "            \n"
    1286             : "            fPx = fAx; fPy = fAy;\n"
    1287             : "            fQx = fBx; fQy = fBy;\n"
    1288             : "            bHasToInterpolate = true;\n"
    1289             : "        }\n"
    1290             : "        fPx = fQx; fQx = fRx; fRx = fSx;\n"
    1291             : "        fPy = fQy; fQy = fRy; fRy = GetValue(fSx,fp,fDF);\n"
    1292             : "        lcl_HasChangeOfSign( fAy, fRy)?(fBx = fRx,fBy = fRy):\n"
    1293             : "            (fAx = fRx,fAy = fRy);\n"
    1294             : "        bHasToInterpolate =\n"
    1295             : "            bHasToInterpolate && (fabs(fRy) * 2.0 <= fabs(fQy));\n"
    1296             : "        ++nCount;\n"
    1297             : "    }\n"
    1298             : "    return fRx;\n"
    1299             : "}\n";
    1300           0 : std::string phiDecl=
    1301             : "double phi(double x);\n";
    1302           0 : std::string phi =
    1303             : "double phi(double x)\n"
    1304             : "{\n"
    1305             : "    return  0.39894228040143268 * exp(-(x * x) / 2.0);\n"
    1306             : "}\n";
    1307           0 : std::string taylorDecl =
    1308             : "double taylor(double* pPolynom, uint nMax, double x);\n";
    1309           0 : std::string taylor =
    1310             : "double taylor(double* pPolynom, uint nMax, double x)\n"
    1311             : "{\n"
    1312             : "    double nVal = pPolynom[nMax];\n"
    1313             : "    for (short i = nMax-1; i >= 0; i--)\n"
    1314             : "    {\n"
    1315             : "        nVal = pPolynom[i] + (nVal * x);\n"
    1316             : "    }\n"
    1317             : "    return nVal;\n"
    1318             : "}";
    1319           0 : std::string gaussDecl = "double gauss(double x);\n";
    1320           0 : std::string gauss =
    1321             : "double gauss(double x)\n"
    1322             : "{\n"
    1323             : "    double xAbs = fabs(x);\n"
    1324             : "    uint xShort = (uint)(floor(xAbs));\n"
    1325             : "    double nVal = 0.0;\n"
    1326             : "    if (xShort == 0)\n"
    1327             : "    {\n"
    1328             : "        double t0[] =\n"
    1329             : "        { 0.39894228040143268, -0.06649038006690545,  0.00997355701003582,\n"
    1330             : "         -0.00118732821548045,  0.00011543468761616, -0.00000944465625950,\n"
    1331             : "          0.00000066596935163, -0.00000004122667415,  0.00000000227352982,\n"
    1332             : "          0.00000000011301172,  0.00000000000511243, -0.00000000000021218 };\n"
    1333             : "        nVal = taylor(t0, 11, (xAbs * xAbs)) * xAbs;\n"
    1334             : "    }\n"
    1335             : "    else if ((xShort >= 1) && (xShort <= 2))\n"
    1336             : "    {\n"
    1337             : "        double t2[] =\n"
    1338             : "        { 0.47724986805182079,  0.05399096651318805, -0.05399096651318805,\n"
    1339             : "          0.02699548325659403, -0.00449924720943234, -0.00224962360471617,\n"
    1340             : "          0.00134977416282970, -0.00011783742691370, -0.00011515930357476,\n"
    1341             : "          0.00003704737285544,  0.00000282690796889, -0.00000354513195524,\n"
    1342             : "          0.00000037669563126,  0.00000019202407921, -0.00000005226908590,\n"
    1343             : "         -0.00000000491799345,  0.00000000366377919, -0.00000000015981997,\n"
    1344             : "         -0.00000000017381238,  0.00000000002624031,  0.00000000000560919,\n"
    1345             : "         -0.00000000000172127, -0.00000000000008634, 0.00000000000007894 };\n"
    1346             : "        nVal = taylor(t2, 23, (xAbs - 2.0));\n"
    1347             : "    }\n"
    1348             : "    else if ((xShort >= 3) && (xShort <= 4))\n"
    1349             : "    {\n"
    1350             : "       double t4[] =\n"
    1351             : "       { 0.49996832875816688,  0.00013383022576489, -0.00026766045152977,\n"
    1352             : "         0.00033457556441221, -0.00028996548915725,  0.00018178605666397,\n"
    1353             : "        -0.00008252863922168,  0.00002551802519049, -0.00000391665839292,\n"
    1354             : "        -0.00000074018205222,  0.00000064422023359, -0.00000017370155340,\n"
    1355             : "         0.00000000909595465,  0.00000000944943118, -0.00000000329957075,\n"
    1356             : "         0.00000000029492075,  0.00000000011874477, -0.00000000004420396,\n"
    1357             : "         0.00000000000361422,  0.00000000000143638, -0.00000000000045848 };\n"
    1358             : "        nVal = taylor(t4, 20, (xAbs - 4.0));\n"
    1359             : "    }\n"
    1360             : "    else\n"
    1361             : "    {\n"
    1362             : "        double asympt[] = { -1.0, 1.0, -3.0, 15.0, -105.0 };\n"
    1363             : "        nVal = 0.5 + phi(xAbs) * taylor(asympt, 4, 1.0/(xAbs * xAbs))/xAbs;\n"
    1364             : "    }\n"
    1365             : "    if (x < 0.0)\n"
    1366             : "        return -nVal;\n"
    1367             : "    else\n"
    1368             : "        return nVal;\n"
    1369             : "}\n";
    1370           0 : std::string lcl_Erfc0600Decl=
    1371             : "void lcl_Erfc0600( double x, double *fVal );\n";
    1372           0 : std::string lcl_Erfc0600 =
    1373             : "void lcl_Erfc0600( double  x, double *fVal )\n"
    1374             : "{\n"
    1375             : "    double fPSum = 0.0;\n"
    1376             : "    double fQSum = 0.0;\n"
    1377             : "    double fXPow = 1.0;\n"
    1378             : "    double *pn;\n"
    1379             : "    double *qn;\n"
    1380             : "    if ( x < 2.2 )\n"
    1381             : "    {\n"
    1382             : "        double pn22[] = {         \n"
    1383             : "        9.99999992049799098E-1,   \n"
    1384             : "        1.33154163936765307,      \n"
    1385             : "        8.78115804155881782E-1,   \n"
    1386             : "        3.31899559578213215E-1,   \n"
    1387             : "        7.14193832506776067E-2,   \n"
    1388             : "        7.06940843763253131E-3    \n"
    1389             : "      };                          \n"
    1390             : "        double qn22[] = {         \n"
    1391             : "        1.00000000000000000,      \n"
    1392             : "        2.45992070144245533,      \n"
    1393             : "        2.65383972869775752,      \n"
    1394             : "        1.61876655543871376,      \n"
    1395             : "        5.94651311286481502E-1,   \n"
    1396             : "        1.26579413030177940E-1,   \n"
    1397             : "        1.25304936549413393E-2    \n"
    1398             : "       };                         \n"
    1399             : "        pn = pn22;                \n"
    1400             : "        qn = qn22;                \n"
    1401             : "      }                           \n"
    1402             : "      else                        \n"
    1403             : "                                  \n"
    1404             : "       {                          \n"
    1405             : "            double pn60[] = {\n"
    1406             : "            9.99921140009714409E-1,\n"
    1407             : "            1.62356584489366647,\n"
    1408             : "            1.26739901455873222,\n"
    1409             : "            5.81528574177741135E-1,\n"
    1410             : "            1.57289620742838702E-1,\n"
    1411             : "            2.25716982919217555E-2\n"
    1412             : "            };\n"
    1413             : "            double qn60[] = {\n"
    1414             : "            1.00000000000000000,\n"
    1415             : "            2.75143870676376208,\n"
    1416             : "            3.37367334657284535,\n"
    1417             : "            2.38574194785344389,\n"
    1418             : "            1.05074004614827206,\n"
    1419             : "            2.78788439273628983E-1,\n"
    1420             : "            4.00072964526861362E-2\n"
    1421             : "            };\n"
    1422             : "            pn = pn60;\n"
    1423             : "            qn = qn60;\n"
    1424             : "       }\n"
    1425             : "    for ( unsigned int i = 0; i < 6; ++i )  \n"
    1426             : "    {\n"
    1427             : "        fPSum += pn[i]*fXPow;\n"
    1428             : "        fQSum += qn[i]*fXPow;\n"
    1429             : "        fXPow *= x;\n"
    1430             : "    }\n"
    1431             : "    fQSum += qn[6]*fXPow;\n"
    1432             : "    *fVal = exp((-1.0)*x*x)*fPSum*pow(fQSum, -1.0);\n"
    1433             : "   }\n";
    1434           0 : std::string lcl_Erfc2654Decl=
    1435             : "void lcl_Erfc2654( double x, double *fVal );\n";
    1436           0 : std::string lcl_Erfc2654 =
    1437             : "void lcl_Erfc2654( double x, double *fVal )\n"
    1438             : "{\n"
    1439             : "    double pn[] = {\n"
    1440             : "        5.64189583547756078E-1,\n"
    1441             : "        8.80253746105525775,\n"
    1442             : "        3.84683103716117320E1,\n"
    1443             : "        4.77209965874436377E1,\n"
    1444             : "        8.08040729052301677\n"
    1445             : "    };\n"
    1446             : "    double qn[] = {\n"
    1447             : "        1.00000000000000000,\n"
    1448             : "        1.61020914205869003E1,\n"
    1449             : "        7.54843505665954743E1,\n"
    1450             : "        1.12123870801026015E2,\n"
    1451             : "        3.73997570145040850E1\n"
    1452             : "    };\n"
    1453             : "\n"
    1454             : "    double fPSum = 0.0;\n"
    1455             : "    double fQSum = 0.0;\n"
    1456             : "    double fXPow = 1.0;\n"
    1457             : "\n"
    1458             : "    for ( unsigned int i = 0; i <= 4; ++i )\n"
    1459             : "    {\n"
    1460             : "        fPSum += pn[i]*fXPow;       \n"
    1461             : "        fQSum += qn[i]*fXPow;\n"
    1462             : "        fXPow *= pow(x*x, -1.0);\n"
    1463             : "    }\n"
    1464             : "    *fVal = exp((-1.0)*x*x)*fPSum*pow(x*fQSum, -1.0);\n"
    1465             : "}\n";
    1466           0 : std::string lcl_Erf0065Decl=
    1467             : "void lcl_Erf0065( double x, double *fVal );\n";
    1468           0 : std::string lcl_Erf0065 =
    1469             : "void lcl_Erf0065( double x, double *fVal )\n"
    1470             : "   {\n"
    1471             : "        double pn[] = {\n"
    1472             : "            1.12837916709551256,\n"
    1473             : "            1.35894887627277916E-1,\n"
    1474             : "            4.03259488531795274E-2,\n"
    1475             : "            1.20339380863079457E-3,\n"
    1476             : "            6.49254556481904354E-5\n"
    1477             : "            };\n"
    1478             : "        double qn[] = {\n"
    1479             : "            1.00000000000000000,\n"
    1480             : "            4.53767041780002545E-1,\n"
    1481             : "            8.69936222615385890E-2,\n"
    1482             : "            8.49717371168693357E-3,\n"
    1483             : "            3.64915280629351082E-4\n"
    1484             : "            };\n"
    1485             : "        double fPSum = 0.0;\n"
    1486             : "        double fQSum = 0.0;\n"
    1487             : "        double fXPow = 1.0;\n"
    1488             : "        for ( unsigned int i = 0; i <= 4; ++i )\n"
    1489             : "        {\n"
    1490             : "            fPSum += pn[i]*fXPow;\n"
    1491             : "            fQSum += qn[i]*fXPow;\n"
    1492             : "            fXPow *= x*x;\n"
    1493             : "        }\n"
    1494             : "        *fVal = x * fPSum * pow(fQSum, -1.0);\n"
    1495             : "   }\n";
    1496           0 : std::string rtl_math_erf_rdDecl=
    1497             : "double rtl_math_erf_rd( double x );\n";
    1498           0 : std::string rtl_math_erf_rd =
    1499             : " double rtl_math_erf_rd( double x )\n"
    1500             : " {\n"
    1501             : "     if( x == 0.0 )\n"
    1502             : "         return 0.0;\n"
    1503             : "     bool bNegative = false;\n"
    1504             : "     if ( x < 0.0 )\n"
    1505             : "     {\n"
    1506             : "         x = fabs( x );\n"
    1507             : "         bNegative = true;\n"
    1508             : "     }\n"
    1509             : "     double fErf = 1.0;\n"
    1510             : "     if ( x < 1.0e-10 )\n"
    1511             : "         fErf = (double) (x*1.1283791670955125738961589031215452);\n"
    1512             : "     else if ( x < 0.65 )\n"
    1513             : "         lcl_Erf0065( x, &fErf );\n"
    1514             : "     if ( bNegative )\n"
    1515             : "         fErf *= (-1.0);\n"
    1516             : "     return fErf;\n"
    1517             : " }\n";
    1518           0 : std::string rtl_math_erfc_rdDecl=
    1519             : "double rtl_math_erfc_rd( double x );\n";
    1520           0 : std::string rtl_math_erfc_rd =
    1521             : " double rtl_math_erfc_rd( double x )\n"
    1522             : " {\n"
    1523             : "     if ( x == 0.0 )\n"
    1524             : "        return 1.0;\n"
    1525             : "     bool bNegative = false;\n"
    1526             : "     if ( x < 0.0 )\n"
    1527             : "     {\n"
    1528             : "         x = fabs( x );\n"
    1529             : "         bNegative = true;\n"
    1530             : "     }\n"
    1531             : "     double fErfc = 0.0;\n"
    1532             : "     if ( x >= 0.65 )\n"
    1533             : "     {\n"
    1534             : "         if ( x < 6.0 )\n"
    1535             : "             lcl_Erfc0600( x, &fErfc );\n"
    1536             : "         else\n"
    1537             : "             lcl_Erfc2654( x, &fErfc );\n"
    1538             : "     }\n"
    1539             : "     else\n"
    1540             : "         fErfc = 1.0 - rtl_math_erf_rd( x );\n"
    1541             : "     if ( bNegative )\n"
    1542             : "         fErfc = 2.0 - fErfc;\n"
    1543             : "     return fErfc;\n"
    1544             : " }\n";
    1545             : #endif
    1546             : 
    1547             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
    1548             : 

Generated by: LCOV version 1.10