alglib 0.1.1

data/ext/alglib/sinverse.h

@@ -0,0 +1,138 @@
+/*************************************************************************
+Copyright (c) 1992-2007 The University of Tennessee.  All rights reserved.
+
+Contributors:
+    * Sergey Bochkanov (ALGLIB project). Translation from FORTRAN to
+      pseudocode.
+
+See subroutines comments for additional copyrights.
+
+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 _sinverse_h
+#define _sinverse_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "sblas.h"
+#include "ldlt.h"
+
+
+/*************************************************************************
+Inversion of a symmetric indefinite matrix
+
+The algorithm gets an LDLT-decomposition as an input, generates matrix A^-1
+and saves the lower or upper triangle of an inverse matrix depending on the
+input (U*D*U' or L*D*L').
+
+Input parameters:
+    A       -   LDLT-decomposition of the matrix,
+                Output of subroutine SMatrixLDLT.
+    N       -   size of matrix A.
+    IsUpper -   storage format. If IsUpper = True, then the symmetric matrix
+                is given as decomposition A = U*D*U' and this decomposition
+                is stored in the upper triangle of matrix A and on the main
+                diagonal, and the lower triangle of matrix A is not used.
+    Pivots  -   a table of permutations, output of subroutine SMatrixLDLT.
+
+Output parameters:
+    A       -   inverse of the matrix, whose LDLT-decomposition was stored
+                in matrix A as a subroutine input.
+                Array with elements [0..N-1, 0..N-1].
+                If IsUpper = True, then A contains the upper triangle of
+                matrix A^-1, and the elements below the main diagonal are
+                not used nor changed. The same applies if IsUpper = False.
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrix is singular and could not be inverted.
+
+  -- LAPACK routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     March 31, 1993
+*************************************************************************/
+bool smatrixldltinverse(ap::real_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     int n,
+     bool isupper);
+
+
+/*************************************************************************
+Inversion of a symmetric indefinite matrix
+
+Given a lower or upper triangle of matrix A, the algorithm generates
+matrix A^-1 and saves the lower or upper triangle depending on the input.
+
+Input parameters:
+    A       -   matrix to be inverted (upper or lower triangle).
+                Array with elements [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   storage format. If IsUpper = True, then the upper
+                triangle of matrix A is given, otherwise the lower
+                triangle is given.
+
+Output parameters:
+    A       -   inverse of matrix A.
+                Array with elements [0..N-1, 0..N-1].
+                If IsUpper = True, then A contains the upper triangle of
+                matrix A^-1, and the elements below the main diagonal are
+                not used nor changed.
+                The same applies if IsUpper = False.
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrix is singular and could not be inverted.
+
+  -- LAPACK routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     March 31, 1993
+*************************************************************************/
+bool smatrixinverse(ap::real_2d_array& a, int n, bool isupper);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool inverseldlt(ap::real_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     int n,
+     bool isupper);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool inversesymmetricindefinite(ap::real_2d_array& a, int n, bool isupper);
+
+
+#endif

data/ext/alglib/spddet.cpp

