alglib 0.1.1

data/ext/alglib/gqgenlaguerre.h

@@ -0,0 +1,69 @@
+/*************************************************************************
+Copyright (c) 2005-2007, Sergey Bochkanov (ALGLIB project).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*************************************************************************/
+
+#ifndef _gqgenlaguerre_h
+#define _gqgenlaguerre_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "gammaf.h"
+
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Laguerre quadrature formula
+
+The algorithm calculates the  nodes  and  weights  of  the  Gauss-Laguerre
+quadrature  formula  on  domain  [0, +infinity)  with  weighting  function
+W(x)=Power(x,Alpha)*Exp(-x).
+
+Input parameters:
+    n       �   a required number of nodes.
+                n >= 1
+    alpha   �   power of the first factor of the weighting function.
+                alpha > -1
+
+Output parameters:
+    x       -   array of nodes.
+                Array whose index ranges from 0 to N-1.
+    w       -   array of weighting coefficients.
+                Array whose index ranges from 0 to N-1.
+
+The algorithm was designed by using information from the QUADRULE library.
+*************************************************************************/
+void buildgausslaguerrequadrature(int n,
+     double alpha,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w);
+
+
+#endif

data/ext/alglib/gqgenlegendre.cpp

@@ -0,0 +1,300 @@
+/*************************************************************************
+Copyright (c) 2005-2007, Sergey Bochkanov (ALGLIB project).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*************************************************************************/
+
+#include <stdafx.h>
+#include <stdio.h>
+#include "gqgenlegendre.h"
+
+static void translategausslegendrepoints(double a,
+     double b,
+     int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w);
+static double f(double x);
+static void testquad();
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Legendre quadrature formula
+
+The  algorithm  calculates  the  nodes  and  weights of the Gauss-Legendre
+quadrature formula on domain [-1, 1].
+
+Input parameters:
+    n   �   a required number of nodes.
+            n>=1.
+
+Output parameters:
+    x   -   array of nodes.
+            Array whose index ranges from 0 to N-1.
+    w   -   array of weighting coefficients.
+            Array whose index ranges from 0 to N-1.
+
+The algorithm was designed by using information from the QUADRULE library.
+*************************************************************************/
+void buildgausslegendrequadrature(int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w)
+{
+    int i;
+    int j;
+    double r;
+    double r1;
+    double p1;
+    double p2;
+    double p3;
+    double dp3;
+
+    x.setbounds(0, n-1);
+    w.setbounds(0, n-1);
+    for(i = 0; i <= (n+1)/2-1; i++)
+    {
+        r = cos(ap::pi()*(4*i+3)/(4*n+2));
+        do
+        {
+            p2 = 0;
+            p3 = 1;
+            for(j = 0; j <= n-1; j++)
+            {
+                p1 = p2;
+                p2 = p3;
+                p3 = ((2*j+1)*r*p2-j*p1)/(j+1);
+            }
+            dp3 = n*(r*p3-p2)/(r*r-1);
+            r1 = r;
+            r = r-p3/dp3;
+        }
+        while(fabs(r-r1)>=ap::machineepsilon*(1+fabs(r))*100);
+        x(i) = r;
+        x(n-1-i) = -r;
+        w(i) = 2/((1-r*r)*dp3*dp3);
+        w(n-1-i) = 2/((1-r*r)*dp3*dp3);
+    }
+}
+
+
+static void translategausslegendrepoints(double a,
+     double b,
+     int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w)
+{
+    int i;
+
+    for(i = 0; i <= n-1; i++)
+    {
+        x(i) = 0.5*(x(i)+1)*(b-a)+a;
+        w(i) = 0.5*w(i)*(b-a);
+    }
+}
+
+
+static double f(double x)
+{
+    double result;
+
+    result = cos(x)*cos(x);
+    return result;
+}
+
+
+static void testquad()
+{
+    double epsilon;
+    double a;
+    double b;
+    ap::real_1d_array x;
+    ap::real_1d_array w;
+    int n;
+    int i;
+    int j;
+    double v1;
+    double v2;
+    double h;
+    double s;
+    double s1;
+    double s2;
+    double s3;
+    double tx;
+    int simpfunccalls;
+    double nodedist;
+    double nodesectstart;
+    double nodesectend;
+    double tmp;
+
+    n = 10;
+    epsilon = 0.000000001;
+    a = -1;
+    b = 1;
+    printf("PRIMARY POINTS TEST\n");
+    v1 = 0;
+    simpfunccalls = 2;
+    s2 = 1;
+    h = b-a;
+    s = f(a)+f(b);
+    do
+    {
+        s3 = s2;
+        h = h/2;
+        s1 = 0;
+        tx = a+h;
+        do
+        {
+            s1 = s1+2*f(tx);
+            simpfunccalls = simpfunccalls+1;
+            tx = tx+2*h;
+        }
+        while(tx<b);
+        s = s+s1;
+        s2 = (s+s1)*h/3;
+        tx = fabs(s3-s2)/15;
+    }
+    while(tx>epsilon);
+    v1 = s2;
+    printf("Simpson (%1ld calls) result %12.8lf\n",
+        long(simpfunccalls),
+        double(v1));
+    buildgausslegendrequadrature(n, x, w);
+    v2 = 0;
+    for(i = 0; i <= n-1; i++)
+    {
+        v2 = v2+w(i)*f(x(i));
+    }
+    printf("Quadrature (%1ld points) result %12.8lf\n",
+        long(n),
+        double(v2));
+    printf("Difference is %5.3le\n",
+        double(fabs(v2-v1)));
+    printf("\n\n\nTRANSLATED POINTS TEST\n");
+    a = 5.2;
+    b = 9.6;
+    v1 = 0;
+    simpfunccalls = 2;
+    s2 = 1;
+    h = b-a;
+    s = f(a)+f(b);
+    do
+    {
+        s3 = s2;
+        h = h/2;
+        s1 = 0;
+        tx = a+h;
+        do
+        {
+            s1 = s1+2*f(tx);
+            simpfunccalls = simpfunccalls+1;
+            tx = tx+2*h;
+        }
+        while(tx<b);
+        s = s+s1;
+        s2 = (s+s1)*h/3;
+        tx = fabs(s3-s2)/15;
+    }
+    while(tx>epsilon);
+    v1 = s2;
+    printf("Simpson (%1ld calls) result %12.8lf\n",
+        long(simpfunccalls),
+        double(v1));
+    buildgausslegendrequadrature(n, x, w);
+    translategausslegendrepoints(a, b, n, x, w);
+    v2 = 0;
+    for(i = 0; i <= n-1; i++)
+    {
+        v2 = v2+w(i)*f(x(i));
+    }
+    printf("Quadrature (%1ld points) result %12.8lf\n",
+        long(n),
+        double(v2));
+    printf("Difference is %5.3le\n",
+        double(fabs(v2-v1)));
+    n = 56;
+    printf("\n\nMIN NODE DISTANCE TEST\n");
+    buildgausslegendrequadrature(n, x, w);
+    for(i = 0; i <= n-1; i++)
+    {
+        for(j = 0; j <= n-2-i; j++)
+        {
+            if( x(j)>=x(j+1) )
+            {
+                tmp = x(j);
+                x(j) = x(j+1);
+                x(j+1) = tmp;
+                tmp = w(j);
+                w(j) = w(j+1);
+                w(j+1) = tmp;
+            }
+        }
+    }
+    for(i = 0; i <= 4; i++)
+    {
+        nodedist = x(n-1)-x(0);
+        nodesectstart = nodedist*(0.2*i-0.5);
+        nodesectend = nodedist*(0.2*(i+1)-0.5);
+        for(j = 0; j <= n-2; j++)
+        {
+            if( x(j)>=nodesectstart&&x(j)<=nodesectend||x(j+1)>=nodesectstart&&x(j+1)<=nodesectend )
+            {
+                if( nodedist>x(j+1)-x(j) )
+                {
+                    nodedist = x(j+1)-x(j);
+                }
+            }
+        }
+        printf("Node distance at [%7.2lf, %7.2lf] is %7.3le\n",
+            double(nodesectstart),
+            double(nodesectend),
+            double(nodedist));
+    }
+    for(i = 0; i <= 4; i++)
+    {
+        tmp = x(n-1)-x(0);
+        nodesectstart = tmp*(0.2*i-0.5);
+        nodesectend = tmp*(0.2*(i+1)-0.5);
+        nodedist = 0;
+        for(j = 0; j <= n-1; j++)
+        {
+            if( x(j)>=nodesectstart&&x(j)<=nodesectend )
+            {
+                if( nodedist<fabs(w(j)) )
+                {
+                    nodedist = fabs(w(j));
+                }
+            }
+        }
+        printf("Max weight at [%7.2lf, %7.2lf] is %7.3le\n",
+            double(nodesectstart),
+            double(nodesectend),
+            double(nodedist));
+    }
+}
+
+
+

