Polylib_test.cpp

Go to the documentation of this file.

///////////////////////////////////////////////////////////////////////////////
//
// File: Polylib_test.cpp
//
// For more information, please see: http://www.nektar.info
//
// The MIT License
//
// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
// Department of Aeronautics, Imperial College London (UK), and Scientific
// Computing and Imaging Institute, University of Utah (USA).
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// Description:
//
///////////////////////////////////////////////////////////////////////////////
 
#include "Polylib.h"
#include <cmath>
#include <cstdio>
 
using namespace std;
using namespace Polylib;
 
/* --------------------------------------------------------------------
   To compile:
   g++ -g -c Polylib.cpp -I ./ -I ../../
   g++ -g -c Polylib_test.cpp -I ./ -I ../../
   g++ -g -o polytest Polylib_test.o Polylib.o -lm
 * --------------------------------------------------------------------*/
 
/* -------------------------------------------------------------------
   This is a routine to test the integration, differentiation and
   interpolation routines in the polylib.c.
 
   First, it performs the integral
 
      /1      alpha   beta  alpha,beta
     |   (1-x)   (1+x)     P (x)       dx  = 0
     /-1                    n
 
   for all   -0.5 <= alpha <= 5   (increments of 0.5)
             -0.5 <= beta  <= 5   (increments of 0.5)
 
   using np points where
          NPLOWER <= np <= NPUPPER
                2     <= n  <= 2*np - delta
 
   delta = 1 (gauss), 2(radau), 3(lobatto).
   The integral is evaluated and if it is larger that EPS then the
   value of alpha,beta,np,n and the integral is printed to the screen.
 
   After every alpha value the statement
       "finished checking all beta values for alpha = #"
   is printed
 
   The routine then evaluates the derivate of
 
          d   n      n-1
      -- x  = n x
      dx
 
   for all   -0.5 <= alpha <= 5   (increments of 0.5)
             -0.5 <= beta  <= 5   (increments of 0.5)
 
   using np points where
          NPLOWER <= np <= NPUPPER
                2     <= n  <= np - 1
 
   The error is check in a pointwise sense and if it is larger than
   EPS then the value of alpha,beta,np,n and the error is printed to
   the screen. After every alpha value the statement
       "finished checking all beta values for alpha = #"
   is printed
 
   Finally the routine  evaluates the interpolation of
 
             n      n
        z  to  x
 
   where z are the quadrature zeros and x are the equispaced points
 
                  2*i
        x    =   -----   - 1.0    (0 <= i <= np-1)
     i       (np-1)
 
 
   for all   -0.5 <= alpha <= 5   (increments of 0.5)
             -0.5 <= beta  <= 5   (increments of 0.5)
 
   using np points where
          NPLOWER <= np <= NPUPPER
                2     <= n  <= np - 1
 
   The error is check in a pointwise sense and if it is larger than
   EPS then the value of alpha,beta,np,n and the error is printed to
   the screen. After every alpha value the statement
      "finished checking all beta values for alpha = #"
   is printed
 
   The above checks are performed for all the Gauss, Gauss-Radau and
   Gauss-Lobatto points. If you want to disable any routine then set
      GAUSS_INT, GAUSS_RADAU_INT, GAUSS_LOBATTO_INT = 0
   for the integration rouintes
      GAUSS_DIFF,GAUSS_RADAU_DIFF, GAUSS_LOBATTO_DIFF = 0
   for the differentiation routines
      GAUSS_INTERP,GAUSS_RADAU_INTERP, GAUSS_LOBATTO_INTERP = 0
   for the interpolation routines.
   ------------------------------------------------------------------*/
 
#define NPLOWER 5
#define NPUPPER 15
#define EPS 1e-12
 
#define GAUSS_INT 1
#define GAUSS_RADAUM_INT 1
#define GAUSS_RADAUP_INT 1
#define GAUSS_LOBATTO_INT 1
#define GAUSS_DIFF 1
#define GAUSS_RADAUM_DIFF 1
#define GAUSS_RADAUP_DIFF 1
#define GAUSS_LOBATTO_DIFF 1
#define GAUSS_INTERP 1
#define GAUSS_RADAUM_INTERP 1
#define GAUSS_RADAUP_INTERP 1
#define GAUSS_LOBATTO_INTERP 1
 
/* local routines */
double ddot(int, double *, int, double *, int);
double *dvector(int, int);
int test_gamma_fraction();
 