@@ -0,0 +1,138 @@
+/*************************************************************************
+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 "spddet.h"
+
+/*************************************************************************
+Determinant calculation of the matrix given by the Cholesky decomposition.
+
+Input parameters:
+    A   -   Cholesky decomposition,
+            output of SMatrixCholesky subroutine.
+    N   -   size of matrix A.
+
+As the determinant is equal to the product of squares of diagonal elements,
+it�s not necessary to specify which triangle - lower or upper - the matrix
+is stored in.
+
+Result:
+    matrix determinant.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+double spdmatrixcholeskydet(const ap::real_2d_array& a, int n)
+{
+    double result;
+    int i;
+
+    result = 1;
+    for(i = 0; i <= n-1; i++)
+    {
+        result = result*ap::sqr(a(i,i));
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Determinant calculation of the symmetric positive definite matrix.
+
+Input parameters:
+    A       -   matrix. Array with elements [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   if IsUpper = True, then the symmetric matrix A is given by
+                its upper triangle, and the lower triangle isn�t used by
+                subroutine. Similarly, if IsUpper = False, then A is given
+                by its lower triangle.
+
+Result:
+    determinant of matrix A.
+    If matrix A is not positive definite, then subroutine returns -1.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+double spdmatrixdet(ap::real_2d_array a, int n, bool isupper)
+{
+    double result;
+
+    if( !spdmatrixcholesky(a, n, isupper) )
+    {
+        result = -1;
+    }
+    else
+    {
+        result = spdmatrixcholeskydet(a, n);
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete subroutine
+*************************************************************************/
+double determinantcholesky(const ap::real_2d_array& a, int n)
+{
+    double result;
+    int i;
+
+    result = 1;
+    for(i = 1; i <= n; i++)
+    {
+        result = result*ap::sqr(a(i,i));
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete subroutine
+*************************************************************************/
+double determinantspd(ap::real_2d_array a, int n, bool isupper)
+{
+    double result;
+
+    if( !choleskydecomposition(a, n, isupper) )
+    {
+        result = -1;
+    }
+    else
+    {
+        result = determinantcholesky(a, n);
+    }
+    return result;
+}
+
+
+

data/ext/alglib/spddet.h

@@ -0,0 +1,96 @@
+/*************************************************************************
+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 _spddet_h
+#define _spddet_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "cholesky.h"
+
+
+/*************************************************************************
+Determinant calculation of the matrix given by the Cholesky decomposition.
+
+Input parameters:
+    A   -   Cholesky decomposition,
+            output of SMatrixCholesky subroutine.
+    N   -   size of matrix A.
+
+As the determinant is equal to the product of squares of diagonal elements,
+it�s not necessary to specify which triangle - lower or upper - the matrix
+is stored in.
+
+Result:
+    matrix determinant.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+double spdmatrixcholeskydet(const ap::real_2d_array& a, int n);
+
+
+/*************************************************************************
+Determinant calculation of the symmetric positive definite matrix.
+
+Input parameters:
+    A       -   matrix. Array with elements [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   if IsUpper = True, then the symmetric matrix A is given by
+                its upper triangle, and the lower triangle isn�t used by
+                subroutine. Similarly, if IsUpper = False, then A is given
+                by its lower triangle.
+
+Result:
+    determinant of matrix A.
+    If matrix A is not positive definite, then subroutine returns -1.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+double spdmatrixdet(ap::real_2d_array a, int n, bool isupper);
+
+
+/*************************************************************************
+Obsolete subroutine
+*************************************************************************/
+double determinantcholesky(const ap::real_2d_array& a, int n);
+
+
+/*************************************************************************
+Obsolete subroutine
+*************************************************************************/
+double determinantspd(ap::real_2d_array a, int n, bool isupper);
+
+
+#endif

data/ext/alglib/spdgevd.cpp

@@ -0,0 +1,842 @@
+/*************************************************************************
+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 "spdgevd.h"
+
+/*************************************************************************
+Algorithm for solving the following generalized symmetric positive-definite
+eigenproblem:
+    A*x = lambda*B*x (1) or
+    A*B*x = lambda*x (2) or
+    B*A*x = lambda*x (3).
+where A is a symmetric matrix, B - symmetric positive-definite matrix.
+The problem is solved by reducing it to an ordinary  symmetric  eigenvalue
+problem.
+
+Input parameters:
+    A           -   symmetric 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 matrices A and B.
+    IsUpperA    -   storage format of matrix A.
+    B           -   symmetric positive-definite matrix which is given by
+                    its upper or lower triangular part.
+                    Array whose indexes range within [0..N-1, 0..N-1].
+    IsUpperB    -   storage format of matrix B.
+    ZNeeded     -   if ZNeeded is equal to:
+                     * 0, the eigenvectors are not returned;
+                     * 1, the eigenvectors are returned.
+    ProblemType -   if ProblemType is equal to:
+                     * 1, the following problem is solved: A*x = lambda*B*x;
+                     * 2, the following problem is solved: A*B*x = lambda*x;
+                     * 3, the following problem is solved: B*A*x = lambda*x.
+
+Output parameters:
+    D           -   eigenvalues in ascending order.
+                    Array whose index ranges within [0..N-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..N-1].
+                    The eigenvectors are stored in matrix columns. It should
+                    be noted that the eigenvectors in such problems do not
+                    form an orthogonal system.
+
+Result:
+    True, if the problem was solved successfully.
+    False, if the error occurred during the Cholesky decomposition of matrix
+    B (the matrix isn�t positive-definite) or during the work of the iterative
+    algorithm for solving the symmetric eigenproblem.
+
+See also the GeneralizedSymmetricDefiniteEVDReduce subroutine.
+
+  -- ALGLIB --
+     Copyright 1.28.2006 by Bochkanov Sergey
+*************************************************************************/
+bool smatrixgevd(ap::real_2d_array a,
+     int n,
+     bool isuppera,
+     const ap::real_2d_array& b,
+     bool isupperb,
+     int zneeded,
+     int problemtype,
+     ap::real_1d_array& d,
+     ap::real_2d_array& z)
+{
+    bool result;
+    ap::real_2d_array r;
+    ap::real_2d_array t;
+    bool isupperr;
+    int j1;
+    int j2;
+    int j1inc;
+    int j2inc;
+    int i;
+    int j;
+    double v;
+
+    
+    //
+    // Reduce and solve
+    //
+    result = smatrixgevdreduce(a, n, isuppera, b, isupperb, problemtype, r, isupperr);
+    if( !result )
+    {
+        return result;
+    }
+    result = smatrixevd(a, n, zneeded, isuppera, d, t);
+    if( !result )
+    {
+        return result;
+    }
+    
+    //
+    // Transform eigenvectors if needed
+    //
+    if( zneeded!=0 )
+    {
+        
+        //
+        // fill Z with zeros
+        //
+        z.setbounds(0, n-1, 0, n-1);
+        for(j = 0; j <= n-1; j++)
+        {
+            z(0,j) = 0.0;
+        }
+        for(i = 1; i <= n-1; i++)
+        {
+            ap::vmove(&z(i, 0), &z(0, 0), ap::vlen(0,n-1));
+        }
+        
+        //
+        // Setup R properties
+        //
+        if( isupperr )
+        {
+            j1 = 0;
+            j2 = n-1;
+            j1inc = +1;
+            j2inc = 0;
+        }
+        else
+        {
+            j1 = 0;
+            j2 = 0;
+            j1inc = 0;
+            j2inc = +1;
+        }
+        
+        //
+        // Calculate R*Z
+        //
+        for(i = 0; i <= n-1; i++)
+        {
+            for(j = j1; j <= j2; j++)
+            {
+                v = r(i,j);
+                ap::vadd(&z(i, 0), &t(j, 0), ap::vlen(0,n-1), v);
+            }
+            j1 = j1+j1inc;
+            j2 = j2+j2inc;
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Algorithm for reduction of the following generalized symmetric positive-
+definite eigenvalue problem:
+    A*x = lambda*B*x (1) or
+    A*B*x = lambda*x (2) or
+    B*A*x = lambda*x (3)
+to the symmetric eigenvalues problem C*y = lambda*y (eigenvalues of this and
+the given problems are the same, and the eigenvectors of the given problem
+could be obtained by multiplying the obtained eigenvectors by the
+transformation matrix x = R*y).
+
+Here A is a symmetric matrix, B - symmetric positive-definite matrix.
+
+Input parameters:
+    A           -   symmetric 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 matrices A and B.
+    IsUpperA    -   storage format of matrix A.
+    B           -   symmetric positive-definite matrix which is given by
+                    its upper or lower triangular part.
+                    Array whose indexes range within [0..N-1, 0..N-1].
+    IsUpperB    -   storage format of matrix B.
+    ProblemType -   if ProblemType is equal to:
+                     * 1, the following problem is solved: A*x = lambda*B*x;
+                     * 2, the following problem is solved: A*B*x = lambda*x;
+                     * 3, the following problem is solved: B*A*x = lambda*x.
+
+Output parameters:
+    A           -   symmetric matrix which is given by its upper or lower
+                    triangle depending on IsUpperA. Contains matrix C.
+                    Array whose indexes range within [0..N-1, 0..N-1].
+    R           -   upper triangular or low triangular transformation matrix
+                    which is used to obtain the eigenvectors of a given problem
+                    as the product of eigenvectors of C (from the right) and
+                    matrix R (from the left). If the matrix is upper
+                    triangular, the elements below the main diagonal
+                    are equal to 0 (and vice versa). Thus, we can perform
+                    the multiplication without taking into account the
+                    internal structure (which is an easier though less
+                    effective way).
+                    Array whose indexes range within [0..N-1, 0..N-1].
+    IsUpperR    -   type of matrix R (upper or lower triangular).
+
+Result:
+    True, if the problem was reduced successfully.
+    False, if the error occurred during the Cholesky decomposition of
+        matrix B (the matrix is not positive-definite).
+
+  -- ALGLIB --
+     Copyright 1.28.2006 by Bochkanov Sergey
+*************************************************************************/
+bool smatrixgevdreduce(ap::real_2d_array& a,
+     int n,
+     bool isuppera,
+     const ap::real_2d_array& b,
+     bool isupperb,
+     int problemtype,
+     ap::real_2d_array& r,
+     bool& isupperr)
+{
+    bool result;
+    ap::real_2d_array t;
+    ap::real_1d_array w1;
+    ap::real_1d_array w2;
+    ap::real_1d_array w3;
+    int i;
+    int j;
+    double v;
+
+    ap::ap_error::make_assertion(n>0, "SMatrixGEVDReduce: N<=0!");
+    ap::ap_error::make_assertion(problemtype==1||problemtype==2||problemtype==3, "SMatrixGEVDReduce: incorrect ProblemType!");
+    result = true;
+    
+    //
+    // Problem 1:  A*x = lambda*B*x
+    //
+    // Reducing to:
+    //     C*y = lambda*y
+    //     C = L^(-1) * A * L^(-T)
+    //     x = L^(-T) * y
+    //
+    if( problemtype==1 )
+    {
+        
+        //
+        // Factorize B in T: B = LL'
+        //
+        t.setbounds(0, n-1, 0, n-1);
+        if( isupperb )
+        {
+            for(i = 0; i <= n-1; i++)
+            {
+                ap::vmove(t.getcolumn(i, i, n-1), b.getrow(i, i, n-1));
+            }
+        }
+        else
+        {
+            for(i = 0; i <= n-1; i++)
+            {
+                ap::vmove(&t(i, 0), &b(i, 0), ap::vlen(0,i));
+            }
+        }
+        if( !spdmatrixcholesky(t, n, false) )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Invert L in T
+        //
+        if( !rmatrixtrinverse(t, n, false, false) )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Build L^(-1) * A * L^(-T) in R
+        //
+        w1.setbounds(1, n);
+        w2.setbounds(1, n);
+        r.setbounds(0, n-1, 0, n-1);
+        for(j = 1; j <= n; j++)
+        {
+            
+            //
+            // Form w2 = A * l'(j) (here l'(j) is j-th column of L^(-T))
+            //
+            ap::vmove(&w1(1), &t(j-1, 0), ap::vlen(1,j));
+            symmetricmatrixvectormultiply(a, isuppera, 0, j-1, w1, 1.0, w2);
+            if( isuppera )
+            {
+                matrixvectormultiply(a, 0, j-1, j, n-1, true, w1, 1, j, 1.0, w2, j+1, n, 0.0);
+            }
+            else
+            {
+                matrixvectormultiply(a, j, n-1, 0, j-1, false, w1, 1, j, 1.0, w2, j+1, n, 0.0);
+            }
+            
+            //
+            // Form l(i)*w2 (here l(i) is i-th row of L^(-1))
+            //
+            for(i = 1; i <= n; i++)
+            {
+                v = ap::vdotproduct(&t(i-1, 0), &w2(1), ap::vlen(0,i-1));
+                r(i-1,j-1) = v;
+            }
+        }
+        
+        //
+        // Copy R to A
+        //
+        for(i = 0; i <= n-1; i++)
+        {
+            ap::vmove(&a(i, 0), &r(i, 0), ap::vlen(0,n-1));
+        }
+        
+        //
+        // Copy L^(-1) from T to R and transpose
+        //
+        isupperr = true;
+        for(i = 0; i <= n-1; i++)
+        {
+            for(j = 0; j <= i-1; j++)
+            {
+                r(i,j) = 0;
+            }
+        }
+        for(i = 0; i <= n-1; i++)
+        {
+            ap::vmove(r.getrow(i, i, n-1), t.getcolumn(i, i, n-1));
+        }
+        return result;
+    }
+    
+    //
+    // Problem 2:  A*B*x = lambda*x
+    // or
+    // problem 3:  B*A*x = lambda*x
+    //
+    // Reducing to:
+    //     C*y = lambda*y
+    //     C = U * A * U'
+    //     B = U'* U
+    //
+    if( problemtype==2||problemtype==3 )
+    {
+        
+        //
+        // Factorize B in T: B = U'*U
+        //
+        t.setbounds(0, n-1, 0, n-1);
+        if( isupperb )
+        {
+            for(i = 0; i <= n-1; i++)
+            {
+                ap::vmove(&t(i, i), &b(i, i), ap::vlen(i,n-1));
+            }
+        }
+        else
+        {
+            for(i = 0; i <= n-1; i++)
+            {
+                ap::vmove(t.getrow(i, i, n-1), b.getcolumn(i, i, n-1));
+            }
+        }
+        if( !spdmatrixcholesky(t, n, true) )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Build U * A * U' in R
+        //
+        w1.setbounds(1, n);
+        w2.setbounds(1, n);
+        w3.setbounds(1, n);
+        r.setbounds(0, n-1, 0, n-1);
+        for(j = 1; j <= n; j++)
+        {
+            
+            //
+            // Form w2 = A * u'(j) (here u'(j) is j-th column of U')
+            //
+            ap::vmove(&w1(1), &t(j-1, j-1), ap::vlen(1,n-j+1));
+            symmetricmatrixvectormultiply(a, isuppera, j-1, n-1, w1, 1.0, w3);
+            ap::vmove(&w2(j), &w3(1), ap::vlen(j,n));
+            ap::vmove(&w1(j), &t(j-1, j-1), ap::vlen(j,n));
+            if( isuppera )
+            {
+                matrixvectormultiply(a, 0, j-2, j-1, n-1, false, w1, j, n, 1.0, w2, 1, j-1, 0.0);
+            }
+            else
+            {
+                matrixvectormultiply(a, j-1, n-1, 0, j-2, true, w1, j, n, 1.0, w2, 1, j-1, 0.0);
+            }
+            
+            //
+            // Form u(i)*w2 (here u(i) is i-th row of U)
+            //
+            for(i = 1; i <= n; i++)
+            {
+                v = ap::vdotproduct(&t(i-1, i-1), &w2(i), ap::vlen(i-1,n-1));
+                r(i-1,j-1) = v;
+            }
+        }
+        
+        //
+        // Copy R to A
+        //
+        for(i = 0; i <= n-1; i++)
+        {
+            ap::vmove(&a(i, 0), &r(i, 0), ap::vlen(0,n-1));
+        }
+        if( problemtype==2 )
+        {
+            
+            //
+            // Invert U in T
+            //
+            if( !rmatrixtrinverse(t, n, true, false) )
+            {
+                result = false;
+                return result;
+            }
+            
+            //
+            // Copy U^-1 from T to R
+            //
+            isupperr = true;
+            for(i = 0; i <= n-1; i++)
+            {
+                for(j = 0; j <= i-1; j++)
+                {
+                    r(i,j) = 0;
+                }
+            }
+            for(i = 0; i <= n-1; i++)
+            {
+                ap::vmove(&r(i, i), &t(i, i), ap::vlen(i,n-1));
+            }
+        }
+        else
+        {
+            
+            //
+            // Copy U from T to R and transpose
+            //
+            isupperr = false;
+            for(i = 0; i <= n-1; i++)
+            {
+                for(j = i+1; j <= n-1; j++)
+                {
+                    r(i,j) = 0;
+                }
+            }
+            for(i = 0; i <= n-1; i++)
+            {
+                ap::vmove(r.getcolumn(i, i, n-1), t.getrow(i, i, n-1));
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool generalizedsymmetricdefiniteevd(ap::real_2d_array a,
+     int n,
+     bool isuppera,
+     const ap::real_2d_array& b,
+     bool isupperb,
+     int zneeded,
+     int problemtype,
+     ap::real_1d_array& d,
+     ap::real_2d_array& z)
+{
+    bool result;
+    ap::real_2d_array r;
+    ap::real_2d_array t;
+    bool isupperr;
+    int j1;
+    int j2;
+    int j1inc;
+    int j2inc;
+    int i;
+    int j;
+    double v;
+
+    
+    //
+    // Reduce and solve
+    //
+    result = generalizedsymmetricdefiniteevdreduce(a, n, isuppera, b, isupperb, problemtype, r, isupperr);
+    if( !result )
+    {
+        return result;
+    }
+    result = symmetricevd(a, n, zneeded, isuppera, d, t);
+    if( !result )
+    {
+        return result;
+    }
+    
+    //
+    // Transform eigenvectors if needed
+    //
+    if( zneeded!=0 )
+    {
+        
+        //
+        // fill Z with zeros
+        //
+        z.setbounds(1, n, 1, n);
+        for(j = 1; j <= n; j++)
+        {
+            z(1,j) = 0.0;
+        }
+        for(i = 2; i <= n; i++)
+        {
+            ap::vmove(&z(i, 1), &z(1, 1), ap::vlen(1,n));
+        }
+        
+        //
+        // Setup R properties
+        //
+        if( isupperr )
+        {
+            j1 = 1;
+            j2 = n;
+            j1inc = +1;
+            j2inc = 0;
+        }
+        else
+        {
+            j1 = 1;
+            j2 = 1;
+            j1inc = 0;
+            j2inc = +1;
+        }
+        
+        //
+        // Calculate R*Z
+        //
+        for(i = 1; i <= n; i++)
+        {
+            for(j = j1; j <= j2; j++)
+            {
+                v = r(i,j);
+                ap::vadd(&z(i, 1), &t(j, 1), ap::vlen(1,n), v);
+            }
+            j1 = j1+j1inc;
+            j2 = j2+j2inc;
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool generalizedsymmetricdefiniteevdreduce(ap::real_2d_array& a,
+     int n,
+     bool isuppera,
+     const ap::real_2d_array& b,
+     bool isupperb,
+     int problemtype,
+     ap::real_2d_array& r,
+     bool& isupperr)
+{
+    bool result;
+    ap::real_2d_array t;
+    ap::real_1d_array w1;
+    ap::real_1d_array w2;
+    ap::real_1d_array w3;
+    int i;
+    int j;
+    double v;
+
+    ap::ap_error::make_assertion(n>0, "GeneralizedSymmetricDefiniteEVDReduce: N<=0!");
+    ap::ap_error::make_assertion(problemtype==1||problemtype==2||problemtype==3, "GeneralizedSymmetricDefiniteEVDReduce: incorrect ProblemType!");
+    result = true;
+    
+    //
+    // Problem 1:  A*x = lambda*B*x
+    //
+    // Reducing to:
+    //     C*y = lambda*y
+    //     C = L^(-1) * A * L^(-T)
+    //     x = L^(-T) * y
+    //
+    if( problemtype==1 )
+    {
+        
+        //
+        // Factorize B in T: B = LL'
+        //
+        t.setbounds(1, n, 1, n);
+        if( isupperb )
+        {
+            for(i = 1; i <= n; i++)
+            {
+                ap::vmove(t.getcolumn(i, i, n), b.getrow(i, i, n));
+            }
+        }
+        else
+        {
+            for(i = 1; i <= n; i++)
+            {
+                ap::vmove(&t(i, 1), &b(i, 1), ap::vlen(1,i));
+            }
+        }
+        if( !choleskydecomposition(t, n, false) )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Invert L in T
+        //
+        if( !invtriangular(t, n, false, false) )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Build L^(-1) * A * L^(-T) in R
+        //
+        w1.setbounds(1, n);
+        w2.setbounds(1, n);
+        r.setbounds(1, n, 1, n);
+        for(j = 1; j <= n; j++)
+        {
+            
+            //
+            // Form w2 = A * l'(j) (here l'(j) is j-th column of L^(-T))
+            //
+            ap::vmove(&w1(1), &t(j, 1), ap::vlen(1,j));
+            symmetricmatrixvectormultiply(a, isuppera, 1, j, w1, 1.0, w2);
+            if( isuppera )
+            {
+                matrixvectormultiply(a, 1, j, j+1, n, true, w1, 1, j, 1.0, w2, j+1, n, 0.0);
+            }
+            else
+            {
+                matrixvectormultiply(a, j+1, n, 1, j, false, w1, 1, j, 1.0, w2, j+1, n, 0.0);
+            }
+            
+            //
+            // Form l(i)*w2 (here l(i) is i-th row of L^(-1))
+            //
+            for(i = 1; i <= n; i++)
+            {
+                v = ap::vdotproduct(&t(i, 1), &w2(1), ap::vlen(1,i));
+                r(i,j) = v;
+            }
+        }
+        
+        //
+        // Copy R to A
+        //
+        for(i = 1; i <= n; i++)
+        {
+            ap::vmove(&a(i, 1), &r(i, 1), ap::vlen(1,n));
+        }
+        
+        //
+        // Copy L^(-1) from T to R and transpose
+        //
+        isupperr = true;
+        for(i = 1; i <= n; i++)
+        {
+            for(j = 1; j <= i-1; j++)
+            {
+                r(i,j) = 0;
+            }
+        }
+        for(i = 1; i <= n; i++)
+        {
+            ap::vmove(r.getrow(i, i, n), t.getcolumn(i, i, n));
+        }
+        return result;
+    }
+    
+    //
+    // Problem 2:  A*B*x = lambda*x
+    // or
+    // problem 3:  B*A*x = lambda*x
+    //
+    // Reducing to:
+    //     C*y = lambda*y
+    //     C = U * A * U'
+    //     B = U'* U
+    //
+    if( problemtype==2||problemtype==3 )
+    {
+        
+        //
+        // Factorize B in T: B = U'*U
+        //
+        t.setbounds(1, n, 1, n);
+        if( isupperb )
+        {
+            for(i = 1; i <= n; i++)
+            {
+                ap::vmove(&t(i, i), &b(i, i), ap::vlen(i,n));
+            }
+        }
+        else
+        {
+            for(i = 1; i <= n; i++)
+            {
+                ap::vmove(t.getrow(i, i, n), b.getcolumn(i, i, n));
+            }
+        }
+        if( !choleskydecomposition(t, n, true) )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Build U * A * U' in R
+        //
+        w1.setbounds(1, n);
+        w2.setbounds(1, n);
+        w3.setbounds(1, n);
+        r.setbounds(1, n, 1, n);
+        for(j = 1; j <= n; j++)
+        {
+            
+            //
+            // Form w2 = A * u'(j) (here u'(j) is j-th column of U')
+            //
+            ap::vmove(&w1(1), &t(j, j), ap::vlen(1,n-j+1));
+            symmetricmatrixvectormultiply(a, isuppera, j, n, w1, 1.0, w3);
+            ap::vmove(&w2(j), &w3(1), ap::vlen(j,n));
+            ap::vmove(&w1(j), &t(j, j), ap::vlen(j,n));
+            if( isuppera )
+            {
+                matrixvectormultiply(a, 1, j-1, j, n, false, w1, j, n, 1.0, w2, 1, j-1, 0.0);
+            }
+            else
+            {
+                matrixvectormultiply(a, j, n, 1, j-1, true, w1, j, n, 1.0, w2, 1, j-1, 0.0);
+            }
+            
+            //
+            // Form u(i)*w2 (here u(i) is i-th row of U)
+            //
+            for(i = 1; i <= n; i++)
+            {
+                v = ap::vdotproduct(&t(i, i), &w2(i), ap::vlen(i,n));
+                r(i,j) = v;
+            }
+        }
+        
+        //
+        // Copy R to A
+        //
+        for(i = 1; i <= n; i++)
+        {
+            ap::vmove(&a(i, 1), &r(i, 1), ap::vlen(1,n));
+        }
+        if( problemtype==2 )
+        {
+            
+            //
+            // Invert U in T
+            //
+            if( !invtriangular(t, n, true, false) )
+            {
+                result = false;
+                return result;
+            }
+            
+            //
+            // Copy U^-1 from T to R
+            //
+            isupperr = true;
+            for(i = 1; i <= n; i++)
+            {
+                for(j = 1; j <= i-1; j++)
+                {
+                    r(i,j) = 0;
+                }
+            }
+            for(i = 1; i <= n; i++)
+            {
+                ap::vmove(&r(i, i), &t(i, i), ap::vlen(i,n));
+            }
+        }
+        else
+        {
+            
+            //
+            // Copy U from T to R and transpose
+            //
+            isupperr = false;
+            for(i = 1; i <= n; i++)
+            {
+                for(j = i+1; j <= n; j++)
+                {
+                    r(i,j) = 0;
+                }
+            }
+            for(i = 1; i <= n; i++)
+            {
+                ap::vmove(r.getcolumn(i, i, n), t.getrow(i, i, n));
+            }
+        }
+    }
+    return result;
+}
+
+
+