data/ext/alglib/gqgenlegendre.h

@@ -0,0 +1,62 @@
+/*************************************************************************
+Copyright (c) 2005-2007, Sergey Bochkanov (ALGLIB project).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*************************************************************************/
+
+#ifndef _gqgenlegendre_h
+#define _gqgenlegendre_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Legendre quadrature formula
+
+The  algorithm  calculates  the  nodes  and  weights of the Gauss-Legendre
+quadrature formula on domain [-1, 1].
+
+Input parameters:
+    n   �   a required number of nodes.
+            n>=1.
+
+Output parameters:
+    x   -   array of nodes.
+            Array whose index ranges from 0 to N-1.
+    w   -   array of weighting coefficients.
+            Array whose index ranges from 0 to N-1.
+
+The algorithm was designed by using information from the QUADRULE library.
+*************************************************************************/
+void buildgausslegendrequadrature(int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w);
+
+
+#endif

data/ext/alglib/gqgenlobatto.cpp

@@ -0,0 +1,305 @@
+/*************************************************************************
+Copyright (c) 2005-2007, Sergey Bochkanov (ALGLIB project).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*************************************************************************/
+
+#include <stdafx.h>
+#include <stdio.h>
+#include "gqgenlobatto.h"
+
+static void testgenerategausslobattoquadrature();
+
+/*************************************************************************
+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 zero moment Mu0
+
+Mu0 = integral(W(x)dx,a,b)
+
+
+Input parameters:
+    Alpha   �   array of coefficients.
+                Array whose index ranges within [0..N-2].
+    Beta    �   array of coefficients.
+                Array whose index ranges within [0..N-2].
+                Zero-indexed element is not used.
+                Beta[I]>0
+    Mu0     �   zero 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:
+    X       �   array of nodes of the quadrature formula (in ascending order).
+                Array whose index ranges within [0..N-1].
+    W       �   array of weights of the quadrature formula.
+                Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the algorithm finished its work successfully.
+    False, if the algorithm of finding the eigenvalues has not converged,
+or one or more of the Beta coefficients is less or equal to 0.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+bool generategausslobattoquadrature(ap::real_1d_array alpha,
+     ap::real_1d_array beta,
+     double mu0,
+     double a,
+     double b,
+     int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w)
+{
+    bool result;
+    int i;
+    ap::real_1d_array d;
+    ap::real_1d_array e;
+    ap::real_2d_array z;
+    double pim1a;
+    double pia;
+    double pim1b;
+    double pib;
+    double t;
+    double a11;
+    double a12;
+    double a21;
+    double a22;
+    double b1;
+    double b2;
+    double alph;
+    double bet;
+
+    if( n<=2 )
+    {
+        result = false;
+        return result;
+    }
+    
+    //
+    // Initialize, D[1:N+1], E[1:N]
+    //
+    n = n-2;
+    d.setbounds(1, n+2);
+    e.setbounds(1, n+1);
+    for(i = 1; i <= n+1; i++)
+    {
+        d(i) = alpha(i-1);
+    }
+    for(i = 1; i <= n; i++)
+    {
+        if( beta(i)<=0 )
+        {
+            result = false;
+            return result;
+        }
+        e(i) = sqrt(beta(i));
+    }
+    
+    //
+    // Caclulate Pn(a), Pn+1(a), Pn(b), Pn+1(b)
+    //
+    beta(0) = 0;
+    pim1a = 0;
+    pia = 1;
+    pim1b = 0;
+    pib = 1;
+    for(i = 1; i <= n+1; i++)
+    {
+        
+        //
+        // Pi(a)
+        //
+        t = (a-alpha(i-1))*pia-beta(i-1)*pim1a;
+        pim1a = pia;
+        pia = t;
+        
+        //
+        // Pi(b)
+        //
+        t = (b-alpha(i-1))*pib-beta(i-1)*pim1b;
+        pim1b = pib;
+        pib = t;
+    }
+    
+    //
+    // Calculate alpha'(n+1), beta'(n+1)
+    //
+    a11 = pia;
+    a12 = pim1a;
+    a21 = pib;
+    a22 = pim1b;
+    b1 = a*pia;
+    b2 = b*pib;
+    if( fabs(a11)>fabs(a21) )
+    {
+        a22 = a22-a12*a21/a11;
+        b2 = b2-b1*a21/a11;
+        bet = b2/a22;
+        alph = (b1-bet*a12)/a11;
+    }
+    else
+    {
+        a12 = a12-a22*a11/a21;
+        b1 = b1-b2*a11/a21;
+        bet = b1/a12;
+        alph = (b2-bet*a22)/a21;
+    }
+    if( bet<0 )
+    {
+        result = false;
+        return result;
+    }
+    d(n+2) = alph;
+    e(n+1) = sqrt(bet);
+    
+    //
+    // EVD
+    //
+    result = tridiagonalevd(d, e, n+2, 3, z);
+    if( !result )
+    {
+        return result;
+    }
+    
+    //
+    // Generate
+    //
+    x.setbounds(0, n+1);
+    w.setbounds(0, n+1);
+    for(i = 1; i <= n+2; i++)
+    {
+        x(i-1) = d(i);
+        w(i-1) = mu0*ap::sqr(z(1,i));
+    }
+    return result;
+}
+
+
+static void testgenerategausslobattoquadrature()
+{
+    ap::real_1d_array alpha;
+    ap::real_1d_array beta;
+    ap::real_1d_array x;
+    ap::real_1d_array w;
+    double err;
+    int i;
+
+    printf("TESTING GAUSS-LOBATTO QUADRATURES GENERATION\n");
+    
+    //
+    // first test
+    //
+    alpha.setbounds(0, 1);
+    beta.setbounds(0, 1);
+    alpha(0) = 0;
+    alpha(1) = 0;
+    beta(0) = 0;
+    beta(1) = double(1*1)/double(4*1*1-1);
+    generategausslobattoquadrature(alpha, beta, 2.0, double(-1), double(+1), 3, x, w);
+    err = 0;
+    err = ap::maxreal(err, fabs(x(0)+1));
+    err = ap::maxreal(err, fabs(x(1)));
+    err = ap::maxreal(err, fabs(x(2)-1));
+    err = ap::maxreal(err, fabs(w(0)-double(1)/double(3)));
+    err = ap::maxreal(err, fabs(w(1)-double(4)/double(3)));
+    err = ap::maxreal(err, fabs(w(2)-double(1)/double(3)));
+    printf("First test (Gauss-Lobatto 2): error is %6.3le\n",
+        double(err));
+    
+    //
+    // second test
+    //
+    alpha.setbounds(0, 2);
+    beta.setbounds(0, 2);
+    alpha(0) = 0;
+    alpha(1) = 0;
+    alpha(2) = 0;
+    beta(0) = 0;
+    beta(1) = double(1*1)/double(4*1*1-1);
+    beta(2) = double(2*2)/double(4*2*2-1);
+    generategausslobattoquadrature(alpha, beta, 2.0, double(-1), double(+1), 4, x, w);
+    err = 0;
+    err = ap::maxreal(err, fabs(x(0)+1));
+    err = ap::maxreal(err, fabs(x(1)+sqrt(double(5))/5));
+    err = ap::maxreal(err, fabs(x(2)-sqrt(double(5))/5));
+    err = ap::maxreal(err, fabs(x(3)-1));
+    err = ap::maxreal(err, fabs(w(0)-double(1)/double(6)));
+    err = ap::maxreal(err, fabs(w(1)-double(5)/double(6)));
+    err = ap::maxreal(err, fabs(w(2)-double(5)/double(6)));
+    err = ap::maxreal(err, fabs(w(3)-double(1)/double(6)));
+    printf("Second test (Gauss-Lobatto 4): error is %6.3le\n",
+        double(err));
+    
+    //
+    // third test
+    //
+    alpha.setbounds(0, 4);
+    beta.setbounds(0, 4);
+    alpha(0) = 0;
+    alpha(1) = 0;
+    alpha(2) = 0;
+    alpha(3) = 0;
+    alpha(4) = 0;
+    beta(0) = 0;
+    beta(1) = double(1*1)/double(4*1*1-1);
+    beta(2) = double(2*2)/double(4*2*2-1);
+    beta(3) = double(3*3)/double(4*3*3-1);
+    beta(4) = double(4*4)/double(4*4*4-1);
+    generategausslobattoquadrature(alpha, beta, 2.0, double(-1), double(+1), 6, x, w);
+    err = 0;
+    err = ap::maxreal(err, fabs(x(0)+1));
+    err = ap::maxreal(err, fabs(x(1)+sqrt((7+2*sqrt(double(7)))/21)));
+    err = ap::maxreal(err, fabs(x(2)+sqrt((7-2*sqrt(double(7)))/21)));
+    err = ap::maxreal(err, fabs(x(3)-sqrt((7-2*sqrt(double(7)))/21)));
+    err = ap::maxreal(err, fabs(x(4)-sqrt((7+2*sqrt(double(7)))/21)));
+    err = ap::maxreal(err, fabs(x(5)-1));
+    err = ap::maxreal(err, fabs(w(0)-double(1)/double(15)));
+    err = ap::maxreal(err, fabs(w(1)-(14-sqrt(double(7)))/30));
+    err = ap::maxreal(err, fabs(w(2)-(14+sqrt(double(7)))/30));
+    err = ap::maxreal(err, fabs(w(3)-(14+sqrt(double(7)))/30));
+    err = ap::maxreal(err, fabs(w(4)-(14-sqrt(double(7)))/30));
+    err = ap::maxreal(err, fabs(w(5)-double(1)/double(15)));
+    printf("Third test (Gauss-Lobatto 6): error is %6.3le\n",
+        double(err));
+}
+
+
+