int main()
{
    int np, n, i;
    double *z, *w, *p, *q, sum = 0, alpha, beta, *d, *dt;
 
    z = dvector(0, NPUPPER - 1);
    w = dvector(0, NPUPPER - 1);
    p = dvector(0, NPUPPER - 1);
 
    q  = dvector(0, NPUPPER * NPUPPER - 1);
    d  = dvector(0, NPUPPER * NPUPPER - 1);
    dt = dvector(0, NPUPPER * NPUPPER - 1);
 
#if GAUSS_INT
    /* Gauss Integration */
    printf("Begin checking Gauss integration\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgj(z, w, np, alpha, beta);
                for (n = 2; n < 2 * np - 1; ++n)
                {
                    jacobfd(np, z, p, NULL, n, alpha, beta);
                    sum = ddot(np, w, 1, p, 1);
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "integal was %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
 
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Integration\n");
#endif
 
#if GAUSS_RADAUM_INT
    /* Gauss Radau Integration */
    printf("Begin checking Gauss Radau Integration\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjm(z, w, np, alpha, beta);
                for (n = 2; n < 2 * np - 2; ++n)
                {
                    jacobfd(np, z, p, NULL, n, alpha, beta);
                    sum = ddot(np, w, 1, p, 1);
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "integal was %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
 
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau (z=-1) Integration\n");
#endif
 
#if GAUSS_RADAUP_INT
    /* Gauss Radau Integration */
    printf("Begin checking Gauss Radau Integration\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjp(z, w, np, alpha, beta);
                for (n = 2; n < 2 * np - 2; ++n)
                {
                    jacobfd(np, z, p, NULL, n, alpha, beta);
                    sum = ddot(np, w, 1, p, 1);
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "integal was %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
 
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau (z=1) Integration\n");
#endif
 
#if GAUSS_LOBATTO_INT
    /* Gauss Lobatto Integration */
    printf("Begin checking Gauss Lobatto integration\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwglj(z, w, np, alpha, beta);
                for (n = 2; n < 2 * np - 3; ++n)
                {
                    jacobfd(np, z, p, NULL, n, alpha, beta);
                    sum = ddot(np, w, 1, p, 1);
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "integal was %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
 
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Lobatto Integration\n");
#endif
 
#if GAUSS_INT
    printf("Begin checking integration through Gauss points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgj(z, w, np, alpha, beta);
                Qg(q, z, np, 0);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, q + i * np, 1, p, 1) -
                                    pow(z[i], n + 1) / (n + 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Jacobi integration\n");
#endif
 
#if GAUSS_RADAUM_INT
    printf("Begin checking integration through Gauss Radau points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjm(z, w, np, alpha, beta);
                Qg(q, z, np, 0);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, q + i * np, 1, p, 1) -
                                    pow(z[i], n + 1) / (n + 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau integration\n");
#endif
 
#if GAUSS_RADAUP_INT
    printf("Begin checking integration through Gauss Radau (z=1) points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjp(z, w, np, alpha, beta);
                Qg(q, z, np, 0);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, q + i * np, 1, p, 1) -
                                    pow(z[i], n + 1) / (n + 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau (z=1) integration\n");
#endif
 
#if GAUSS_LOBATTO_INT
    printf("Begin checking integration through Gauss Lobatto points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwglj(z, w, np, alpha, beta);
                Qg(q, z, np, 0);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, q + i * np, 1, p, 1) -
                                    pow(z[i], n + 1) / (n + 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Lobatto integration\n");
#endif
 
#if GAUSS_DIFF
    printf("Begin checking differentiation through Gauss points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgj(z, w, np, alpha, beta);
                Dgj(d, z, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) -
                                    n * pow(z[i], n - 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Jacobi differentiation\n");
#endif
 
#if GAUSS_RADAUM_DIFF
    printf("Begin checking differentiation through Gauss Radau points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjm(z, w, np, alpha, beta);
                Dgrjm(d, z, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) -
                                    n * pow(z[i], n - 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau (z=-1) differentiation\n");
#endif
 
#if GAUSS_RADAUP_DIFF
    printf("Begin checking differentiation through Gauss Radau (z=1) points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjp(z, w, np, alpha, beta);
                Dgrjp(d, z, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) -
                                    n * pow(z[i], n - 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau (z=1) differentiation\n");
#endif
 
#if GAUSS_LOBATTO_DIFF
    printf("Begin checking differentiation through Gauss Lobatto points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwglj(z, w, np, alpha, beta);
                Dglj(d, z, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                        p[i] = pow(z[i], n);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) -
                                    n * pow(z[i], n - 1));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Lobatto differentiation\n");
#endif
 
    /* check interpolation routines */
#if GAUSS_INTERP
    printf("Begin checking interpolation through Gauss points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgj(z, w, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                    {
                        w[i] = 2.0 * i / (double)(np - 1) - 1.0;
                        p[i] = pow(z[i], n);
                    }
                    Imgj(d, z, w, np, np, alpha, beta);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) - pow(w[i], n));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Jacobi interpolation\n");
#endif
 
#if GAUSS_RADAUM_INTERP
    printf("Begin checking Interpolation through Gauss Radau (z=-1) points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjm(z, w, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                    {
                        w[i] = 2.0 * i / (double)(np - 1) - 1.0;
                        p[i] = pow(z[i], n);
                    }
                    Imgrjm(d, z, w, np, np, alpha, beta);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) - pow(w[i], n));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radua Jacobi (z=-1) interpolation\n");
#endif
#if GAUSS_RADAUP_INTERP
    printf("Begin checking Interpolation through Gauss Radau (z=1) points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwgrjp(z, w, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                    {
                        w[i] = 2.0 * i / (double)(np - 1) - 1.0;
                        p[i] = pow(z[i], n);
                    }
                    Imgrjp(d, z, w, np, np, alpha, beta);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) - pow(w[i], n));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Radau (z=1) interpolation\n");
#endif
 
#if GAUSS_LOBATTO_INTERP
    printf("Begin checking Interpolation through Gauss Lobatto points\n");
    alpha = -0.5;
    while (alpha <= 5.0)
    {
        beta = -0.5;
        while (beta <= 5.0)
        {
 
            for (np = NPLOWER; np <= NPUPPER; ++np)
            {
                zwglj(z, w, np, alpha, beta);
                for (n = 2; n < np - 1; ++n)
                {
                    for (i = 0; i < np; ++i)
                    {
                        w[i] = 2.0 * i / (double)(np - 1) - 1.0;
                        p[i] = pow(z[i], n);
                    }
                    Imglj(d, z, w, np, np, alpha, beta);
                    sum = 0;
                    for (i = 0; i < np; ++i)
                        sum += fabs(ddot(np, d + i, np, p, 1) - pow(w[i], n));
                    sum /= np;
                    if (fabs(sum) > EPS)
                        printf("alpha = %lf, beta = %lf, np = %d, n = %d "
                               "difference %lg\n",
                               alpha, beta, np, n, sum);
                }
            }
            beta += 0.5;
        }
        printf("finished checking all beta values for alpha = %lf\n", alpha);
        alpha += 0.5;
    }
    printf("Finished checking Gauss Lobatto interploation\n");
#endif
    test_gamma_fraction();
 
    free(z);
    free(w);
    free(p);
    free(d);
    free(dt);
    return 0;
}
 
double ddot(int n, double *x, int incx, double *y, int incy)
{
    register double sum = 0.;
 
    while (n--)
    {
        sum += (*x) * (*y);
        x += incx;
        y += incy;
    }
    return sum;
}
 
double *dvector(int nl, int nh)
{
    double *v;
 
    v = (double *)malloc((unsigned)(nh - nl + 1) * sizeof(double));
    return v - nl;
}
 
int test_gamma_fraction()
{
    double a = 362880.;
    double c = Polylib::gammaFracGammaF(10, 0., 0, 1.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 10., 1.,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(1, 0., 12, -2.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 1., 10.,
           c * a - 1.);
 
    a = 30.;
    c = Polylib::gammaFracGammaF(4, 3., 5, 0.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 5., 7.,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(5, 0., 7, 0.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 7., 5.,
           c * a - 1.);
 
    a = 21651.09375;
    c = Polylib::gammaFracGammaF(7, 3.5, 5, 0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 10.5, 5.5,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(5, 0.5, 10, 0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 5.5, 10.5,
           c * a - 1.);
 
    a = 97429.921875;
    c = Polylib::gammaFracGammaF(10, 0.5, 5, -0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 10.5, 4.5,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(5, -0.5, 11, -0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 4.5, 10.5,
           c * a - 1.);
 
    a = 2279.0625;
    c = Polylib::gammaFracGammaF(10, -0.5, 5, 0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 9.5, 5.5,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(5, 0.5, 10, -0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 5.5, 9.5,
           c * a - 1.);
 
    a = 639383.8623046875;
    c = Polylib::gammaFracGammaF(10, 0.5, 0, 0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 10.5, 0.5,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(0, 0.5, 10, 0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 0.5, 10.5,
           c * a - 1.);
 
    a = 5967498288235982848.;
    c = Polylib::gammaFracGammaF(100, 0., 90, 0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 100., 90.5,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(90, 0.5, 100, 0.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 90.5, 100.,
           c * a - 1.);
 
    a = 5618641603777298169856.;
    c = Polylib::gammaFracGammaF(200, 0., 191, -0.5);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 200., 190.5,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(190, 0.5, 200, 0.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 190.5, 200.,
           c * a - 1.);
 
    a = 77396694214720029196288.;
    c = Polylib::gammaFracGammaF(200, 0., 190, 0.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 200., 190.,
           c / a - 1.);
    c = Polylib::gammaFracGammaF(190, 0., 200, 0.);
    printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n", 190., 200.,
           c * a - 1.);
 
    int Q = 2;
    for (double alpha = -0.5; alpha <= 150.; alpha += 0.5)
    {
        for (double beta = -0.5; beta <= 150.; beta += 0.5)
        {
            a = Polylib::gammaF(Q + alpha) / Polylib::gammaF(Q + beta);
            c = Polylib::gammaFracGammaF(Q, alpha, Q, beta) / a - 1.;
            if (fabs(c) > 5.e-15)
            {
                printf("alpha = %7.2lf, beta = %7.2lf, difference %9.2e\n",
                       Q + alpha, Q + beta, c);
            }
        }
    }
 
    return 0;
}