alglib 0.1.1

data/ext/alglib/gqgenhermite.h

@@ -0,0 +1,63 @@
+/*************************************************************************
+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 _gqgenhermite_h
+#define _gqgenhermite_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Hermite quadrature formula
+
+The  algorithm  calculates  the  nodes  and  weights  of the Gauss-Hermite
+quadrature  formula on domain  (-infinity, +infinity) with weight function
+W(x)=Exp(-x*x).
+
+Input parameters:
+    n   �   a required number of nodes.
+            1 <= n <= 190.
+
+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 buildgausshermitequadrature(int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w);
+
+
+#endif

data/ext/alglib/gqgenjacobi.cpp

@@ -0,0 +1,297 @@
+/*************************************************************************
+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 "gqgenjacobi.h"
+
+static void testquad();
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Jacobi quadrature formula
+
+The algorithm  calculates  the  nodes  and  weights  of  the  Gauss-Jacobi
+quadrature    formula    on    domain   [-1, 1]   with   weight   function
+W(x)=Power(1-x,Alpha)*Power(1+x,Beta).
+
+Input parameters:
+    n       �   a required number of nodes.
+                n>=1.
+    alpha   �   power of the first factor of the weighting function.
+                alpha > -1
+    beta    �   power of the second factor of the weighting function.
+                beta > -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 buildgaussjacobiquadrature(int n,
+     double alpha,
+     double beta,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w)
+{
+    int i;
+    int j;
+    double r;
+    double r1;
+    double t1;
+    double t2;
+    double t3;
+    double p1;
+    double p2;
+    double p3;
+    double pp;
+    double an;
+    double bn;
+    double a;
+    double b;
+    double c;
+    double tmpsgn;
+    double alfbet;
+    double temp;
+    int its;
+
+    x.setbounds(0, n-1);
+    w.setbounds(0, n-1);
+    for(i = 0; i <= n-1; i++)
+    {
+        if( i==0 )
+        {
+            an = alpha/n;
+            bn = beta/n;
+            t1 = (1+alpha)*(2.78/(4+n*n)+0.768*an/n);
+            t2 = 1+1.48*an+0.96*bn+0.452*an*an+0.83*an*bn;
+            r = (t2-t1)/t2;
+        }
+        else
+        {
+            if( i==1 )
+            {
+                t1 = (4.1+alpha)/((1+alpha)*(1+0.156*alpha));
+                t2 = 1+0.06*(n-8)*(1+0.12*alpha)/n;
+                t3 = 1+0.012*beta*(1+0.25*fabs(alpha))/n;
+                r = r-t1*t2*t3*(1-r);
+            }
+            else
+            {
+                if( i==2 )
+                {
+                    t1 = (1.67+0.28*alpha)/(1+0.37*alpha);
+                    t2 = 1+0.22*(n-8)/n;
+                    t3 = 1+8*beta/((6.28+beta)*n*n);
+                    r = r-t1*t2*t3*(x(0)-r);
+                }
+                else
+                {
+                    if( i<n-2 )
+                    {
+                        r = 3*x(i-1)-3*x(i-2)+x(i-3);
+                    }
+                    else
+                    {
+                        if( i==n-2 )
+                        {
+                            t1 = (1+0.235*beta)/(0.766+0.119*beta);
+                            t2 = 1/(1+0.639*(n-4)/(1+0.71*(n-4)));
+                            t3 = 1/(1+20*alpha/((7.5+alpha)*n*n));
+                            r = r+t1*t2*t3*(r-x(i-2));
+                        }
+                        else
+                        {
+                            if( i==n-1 )
+                            {
+                                t1 = (1+0.37*beta)/(1.67+0.28*beta);
+                                t2 = 1/(1+0.22*(n-8)/n);
+                                t3 = 1/(1+8*alpha/((6.28+alpha)*n*n));
+                                r = r+t1*t2*t3*(r-x(i-2));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        alfbet = alpha+beta;
+        do
+        {
+            temp = 2+alfbet;
+            p1 = (alpha-beta+temp*r)*0.5;
+            p2 = 1;
+            for(j = 2; j <= n; j++)
+            {
+                p3 = p2;
+                p2 = p1;
+                temp = 2*j+alfbet;
+                a = 2*j*(j+alfbet)*(temp-2);
+                b = (temp-1)*(alpha*alpha-beta*beta+temp*(temp-2)*r);
+                c = 2*(j-1+alpha)*(j-1+beta)*temp;
+                p1 = (b*p2-c*p3)/a;
+            }
+            pp = (n*(alpha-beta-temp*r)*p1+2*(n+alpha)*(n+beta)*p2)/(temp*(1-r*r));
+            r1 = r;
+            r = r1-p1/pp;
+        }
+        while(fabs(r-r1)>=ap::machineepsilon*(1+fabs(r))*100);
+        x(i) = r;
+        w(i) = exp(lngamma(alpha+n, tmpsgn)+lngamma(beta+n, tmpsgn)-lngamma(double(n+1), tmpsgn)-lngamma(n+alfbet+1, tmpsgn))*temp*pow(double(2), alfbet)/(pp*p2);
+    }
+}
+
+
+static void testquad()
+{
+    double alpha;
+    double beta;
+    ap::real_1d_array x;
+    ap::real_1d_array w;
+    ap::real_1d_array xleg;
+    ap::real_1d_array wleg;
+    int n;
+    int i;
+    int j;
+    double tmp;
+    double valjac;
+    double valsim;
+    double nodedist;
+    double nodesectstart;
+    double nodesectend;
+    double err;
+    double nodeerr;
+    double weighterr;
+
+    n = 56;
+    alpha = -0.5;
+    beta = -0.5;
+    printf("CHEBYSHEV TEST\n");
+    buildgaussjacobiquadrature(n, alpha, beta, 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;
+            }
+        }
+    }
+    nodeerr = 0;
+    weighterr = 0;
+    for(i = 0; i <= n-1; i++)
+    {
+        err = fabs(ap::pi()/n-w(i));
+        if( err>weighterr )
+        {
+            weighterr = err;
+        }
+        err = fabs(x(n-1-i)-cos(ap::pi()*(i+0.5)/n));
+        if( err>nodeerr )
+        {
+            nodeerr = err;
+        }
+    }
+    printf("Node error is %5.3le\nWeight error is %5.3le\n",
+        double(nodeerr),
+        double(weighterr));
+    n = 56;
+    alpha = -0.95;
+    beta = -0.95;
+    printf("\n\nMIN NODE DISTANCE AND WEIGHT HISTOGRAM TEST\n");
+    buildgaussjacobiquadrature(n, alpha, beta, 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++)
+    {
+        nodesectstart = 0.2*i*2-1;
+        nodesectend = 0.2*(i+1)*2-1;
+        nodedist = 2;
+        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 [%5.2lf, %5.2lf] is %5.3le\n",
+            double(nodesectstart),
+            double(nodesectend),
+            double(nodedist));
+    }
+    for(i = 0; i <= 4; i++)
+    {
+        nodesectstart = 0.2*i*2-1;
+        nodesectend = 0.2*(i+1)*2-1;
+        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 [%5.2lf, %5.2lf] is %5.3le\n",
+            double(nodesectstart),
+            double(nodesectend),
+            double(nodedist));
+    }
+}
+
+
+

data/ext/alglib/gqgenjacobi.h

@@ -0,0 +1,72 @@
+/*************************************************************************
+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 _gqgenjacobi_h
+#define _gqgenjacobi_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "gammaf.h"
+
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Jacobi quadrature formula
+
+The algorithm  calculates  the  nodes  and  weights  of  the  Gauss-Jacobi
+quadrature    formula    on    domain   [-1, 1]   with   weight   function
+W(x)=Power(1-x,Alpha)*Power(1+x,Beta).
+
+Input parameters:
+    n       �   a required number of nodes.
+                n>=1.
+    alpha   �   power of the first factor of the weighting function.
+                alpha > -1
+    beta    �   power of the second factor of the weighting function.
+                beta > -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 buildgaussjacobiquadrature(int n,
+     double alpha,
+     double beta,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w);
+
+
+#endif

data/ext/alglib/gqgenlaguerre.cpp

@@ -0,0 +1,265 @@
+/*************************************************************************
+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 "gqgenlaguerre.h"
+
+static double f(double x);
+static void testquad();
+
+/*************************************************************************
+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)
+{
+    int i;
+    int j;
+    double r;
+    double r1;
+    double p1;
+    double p2;
+    double p3;
+    double dp3;
+    double tsg;
+
+    x.setbounds(0, n-1);
+    w.setbounds(0, n-1);
+    for(i = 0; i <= n-1; i++)
+    {
+        if( i==0 )
+        {
+            r = (1+alpha)*(3+0.92*alpha)/(1+2.4*n+1.8*alpha);
+        }
+        else
+        {
+            if( i==1 )
+            {
+                r = r+(15+6.25*alpha)/(1+0.9*alpha+2.5*n);
+            }
+            else
+            {
+                r = r+((1+2.55*(i-1))/(1.9*(i-1))+1.26*(i-1)*alpha/(1+3.5*(i-1)))/(1+0.3*alpha)*(r-x(i-2));
+            }
+        }
+        do
+        {
+            p2 = 0;
+            p3 = 1;
+            for(j = 0; j <= n-1; j++)
+            {
+                p1 = p2;
+                p2 = p3;
+                p3 = ((-r+2*j+alpha+1)*p2-(j+alpha)*p1)/(j+1);
+            }
+            dp3 = (n*p3-(n+alpha)*p2)/r;
+            r1 = r;
+            r = r-p3/dp3;
+        }
+        while(fabs(r-r1)>=ap::machineepsilon*(1+fabs(r))*100);
+        x(i) = r;
+        w(i) = -exp(lngamma(alpha+n, tsg)-lngamma(double(n), tsg))/(dp3*n*p2);
+    }
+}
+
+
+static double f(double x)
+{
+    double result;
+
+    result = sin(x);
+    return result;
+}
+
+
+static void testquad()
+{
+    double alpha;
+    double totalepsilon;
+    double partialepsilon;
+    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 lessthanepscnt;
+    double nodedist;
+    double nodesectstart;
+    double nodesectend;
+    double tmp;
+
+    n = 10;
+    alpha = 2.3;
+    totalepsilon = 0.001;
+    a = 0;
+    b = 1;
+    v1 = 0;
+    lessthanepscnt = 0;
+    partialepsilon = totalepsilon/50;
+    while(lessthanepscnt<5)
+    {
+        s2 = 1;
+        h = b-a;
+        s = pow(a, alpha)*exp(-a)*f(a)+pow(b, alpha)*exp(-b)*f(b);
+        do
+        {
+            s3 = s2;
+            h = h/2;
+            s1 = 0;
+            tx = a+h;
+            do
+            {
+                s1 = s1+2*pow(tx, alpha)*exp(-tx)*f(tx);
+                tx = tx+2*h;
+            }
+            while(tx<b);
+            s = s+s1;
+            s2 = (s+s1)*h/3;
+            tx = fabs(s3-s2)/15;
+        }
+        while(tx>partialepsilon);
+        if( fabs(s2)<totalepsilon )
+        {
+            lessthanepscnt = lessthanepscnt+1;
+        }
+        v1 = v1+s2;
+        a = a+1;
+        b = b+1;
+    }
+    printf("Simpson result %12.8lf\n",
+        double(v1));
+    buildgausslaguerrequadrature(n, alpha, 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");
+    alpha = 0.4;
+    buildgausslaguerrequadrature(n, alpha, 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);
+        nodesectstart = nodedist*0.2*i;
+        nodesectend = nodedist*0.2*(i+1);
+        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);
+        nodesectstart = tmp*0.2*i;
+        nodesectend = tmp*0.2*(i+1);
+        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));
+    }
+}
+
+
+