alglib 0.1.1

data/ext/alglib/gqgenlobatto.h

@@ -0,0 +1,97 @@
+/*************************************************************************
+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 _gqgenlobatto_h
+#define _gqgenlobatto_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "blas.h"
+#include "rotations.h"
+#include "tdevd.h"
+
+
+/*************************************************************************
+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);
+
+
+#endif

data/ext/alglib/gqgenradau.cpp

@@ -0,0 +1,232 @@
+/*************************************************************************
+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 "gqgenradau.h"
+
+static void testgenerategaussradauquadrature();
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Radua 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 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-1].
+                Zero-indexed element is not used.
+                Beta[I]>0
+    Mu0     �   zero 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:
+    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 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 generategaussradauquadrature(ap::real_1d_array alpha,
+     ap::real_1d_array beta,
+     double mu0,
+     double a,
+     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 polim1;
+    double poli;
+    double t;
+
+    if( n<2 )
+    {
+        result = false;
+        return result;
+    }
+    
+    //
+    // Initialize, D[1:N], E[1:N]
+    //
+    n = n-1;
+    d.setbounds(1, n+1);
+    e.setbounds(1, n);
+    for(i = 1; i <= n; i++)
+    {
+        d(i) = alpha(i-1);
+        if( beta(i)<=0 )
+        {
+            result = false;
+            return result;
+        }
+        e(i) = sqrt(beta(i));
+    }
+    
+    //
+    // Caclulate Pn(a), Pn-1(a), and D[N+1]
+    //
+    beta(0) = 0;
+    polim1 = 0;
+    poli = 1;
+    for(i = 1; i <= n; i++)
+    {
+        t = (a-alpha(i-1))*poli-beta(i-1)*polim1;
+        polim1 = poli;
+        poli = t;
+    }
+    d(n+1) = a-beta(n)*polim1/poli;
+    
+    //
+    // EVD
+    //
+    result = tridiagonalevd(d, e, n+1, 3, z);
+    if( !result )
+    {
+        return result;
+    }
+    
+    //
+    // Generate
+    //
+    x.setbounds(0, n);
+    w.setbounds(0, n);
+    for(i = 1; i <= n+1; i++)
+    {
+        x(i-1) = d(i);
+        w(i-1) = mu0*ap::sqr(z(1,i));
+    }
+    return result;
+}
+
+
+static void testgenerategaussradauquadrature()
+{
+    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-RADAU QUADRATURES GENERATION\n");
+    
+    //
+    // first test
+    //
+    alpha.setbounds(0, 0);
+    beta.setbounds(0, 1);
+    alpha(0) = 0;
+    beta(0) = 0;
+    beta(1) = double(1*1)/double(4*1*1-1);
+    generategaussradauquadrature(alpha, beta, 2.0, double(-1), 2, x, w);
+    err = 0;
+    err = ap::maxreal(err, fabs(x(0)+1));
+    err = ap::maxreal(err, fabs(x(1)-double(1)/double(3)));
+    err = ap::maxreal(err, fabs(w(0)-0.5));
+    err = ap::maxreal(err, fabs(w(1)-1.5));
+    printf("First test (Gauss-Radau 2): error is %6.3le\n",
+        double(err));
+    
+    //
+    // second test
+    //
+    alpha.setbounds(0, 1);
+    beta.setbounds(0, 2);
+    alpha(0) = 0;
+    alpha(1) = 0;
+    for(i = 0; i <= 2; i++)
+    {
+        beta(i) = ap::sqr(double(i))/(4*ap::sqr(double(i))-1);
+    }
+    generategaussradauquadrature(alpha, beta, 2.0, double(-1), 3, x, w);
+    err = 0;
+    err = ap::maxreal(err, fabs(x(0)+1));
+    err = ap::maxreal(err, fabs(x(1)-(1-sqrt(double(6)))/5));
+    err = ap::maxreal(err, fabs(x(2)-(1+sqrt(double(6)))/5));
+    err = ap::maxreal(err, fabs(w(0)-double(2)/double(9)));
+    err = ap::maxreal(err, fabs(w(1)-(16+sqrt(double(6)))/18));
+    err = ap::maxreal(err, fabs(w(2)-(16-sqrt(double(6)))/18));
+    printf("Second test (Gauss-Radau 3): error is %6.3le\n",
+        double(err));
+    
+    //
+    // third test
+    //
+    alpha.setbounds(0, 1);
+    beta.setbounds(0, 2);
+    alpha(0) = 0;
+    alpha(1) = 0;
+    for(i = 0; i <= 2; i++)
+    {
+        beta(i) = ap::sqr(double(i))/(4*ap::sqr(double(i))-1);
+    }
+    generategaussradauquadrature(alpha, beta, 2.0, double(+1), 3, x, w);
+    err = 0;
+    err = ap::maxreal(err, fabs(x(2)-1));
+    err = ap::maxreal(err, fabs(x(1)+(1-sqrt(double(6)))/5));
+    err = ap::maxreal(err, fabs(x(0)+(1+sqrt(double(6)))/5));
+    err = ap::maxreal(err, fabs(w(2)-double(2)/double(9)));
+    err = ap::maxreal(err, fabs(w(1)-(16+sqrt(double(6)))/18));
+    err = ap::maxreal(err, fabs(w(0)-(16-sqrt(double(6)))/18));
+    printf("Second test (Gauss-Radau 3, at point b): error is %6.3le\n",
+        double(err));
+}
+
+
+

data/ext/alglib/gqgenradau.h

@@ -0,0 +1,95 @@
+/*************************************************************************
+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 _gqgenradau_h
+#define _gqgenradau_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "blas.h"
+#include "rotations.h"
+#include "tdevd.h"
+
+
+/*************************************************************************
+Computation of nodes and weights for a Gauss-Radua 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 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-1].
+                Zero-indexed element is not used.
+                Beta[I]>0
+    Mu0     �   zero 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:
+    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 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 generategaussradauquadrature(ap::real_1d_array alpha,
+     ap::real_1d_array beta,
+     double mu0,
+     double a,
+     int n,
+     ap::real_1d_array& x,
+     ap::real_1d_array& w);
+
+
+#endif

data/ext/alglib/hbisinv.cpp

@@ -0,0 +1,480 @@
+/*************************************************************************
+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 "hbisinv.h"
+
+/*************************************************************************
+Subroutine for finding the eigenvalues (and eigenvectors) of  a  Hermitian
+matrix  in  a  given half-interval (A, B] by using a bisection and inverse
+iteration
+
+Input parameters:
+    A       -   Hermitian matrix which is given  by  its  upper  or  lower
+                triangular  part.  Array  whose   indexes   range   within
+                [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    ZNeeded -   flag controlling whether the eigenvectors  are  needed  or
+                not. If ZNeeded is equal to:
+                 * 0, the eigenvectors are not returned;
+                 * 1, the eigenvectors are returned.
+    IsUpperA -  storage format of matrix A.
+    B1, B2 -    half-interval (B1, B2] to search eigenvalues in.
+
+Output parameters:
+    M       -   number of eigenvalues found in a given half-interval, M>=0
+    W       -   array of the eigenvalues found.
+                Array whose index ranges within [0..M-1].
+    Z       -   if ZNeeded is equal to:
+                 * 0, Z hasn�t changed;
+                 * 1, Z contains eigenvectors.
+                Array whose indexes range within [0..N-1, 0..M-1].
+                The eigenvectors are stored in the matrix columns.
+
+Result:
+    True, if successful. M contains the number of eigenvalues in the given
+    half-interval (could be equal to 0), W contains the eigenvalues,
+    Z contains the eigenvectors (if needed).
+
+    False, if the bisection method subroutine  wasn't  able  to  find  the
+    eigenvalues  in  the  given  interval  or  if  the  inverse  iteration
+    subroutine  wasn't  able  to  find all the corresponding eigenvectors.
+    In that case, the eigenvalues and eigenvectors are not returned, M  is
+    equal to 0.
+
+Note:
+    eigen vectors of Hermitian matrix are defined up to multiplication  by
+    a complex number L, such as |L|=1.
+
+  -- ALGLIB --
+     Copyright 07.01.2006, 24.03.2007 by Bochkanov Sergey.
+*************************************************************************/
+bool hmatrixevdr(ap::complex_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     double b1,
+     double b2,
+     int& m,
+     ap::real_1d_array& w,
+     ap::complex_2d_array& z)
+{
+    bool result;
+    ap::complex_2d_array q;
+    ap::real_2d_array t;
+    ap::complex_1d_array tau;
+    ap::real_1d_array e;
+    ap::real_1d_array work;
+    int i;
+    int k;
+    double v;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "HermitianEigenValuesAndVectorsInInterval: incorrect ZNeeded");
+    
+    //
+    // Reduce to tridiagonal form
+    //
+    hmatrixtd(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        hmatrixtdunpackq(a, n, isupper, tau, q);
+        zneeded = 2;
+    }
+    
+    //
+    // Bisection and inverse iteration
+    //
+    result = smatrixtdevdr(w, e, n, zneeded, b1, b2, m, t);
+    
+    //
+    // Eigenvectors are needed
+    // Calculate Z = Q*T = Re(Q)*T + i*Im(Q)*T
+    //
+    if( result&&zneeded!=0&&m!=0 )
+    {
+        work.setbounds(0, m-1);
+        z.setbounds(0, n-1, 0, m-1);
+        for(i = 0; i <= n-1; i++)
+        {
+            
+            //
+            // Calculate real part
+            //
+            for(k = 0; k <= m-1; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 0; k <= n-1; k++)
+            {
+                v = q(i,k).x;
+                ap::vadd(&work(0), &t(k, 0), ap::vlen(0,m-1), v);
+            }
+            for(k = 0; k <= m-1; k++)
+            {
+                z(i,k).x = work(k);
+            }
+            
+            //
+            // Calculate imaginary part
+            //
+            for(k = 0; k <= m-1; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 0; k <= n-1; k++)
+            {
+                v = q(i,k).y;
+                ap::vadd(&work(0), &t(k, 0), ap::vlen(0,m-1), v);
+            }
+            for(k = 0; k <= m-1; k++)
+            {
+                z(i,k).y = work(k);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Subroutine for finding the eigenvalues and  eigenvectors  of  a  Hermitian
+matrix with given indexes by using bisection and inverse iteration methods
+
+Input parameters:
+    A       -   Hermitian matrix which is given  by  its  upper  or  lower
+                triangular part.
+                Array whose indexes range within [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    ZNeeded -   flag controlling whether the eigenvectors  are  needed  or
+                not. If ZNeeded is equal to:
+                 * 0, the eigenvectors are not returned;
+                 * 1, the eigenvectors are returned.
+    IsUpperA -  storage format of matrix A.
+    I1, I2 -    index interval for searching (from I1 to I2).
+                0 <= I1 <= I2 <= N-1.
+
+Output parameters:
+    W       -   array of the eigenvalues found.
+                Array whose index ranges within [0..I2-I1].
+    Z       -   if ZNeeded is equal to:
+                 * 0, Z hasn�t changed;
+                 * 1, Z contains eigenvectors.
+                Array whose indexes range within [0..N-1, 0..I2-I1].
+                In  that  case,  the eigenvectors are stored in the matrix
+                columns.
+
+Result:
+    True, if successful. W contains the eigenvalues, Z contains the
+    eigenvectors (if needed).
+
+    False, if the bisection method subroutine  wasn't  able  to  find  the
+    eigenvalues  in  the  given  interval  or  if  the  inverse  iteration
+    subroutine wasn't able to find  all  the  corresponding  eigenvectors.
+    In that case, the eigenvalues and eigenvectors are not returned.
+
+Note:
+    eigen vectors of Hermitian matrix are defined up to multiplication  by
+    a complex number L, such as |L|=1.
+
+  -- ALGLIB --
+     Copyright 07.01.2006, 24.03.2007 by Bochkanov Sergey.
+*************************************************************************/
+bool hmatrixevdi(ap::complex_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     int i1,
+     int i2,
+     ap::real_1d_array& w,
+     ap::complex_2d_array& z)
+{
+    bool result;
+    ap::complex_2d_array q;
+    ap::real_2d_array t;
+    ap::complex_1d_array tau;
+    ap::real_1d_array e;
+    ap::real_1d_array work;
+    int i;
+    int k;
+    double v;
+    int m;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "HermitianEigenValuesAndVectorsByIndexes: incorrect ZNeeded");
+    
+    //
+    // Reduce to tridiagonal form
+    //
+    hmatrixtd(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        hmatrixtdunpackq(a, n, isupper, tau, q);
+        zneeded = 2;
+    }
+    
+    //
+    // Bisection and inverse iteration
+    //
+    result = smatrixtdevdi(w, e, n, zneeded, i1, i2, t);
+    
+    //
+    // Eigenvectors are needed
+    // Calculate Z = Q*T = Re(Q)*T + i*Im(Q)*T
+    //
+    m = i2-i1+1;
+    if( result&&zneeded!=0 )
+    {
+        work.setbounds(0, m-1);
+        z.setbounds(0, n-1, 0, m-1);
+        for(i = 0; i <= n-1; i++)
+        {
+            
+            //
+            // Calculate real part
+            //
+            for(k = 0; k <= m-1; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 0; k <= n-1; k++)
+            {
+                v = q(i,k).x;
+                ap::vadd(&work(0), &t(k, 0), ap::vlen(0,m-1), v);
+            }
+            for(k = 0; k <= m-1; k++)
+            {
+                z(i,k).x = work(k);
+            }
+            
+            //
+            // Calculate imaginary part
+            //
+            for(k = 0; k <= m-1; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 0; k <= n-1; k++)
+            {
+                v = q(i,k).y;
+                ap::vadd(&work(0), &t(k, 0), ap::vlen(0,m-1), v);
+            }
+            for(k = 0; k <= m-1; k++)
+            {
+                z(i,k).y = work(k);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool hermitianeigenvaluesandvectorsininterval(ap::complex_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     double b1,
+     double b2,
+     int& m,
+     ap::real_1d_array& w,
+     ap::complex_2d_array& z)
+{
+    bool result;
+    ap::complex_2d_array q;
+    ap::real_2d_array t;
+    ap::complex_1d_array tau;
+    ap::real_1d_array e;
+    ap::real_1d_array work;
+    int i;
+    int k;
+    double v;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "HermitianEigenValuesAndVectorsInInterval: incorrect ZNeeded");
+    
+    //
+    // Reduce to tridiagonal form
+    //
+    hermitiantotridiagonal(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        unpackqfromhermitiantridiagonal(a, n, isupper, tau, q);
+        zneeded = 2;
+    }
+    
+    //
+    // Bisection and inverse iteration
+    //
+    result = tridiagonaleigenvaluesandvectorsininterval(w, e, n, zneeded, b1, b2, m, t);
+    
+    //
+    // Eigenvectors are needed
+    // Calculate Z = Q*T = Re(Q)*T + i*Im(Q)*T
+    //
+    if( result&&zneeded!=0&&m!=0 )
+    {
+        work.setbounds(1, m);
+        z.setbounds(1, n, 1, m);
+        for(i = 1; i <= n; i++)
+        {
+            
+            //
+            // Calculate real part
+            //
+            for(k = 1; k <= m; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 1; k <= n; k++)
+            {
+                v = q(i,k).x;
+                ap::vadd(&work(1), &t(k, 1), ap::vlen(1,m), v);
+            }
+            for(k = 1; k <= m; k++)
+            {
+                z(i,k).x = work(k);
+            }
+            
+            //
+            // Calculate imaginary part
+            //
+            for(k = 1; k <= m; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 1; k <= n; k++)
+            {
+                v = q(i,k).y;
+                ap::vadd(&work(1), &t(k, 1), ap::vlen(1,m), v);
+            }
+            for(k = 1; k <= m; k++)
+            {
+                z(i,k).y = work(k);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool hermitianeigenvaluesandvectorsbyindexes(ap::complex_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     int i1,
+     int i2,
+     ap::real_1d_array& w,
+     ap::complex_2d_array& z)
+{
+    bool result;
+    ap::complex_2d_array q;
+    ap::real_2d_array t;
+    ap::complex_1d_array tau;
+    ap::real_1d_array e;
+    ap::real_1d_array work;
+    int i;
+    int k;
+    double v;
+    int m;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "HermitianEigenValuesAndVectorsByIndexes: incorrect ZNeeded");
+    
+    //
+    // Reduce to tridiagonal form
+    //
+    hermitiantotridiagonal(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        unpackqfromhermitiantridiagonal(a, n, isupper, tau, q);
+        zneeded = 2;
+    }
+    
+    //
+    // Bisection and inverse iteration
+    //
+    result = tridiagonaleigenvaluesandvectorsbyindexes(w, e, n, zneeded, i1, i2, t);
+    
+    //
+    // Eigenvectors are needed
+    // Calculate Z = Q*T = Re(Q)*T + i*Im(Q)*T
+    //
+    m = i2-i1+1;
+    if( result&&zneeded!=0 )
+    {
+        work.setbounds(1, m);
+        z.setbounds(1, n, 1, m);
+        for(i = 1; i <= n; i++)
+        {
+            
+            //
+            // Calculate real part
+            //
+            for(k = 1; k <= m; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 1; k <= n; k++)
+            {
+                v = q(i,k).x;
+                ap::vadd(&work(1), &t(k, 1), ap::vlen(1,m), v);
+            }
+            for(k = 1; k <= m; k++)
+            {
+                z(i,k).x = work(k);
+            }
+            
+            //
+            // Calculate imaginary part
+            //
+            for(k = 1; k <= m; k++)
+            {
+                work(k) = 0;
+            }
+            for(k = 1; k <= n; k++)
+            {
+                v = q(i,k).y;
+                ap::vadd(&work(1), &t(k, 1), ap::vlen(1,m), v);
+            }
+            for(k = 1; k <= m; k++)
+            {
+                z(i,k).y = work(k);
+            }
+        }
+    }
+    return result;
+}
+
+
+