context: /*************************************************************************
  ALGLIB 3.14.0 (source code generated 2018-06-16)
  Copyright (c) Sergey Bochkanov (ALGLIB project).
  
  >>> SOURCE LICENSE >>>
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation (www.fsf.org); either version 2 of the 
  License, or (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  A copy of the GNU General Public License is available at
  http://www.fsf.org/licensing/licenses
  >>> END OF LICENSE >>>
  *************************************************************************/
  #pragma warning disable 162
  #pragma warning disable 164
  #pragma warning disable 219
  using System;
  
  public partial class alglib
  {
  
      
      /*************************************************************************
      Computation of nodes and weights for a Gauss quadrature formula
  
      The algorithm generates the N-point Gauss quadrature formula  with  weight
      function given by coefficients alpha and beta  of  a  recurrence  relation
      which generates a system of orthogonal polynomials:
  
      P-1(x)   =  0
      P0(x)    =  1
      Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)
  
      and zeroth moment Mu0
  
      Mu0 = integral(W(x)dx,a,b)
  
      INPUT PARAMETERS:
          Alpha   -   array[0..N-1], alpha coefficients
          Beta    -   array[0..N-1], beta coefficients
                      Zero-indexed element is not used and may be arbitrary.
                      Beta[I]>0.
          Mu0     -   zeroth moment of the weight function.
          N       -   number of nodes of the quadrature formula, N>=1
  
      OUTPUT PARAMETERS:
          Info    -   error code:
                      * -3    internal eigenproblem solver hasn't converged
                      * -2    Beta[i]<=0
                      * -1    incorrect N was passed
                      *  1    OK
          X       -   array[0..N-1] - array of quadrature nodes,
                      in ascending order.
          W       -   array[0..N-1] - array of quadrature weights.
  
        -- ALGLIB --
           Copyright 2005-2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgeneraterec(double[] alpha, double[] beta, double mu0, int n, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgeneraterec(alpha, beta, mu0, n, ref info, ref x, ref w, null);
      }
      
      public static void gqgeneraterec(double[] alpha, double[] beta, double mu0, int n, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgeneraterec(alpha, beta, mu0, n, ref info, ref x, ref w, _params);
      }
      
      /*************************************************************************
      Computation of nodes and weights for a Gauss-Lobatto quadrature formula
  
      The algorithm generates the N-point Gauss-Lobatto quadrature formula  with
      weight function given by coefficients alpha and beta of a recurrence which
      generates a system of orthogonal polynomials.
  
      P-1(x)   =  0
      P0(x)    =  1
      Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)
  
      and zeroth moment Mu0
  
      Mu0 = integral(W(x)dx,a,b)
  
      INPUT PARAMETERS:
          Alpha   -   array[0..N-2], alpha coefficients
          Beta    -   array[0..N-2], beta coefficients.
                      Zero-indexed element is not used, may be arbitrary.
                      Beta[I]>0
          Mu0     -   zeroth moment of the weighting function.
          A       -   left boundary of the integration interval.
          B       -   right boundary of the integration interval.
          N       -   number of nodes of the quadrature formula, N>=3
                      (including the left and right boundary nodes).
  
      OUTPUT PARAMETERS:
          Info    -   error code:
                      * -3    internal eigenproblem solver hasn't converged
                      * -2    Beta[i]<=0
                      * -1    incorrect N was passed
                      *  1    OK
          X       -   array[0..N-1] - array of quadrature nodes,
                      in ascending order.
          W       -   array[0..N-1] - array of quadrature weights.
  
        -- ALGLIB --
           Copyright 2005-2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgenerategausslobattorec(double[] alpha, double[] beta, double mu0, double a, double b, int n, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausslobattorec(alpha, beta, mu0, a, b, n, ref info, ref x, ref w, null);
      }
      
      public static void gqgenerategausslobattorec(double[] alpha, double[] beta, double mu0, double a, double b, int n, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausslobattorec(alpha, beta, mu0, a, b, n, ref info, ref x, ref w, _params);
      }
      
      /*************************************************************************
      Computation of nodes and weights for a Gauss-Radau quadrature formula
  
      The algorithm generates the N-point Gauss-Radau  quadrature  formula  with
      weight function given by the coefficients alpha and  beta  of a recurrence
      which generates a system of orthogonal polynomials.
  
      P-1(x)   =  0
      P0(x)    =  1
      Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)
  
      and zeroth moment Mu0
  
      Mu0 = integral(W(x)dx,a,b)
  
      INPUT PARAMETERS:
          Alpha   -   array[0..N-2], alpha coefficients.
          Beta    -   array[0..N-1], beta coefficients
                      Zero-indexed element is not used.
                      Beta[I]>0
          Mu0     -   zeroth moment of the weighting function.
          A       -   left boundary of the integration interval.
          N       -   number of nodes of the quadrature formula, N>=2
                      (including the left boundary node).
  
      OUTPUT PARAMETERS:
          Info    -   error code:
                      * -3    internal eigenproblem solver hasn't converged
                      * -2    Beta[i]<=0
                      * -1    incorrect N was passed
                      *  1    OK
          X       -   array[0..N-1] - array of quadrature nodes,
                      in ascending order.
          W       -   array[0..N-1] - array of quadrature weights.
  
  
        -- ALGLIB --
           Copyright 2005-2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgenerategaussradaurec(double[] alpha, double[] beta, double mu0, double a, int n, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategaussradaurec(alpha, beta, mu0, a, n, ref info, ref x, ref w, null);
      }
      
      public static void gqgenerategaussradaurec(double[] alpha, double[] beta, double mu0, double a, int n, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategaussradaurec(alpha, beta, mu0, a, n, ref info, ref x, ref w, _params);
      }
      
      /*************************************************************************
      Returns nodes/weights for Gauss-Legendre quadrature on [-1,1] with N
      nodes.
  
      INPUT PARAMETERS:
          N           -   number of nodes, >=1
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -4    an  error   was   detected   when  calculating
                                  weights/nodes.  N  is  too  large   to  obtain
                                  weights/nodes  with  high   enough   accuracy.
                                  Try  to   use   multiple   precision  version.
                          * -3    internal eigenproblem solver hasn't  converged
                          * -1    incorrect N was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes,
                          in ascending order.
          W           -   array[0..N-1] - array of quadrature weights.
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgenerategausslegendre(int n, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausslegendre(n, ref info, ref x, ref w, null);
      }
      
      public static void gqgenerategausslegendre(int n, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausslegendre(n, ref info, ref x, ref w, _params);
      }
      
      /*************************************************************************
      Returns  nodes/weights  for  Gauss-Jacobi quadrature on [-1,1] with weight
      function W(x)=Power(1-x,Alpha)*Power(1+x,Beta).
  
      INPUT PARAMETERS:
          N           -   number of nodes, >=1
          Alpha       -   power-law coefficient, Alpha>-1
          Beta        -   power-law coefficient, Beta>-1
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -4    an  error  was   detected   when   calculating
                                  weights/nodes. Alpha or  Beta  are  too  close
                                  to -1 to obtain weights/nodes with high enough
                                  accuracy, or, may be, N is too large.  Try  to
                                  use multiple precision version.
                          * -3    internal eigenproblem solver hasn't converged
                          * -1    incorrect N/Alpha/Beta was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes,
                          in ascending order.
          W           -   array[0..N-1] - array of quadrature weights.
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgenerategaussjacobi(int n, double alpha, double beta, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategaussjacobi(n, alpha, beta, ref info, ref x, ref w, null);
      }
      
      public static void gqgenerategaussjacobi(int n, double alpha, double beta, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategaussjacobi(n, alpha, beta, ref info, ref x, ref w, _params);
      }
      
      /*************************************************************************
      Returns  nodes/weights  for  Gauss-Laguerre  quadrature  on  [0,+inf) with
      weight function W(x)=Power(x,Alpha)*Exp(-x)
  
      INPUT PARAMETERS:
          N           -   number of nodes, >=1
          Alpha       -   power-law coefficient, Alpha>-1
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -4    an  error  was   detected   when   calculating
                                  weights/nodes. Alpha is too  close  to  -1  to
                                  obtain weights/nodes with high enough accuracy
                                  or, may  be,  N  is  too  large.  Try  to  use
                                  multiple precision version.
                          * -3    internal eigenproblem solver hasn't converged
                          * -1    incorrect N/Alpha was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes,
                          in ascending order.
          W           -   array[0..N-1] - array of quadrature weights.
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgenerategausslaguerre(int n, double alpha, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausslaguerre(n, alpha, ref info, ref x, ref w, null);
      }
      
      public static void gqgenerategausslaguerre(int n, double alpha, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausslaguerre(n, alpha, ref info, ref x, ref w, _params);
      }
      
      /*************************************************************************
      Returns  nodes/weights  for  Gauss-Hermite  quadrature on (-inf,+inf) with
      weight function W(x)=Exp(-x*x)
  
      INPUT PARAMETERS:
          N           -   number of nodes, >=1
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -4    an  error  was   detected   when   calculating
                                  weights/nodes.  May be, N is too large. Try to
                                  use multiple precision version.
                          * -3    internal eigenproblem solver hasn't converged
                          * -1    incorrect N/Alpha was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes,
                          in ascending order.
          W           -   array[0..N-1] - array of quadrature weights.
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gqgenerategausshermite(int n, out int info, out double[] x, out double[] w)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausshermite(n, ref info, ref x, ref w, null);
      }
      
      public static void gqgenerategausshermite(int n, out int info, out double[] x, out double[] w, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          w = new double[0];
          gq.gqgenerategausshermite(n, ref info, ref x, ref w, _params);
      }
  
  }
  public partial class alglib
  {
  
      
      /*************************************************************************
      Computation of nodes and weights of a Gauss-Kronrod quadrature formula
  
      The algorithm generates the N-point Gauss-Kronrod quadrature formula  with
      weight  function  given  by  coefficients  alpha  and beta of a recurrence
      relation which generates a system of orthogonal polynomials:
  
          P-1(x)   =  0
          P0(x)    =  1
          Pn+1(x)  =  (x-alpha(n))*Pn(x)  -  beta(n)*Pn-1(x)
  
      and zero moment Mu0
  
          Mu0 = integral(W(x)dx,a,b)
  
  
      INPUT PARAMETERS:
          Alpha       -   alpha coefficients, array[0..floor(3*K/2)].
          Beta        -   beta coefficients,  array[0..ceil(3*K/2)].
                          Beta[0] is not used and may be arbitrary.
                          Beta[I]>0.
          Mu0         -   zeroth moment of the weight function.
          N           -   number of nodes of the Gauss-Kronrod quadrature formula,
                          N >= 3,
                          N =  2*K+1.
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -5    no real and positive Gauss-Kronrod formula can
                                  be created for such a weight function  with  a
                                  given number of nodes.
                          * -4    N is too large, task may be ill  conditioned -
                                  x[i]=x[i+1] found.
                          * -3    internal eigenproblem solver hasn't converged
                          * -2    Beta[i]<=0
                          * -1    incorrect N was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes,
                          in ascending order.
          WKronrod    -   array[0..N-1] - Kronrod weights
          WGauss      -   array[0..N-1] - Gauss weights (interleaved with zeros
                          corresponding to extended Kronrod nodes).
  
        -- ALGLIB --
           Copyright 08.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gkqgeneraterec(double[] alpha, double[] beta, double mu0, int n, out int info, out double[] x, out double[] wkronrod, out double[] wgauss)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqgeneraterec(alpha, beta, mu0, n, ref info, ref x, ref wkronrod, ref wgauss, null);
      }
      
      public static void gkqgeneraterec(double[] alpha, double[] beta, double mu0, int n, out int info, out double[] x, out double[] wkronrod, out double[] wgauss, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqgeneraterec(alpha, beta, mu0, n, ref info, ref x, ref wkronrod, ref wgauss, _params);
      }
      
      /*************************************************************************
      Returns   Gauss   and   Gauss-Kronrod   nodes/weights  for  Gauss-Legendre
      quadrature with N points.
  
      GKQLegendreCalc (calculation) or  GKQLegendreTbl  (precomputed  table)  is
      used depending on machine precision and number of nodes.
  
      INPUT PARAMETERS:
          N           -   number of Kronrod nodes, must be odd number, >=3.
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -4    an  error   was   detected   when  calculating
                                  weights/nodes.  N  is  too  large   to  obtain
                                  weights/nodes  with  high   enough   accuracy.
                                  Try  to   use   multiple   precision  version.
                          * -3    internal eigenproblem solver hasn't converged
                          * -1    incorrect N was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes, ordered in
                          ascending order.
          WKronrod    -   array[0..N-1] - Kronrod weights
          WGauss      -   array[0..N-1] - Gauss weights (interleaved with zeros
                          corresponding to extended Kronrod nodes).
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gkqgenerategausslegendre(int n, out int info, out double[] x, out double[] wkronrod, out double[] wgauss)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqgenerategausslegendre(n, ref info, ref x, ref wkronrod, ref wgauss, null);
      }
      
      public static void gkqgenerategausslegendre(int n, out int info, out double[] x, out double[] wkronrod, out double[] wgauss, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqgenerategausslegendre(n, ref info, ref x, ref wkronrod, ref wgauss, _params);
      }
      
      /*************************************************************************
      Returns   Gauss   and   Gauss-Kronrod   nodes/weights   for   Gauss-Jacobi
      quadrature on [-1,1] with weight function
  
          W(x)=Power(1-x,Alpha)*Power(1+x,Beta).
  
      INPUT PARAMETERS:
          N           -   number of Kronrod nodes, must be odd number, >=3.
          Alpha       -   power-law coefficient, Alpha>-1
          Beta        -   power-law coefficient, Beta>-1
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -5    no real and positive Gauss-Kronrod formula can
                                  be created for such a weight function  with  a
                                  given number of nodes.
                          * -4    an  error  was   detected   when   calculating
                                  weights/nodes. Alpha or  Beta  are  too  close
                                  to -1 to obtain weights/nodes with high enough
                                  accuracy, or, may be, N is too large.  Try  to
                                  use multiple precision version.
                          * -3    internal eigenproblem solver hasn't converged
                          * -1    incorrect N was passed
                          * +1    OK
                          * +2    OK, but quadrature rule have exterior  nodes,
                                  x[0]<-1 or x[n-1]>+1
          X           -   array[0..N-1] - array of quadrature nodes, ordered in
                          ascending order.
          WKronrod    -   array[0..N-1] - Kronrod weights
          WGauss      -   array[0..N-1] - Gauss weights (interleaved with zeros
                          corresponding to extended Kronrod nodes).
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gkqgenerategaussjacobi(int n, double alpha, double beta, out int info, out double[] x, out double[] wkronrod, out double[] wgauss)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqgenerategaussjacobi(n, alpha, beta, ref info, ref x, ref wkronrod, ref wgauss, null);
      }
      
      public static void gkqgenerategaussjacobi(int n, double alpha, double beta, out int info, out double[] x, out double[] wkronrod, out double[] wgauss, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqgenerategaussjacobi(n, alpha, beta, ref info, ref x, ref wkronrod, ref wgauss, _params);
      }
      
      /*************************************************************************
      Returns Gauss and Gauss-Kronrod nodes for quadrature with N points.
  
      Reduction to tridiagonal eigenproblem is used.
  
      INPUT PARAMETERS:
          N           -   number of Kronrod nodes, must be odd number, >=3.
  
      OUTPUT PARAMETERS:
          Info        -   error code:
                          * -4    an  error   was   detected   when  calculating
                                  weights/nodes.  N  is  too  large   to  obtain
                                  weights/nodes  with  high   enough   accuracy.
                                  Try  to   use   multiple   precision  version.
                          * -3    internal eigenproblem solver hasn't converged
                          * -1    incorrect N was passed
                          * +1    OK
          X           -   array[0..N-1] - array of quadrature nodes, ordered in
                          ascending order.
          WKronrod    -   array[0..N-1] - Kronrod weights
          WGauss      -   array[0..N-1] - Gauss weights (interleaved with zeros
                          corresponding to extended Kronrod nodes).
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gkqlegendrecalc(int n, out int info, out double[] x, out double[] wkronrod, out double[] wgauss)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqlegendrecalc(n, ref info, ref x, ref wkronrod, ref wgauss, null);
      }
      
      public static void gkqlegendrecalc(int n, out int info, out double[] x, out double[] wkronrod, out double[] wgauss, alglib.xparams _params)
      {
          info = 0;
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          gkq.gkqlegendrecalc(n, ref info, ref x, ref wkronrod, ref wgauss, _params);
      }
      
      /*************************************************************************
      Returns Gauss and Gauss-Kronrod nodes for quadrature with N  points  using
      pre-calculated table. Nodes/weights were  computed  with  accuracy  up  to
      1.0E-32 (if MPFR version of ALGLIB is used). In standard double  precision
      accuracy reduces to something about 2.0E-16 (depending  on your compiler's
      handling of long floating point constants).
  
      INPUT PARAMETERS:
          N           -   number of Kronrod nodes.
                          N can be 15, 21, 31, 41, 51, 61.
  
      OUTPUT PARAMETERS:
          X           -   array[0..N-1] - array of quadrature nodes, ordered in
                          ascending order.
          WKronrod    -   array[0..N-1] - Kronrod weights
          WGauss      -   array[0..N-1] - Gauss weights (interleaved with zeros
                          corresponding to extended Kronrod nodes).
  
  
        -- ALGLIB --
           Copyright 12.05.2009 by Bochkanov Sergey
      *************************************************************************/
      public static void gkqlegendretbl(int n, out double[] x, out double[] wkronrod, out double[] wgauss, out double eps)
      {
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          eps = 0;
          gkq.gkqlegendretbl(n, ref x, ref wkronrod, ref wgauss, ref eps, null);
      }
      
      public static void gkqlegendretbl(int n, out double[] x, out double[] wkronrod, out double[] wgauss, out double eps, alglib.xparams _params)
      {
          x = new double[0];
          wkronrod = new double[0];
          wgauss = new double[0];
          eps = 0;
          gkq.gkqlegendretbl(n, ref x, ref wkronrod, ref wgauss, ref eps, _params);
      }
  
  }
  public partial class alglib
  {
  
  
      /*************************************************************************
      Integration report:
      * TerminationType = completetion code:
          * -5    non-convergence of Gauss-Kronrod nodes
                  calculation subroutine.
          * -1    incorrect parameters were specified
          *  1    OK
      * Rep.NFEV countains number of function calculations
      * Rep.NIntervals contains number of intervals [a,b]
        was partitioned into.
      *************************************************************************/
      public class autogkreport : alglibobject
      {
          //
          // Public declarations
          //
          public int terminationtype { get { return _innerobj.terminationtype; } set { _innerobj.terminationtype = value; } }
          public int nfev { get { return _innerobj.nfev; } set { _innerobj.nfev = value; } }
          public int nintervals { get { return _innerobj.nintervals; } set { _innerobj.nintervals = value; } }
      
          public autogkreport()
          {
              _innerobj = new autogk.autogkreport();
          }
          
          public override alglib.alglibobject make_copy()
          {
              return new autogkreport((autogk.autogkreport)_innerobj.make_copy());
          }
      
          //
          // Although some of declarations below are public, you should not use them
          // They are intended for internal use only
          //
          private autogk.autogkreport _innerobj;
          public autogk.autogkreport innerobj { get { return _innerobj; } }
          public autogkreport(autogk.autogkreport obj)
          {
              _innerobj = obj;
          }
      }
  
  
      /*************************************************************************
      This structure stores state of the integration algorithm.
  
      Although this class has public fields,  they are not intended for external
      use. You should use ALGLIB functions to work with this class:
      * autogksmooth()/AutoGKSmoothW()/... to create objects
      * autogkintegrate() to begin integration
      * autogkresults() to get results
      *************************************************************************/
      public class autogkstate : alglibobject
      {
          //
          // Public declarations
          //
          public bool needf { get { return _innerobj.needf; } set { _innerobj.needf = value; } }
          public double x { get { return _innerobj.x; } set { _innerobj.x = value; } }
          public double xminusa { get { return _innerobj.xminusa; } set { _innerobj.xminusa = value; } }
          public double bminusx { get { return _innerobj.bminusx; } set { _innerobj.bminusx = value; } }
          public double f { get { return _innerobj.f; } set { _innerobj.f = value; } }
      
          public autogkstate()
          {
              _innerobj = new autogk.autogkstate();
          }
          
          public override alglib.alglibobject make_copy()
          {
              return new autogkstate((autogk.autogkstate)_innerobj.make_copy());
          }
      
          //
          // Although some of declarations below are public, you should not use them
          // They are intended for internal use only
          //
          private autogk.autogkstate _innerobj;
          public autogk.autogkstate innerobj { get { return _innerobj; } }
          public autogkstate(autogk.autogkstate obj)
          {
              _innerobj = obj;
          }
      }
      
      /*************************************************************************
      Integration of a smooth function F(x) on a finite interval [a,b].
  
      Fast-convergent algorithm based on a Gauss-Kronrod formula is used. Result
      is calculated with accuracy close to the machine precision.
  
      Algorithm works well only with smooth integrands.  It  may  be  used  with
      continuous non-smooth integrands, but with  less  performance.
  
      It should never be used with integrands which have integrable singularities
      at lower or upper limits - algorithm may crash. Use AutoGKSingular in such
      cases.
  
      INPUT PARAMETERS:
  
gt:         A, B    -   interval boundaries (A<B, A=B or A>B)