alglib 0.1.1

data/ext/alglib/spdgevd.h

@@ -0,0 +1,200 @@
+/*************************************************************************
+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 _spdgevd_h
+#define _spdgevd_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "cholesky.h"
+#include "sblas.h"
+#include "blas.h"
+#include "trinverse.h"
+#include "rotations.h"
+#include "tdevd.h"
+#include "reflections.h"
+#include "tridiagonal.h"
+#include "sevd.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);
+
+
+/*************************************************************************
+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);
+
+
+/*************************************************************************
+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);
+
+
+/*************************************************************************
+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);
+
+
+#endif

data/ext/alglib/spdinverse.cpp

@@ -0,0 +1,509 @@
+/*************************************************************************
+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.
+*************************************************************************/
+
+#include <stdafx.h>
+#include <stdio.h>
+#include "spdinverse.h"
+
+static void testinversecholesky();
+
+/*************************************************************************
+Inversion of a symmetric positive definite matrix which is given
+by Cholesky decomposition.
+
+Input parameters:
+    A       -   Cholesky decomposition of the matrix to be inverted:
+                A=U�*U or A = L*L'.
+                Output of  CholeskyDecomposition subroutine.
+                Array with elements [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    IsUpper �   storage format.
+                If IsUpper = True, then matrix A is given as A = U'*U
+                (matrix contains upper triangle).
+                Similarly, if IsUpper = False, then A = L*L'.
+
+Output parameters:
+    A       -   upper or lower triangle of symmetric matrix A^-1, depending
+                on the value of IsUpper.
+
+Result:
+    True, if the inversion succeeded.
+    False, if matrix A contains zero elements on its main diagonal.
+    Matrix A could not be inverted.
+
+The algorithm is the modification of DPOTRI and DLAUU2 subroutines from
+LAPACK library.
+*************************************************************************/
+bool spdmatrixcholeskyinverse(ap::real_2d_array& a, int n, bool isupper)
+{
+    bool result;
+    int i;
+    int j;
+    int k;
+    double v;
+    double ajj;
+    double aii;
+    ap::real_1d_array t;
+    ap::real_2d_array a1;
+
+    result = true;
+    
+    //
+    // Test the input parameters.
+    //
+    t.setbounds(0, n-1);
+    if( isupper )
+    {
+        
+        //
+        // Compute inverse of upper triangular matrix.
+        //
+        for(j = 0; j <= n-1; j++)
+        {
+            if( a(j,j)==0 )
+            {
+                result = false;
+                return result;
+            }
+            a(j,j) = 1/a(j,j);
+            ajj = -a(j,j);
+            
+            //
+            // Compute elements 1:j-1 of j-th column.
+            //
+            ap::vmove(t.getvector(0, j-1), a.getcolumn(j, 0, j-1));
+            for(i = 0; i <= j-1; i++)
+            {
+                v = ap::vdotproduct(&a(i, i), &t(i), ap::vlen(i,j-1));
+                a(i,j) = v;
+            }
+            ap::vmul(a.getcolumn(j, 0, j-1), ajj);
+        }
+        
+        //
+        // InvA = InvU * InvU'
+        //
+        for(i = 0; i <= n-1; i++)
+        {
+            aii = a(i,i);
+            if( i<n-1 )
+            {
+                v = ap::vdotproduct(&a(i, i), &a(i, i), ap::vlen(i,n-1));
+                a(i,i) = v;
+                for(k = 0; k <= i-1; k++)
+                {
+                    v = ap::vdotproduct(&a(k, i+1), &a(i, i+1), ap::vlen(i+1,n-1));
+                    a(k,i) = a(k,i)*aii+v;
+                }
+            }
+            else
+            {
+                ap::vmul(a.getcolumn(i, 0, i), aii);
+            }
+        }
+    }
+    else
+    {
+        
+        //
+        // Compute inverse of lower triangular matrix.
+        //
+        for(j = n-1; j >= 0; j--)
+        {
+            if( a(j,j)==0 )
+            {
+                result = false;
+                return result;
+            }
+            a(j,j) = 1/a(j,j);
+            ajj = -a(j,j);
+            if( j<n-1 )
+            {
+                
+                //
+                // Compute elements j+1:n of j-th column.
+                //
+                ap::vmove(t.getvector(j+1, n-1), a.getcolumn(j, j+1, n-1));
+                for(i = j+1+1; i <= n; i++)
+                {
+                    v = ap::vdotproduct(&a(i-1, j+1), &t(j+1), ap::vlen(j+1,i-1));
+                    a(i-1,j) = v;
+                }
+                ap::vmul(a.getcolumn(j, j+1, n-1), ajj);
+            }
+        }
+        
+        //
+        // InvA = InvL' * InvL
+        //
+        for(i = 0; i <= n-1; i++)
+        {
+            aii = a(i,i);
+            if( i<n-1 )
+            {
+                v = ap::vdotproduct(a.getcolumn(i, i, n-1), a.getcolumn(i, i, n-1));
+                a(i,i) = v;
+                for(k = 0; k <= i-1; k++)
+                {
+                    v = ap::vdotproduct(a.getcolumn(k, i+1, n-1), a.getcolumn(i, i+1, n-1));
+                    a(i,k) = aii*a(i,k)+v;
+                }
+            }
+            else
+            {
+                ap::vmul(&a(i, 0), ap::vlen(0,i), aii);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Inversion of a symmetric positive definite matrix.
+
+Given an upper or lower triangle of a symmetric positive definite matrix,
+the algorithm generates matrix A^-1 and saves the upper or lower 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 the upper triangle of matrix A^-1
+                is used, and the elements below the main diagonal are not
+                used nor changed. The same applies if IsUpper = False.
+
+Result:
+    True, if the matrix is positive definite.
+    False, if the matrix is not positive definite (and it could not be
+    inverted by this algorithm).
+*************************************************************************/
+bool spdmatrixinverse(ap::real_2d_array& a, int n, bool isupper)
+{
+    bool result;
+
+    result = false;
+    if( spdmatrixcholesky(a, n, isupper) )
+    {
+        if( spdmatrixcholeskyinverse(a, n, isupper) )
+        {
+            result = true;
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete subroutine.
+*************************************************************************/
+bool inversecholesky(ap::real_2d_array& a, int n, bool isupper)
+{
+    bool result;
+    int i;
+    int j;
+    int k;
+    int nmj;
+    int jm1;
+    int jp1;
+    int ip1;
+    double v;
+    double ajj;
+    double aii;
+    ap::real_1d_array t;
+    ap::real_1d_array d;
+
+    result = true;
+    
+    //
+    // Test the input parameters.
+    //
+    t.setbounds(1, n);
+    d.setbounds(1, n);
+    if( isupper )
+    {
+        
+        //
+        // Compute inverse of upper triangular matrix.
+        //
+        for(j = 1; j <= n; j++)
+        {
+            if( a(j,j)==0 )
+            {
+                result = false;
+                return result;
+            }
+            jm1 = j-1;
+            a(j,j) = 1/a(j,j);
+            ajj = -a(j,j);
+            
+            //
+            // Compute elements 1:j-1 of j-th column.
+            //
+            ap::vmove(t.getvector(1, jm1), a.getcolumn(j, 1, jm1));
+            for(i = 1; i <= j-1; i++)
+            {
+                v = ap::vdotproduct(a.getrow(i, i, jm1), a.getcolumn(j, i, jm1));
+                a(i,j) = v;
+            }
+            ap::vmul(a.getcolumn(j, 1, jm1), ajj);
+        }
+        
+        //
+        // InvA = InvU * InvU'
+        //
+        for(i = 1; i <= n; i++)
+        {
+            aii = a(i,i);
+            if( i<n )
+            {
+                v = ap::vdotproduct(&a(i, i), &a(i, i), ap::vlen(i,n));
+                a(i,i) = v;
+                ip1 = i+1;
+                for(k = 1; k <= i-1; k++)
+                {
+                    v = ap::vdotproduct(&a(k, ip1), &a(i, ip1), ap::vlen(ip1,n));
+                    a(k,i) = a(k,i)*aii+v;
+                }
+            }
+            else
+            {
+                ap::vmul(a.getcolumn(i, 1, i), aii);
+            }
+        }
+    }
+    else
+    {
+        
+        //
+        // Compute inverse of lower triangular matrix.
+        //
+        for(j = n; j >= 1; j--)
+        {
+            if( a(j,j)==0 )
+            {
+                result = false;
+                return result;
+            }
+            a(j,j) = 1/a(j,j);
+            ajj = -a(j,j);
+            if( j<n )
+            {
+                
+                //
+                // Compute elements j+1:n of j-th column.
+                //
+                nmj = n-j;
+                jp1 = j+1;
+                ap::vmove(t.getvector(jp1, n), a.getcolumn(j, jp1, n));
+                for(i = j+1; i <= n; i++)
+                {
+                    v = ap::vdotproduct(&a(i, jp1), &t(jp1), ap::vlen(jp1,i));
+                    a(i,j) = v;
+                }
+                ap::vmul(a.getcolumn(j, jp1, n), ajj);
+            }
+        }
+        
+        //
+        // InvA = InvL' * InvL
+        //
+        for(i = 1; i <= n; i++)
+        {
+            aii = a(i,i);
+            if( i<n )
+            {
+                v = ap::vdotproduct(a.getcolumn(i, i, n), a.getcolumn(i, i, n));
+                a(i,i) = v;
+                ip1 = i+1;
+                for(k = 1; k <= i-1; k++)
+                {
+                    v = ap::vdotproduct(a.getcolumn(k, ip1, n), a.getcolumn(i, ip1, n));
+                    a(i,k) = aii*a(i,k)+v;
+                }
+            }
+            else
+            {
+                ap::vmul(&a(i, 1), ap::vlen(1,i), aii);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete subroutine.
+*************************************************************************/
+bool inversesymmetricpositivedefinite(ap::real_2d_array& a,
+     int n,
+     bool isupper)
+{
+    bool result;
+
+    result = false;
+    if( choleskydecomposition(a, n, isupper) )
+    {
+        if( inversecholesky(a, n, isupper) )
+        {
+            result = true;
+        }
+    }
+    return result;
+}
+
+
+static void testinversecholesky()
+{
+    ap::real_2d_array l;
+    ap::real_2d_array a;
+    ap::real_2d_array inva;
+    int n;
+    int pass;
+    int passcount;
+    int i;
+    int j;
+    int minij;
+    bool upperin;
+    bool cr;
+    double err;
+    double v;
+
+    err = 0;
+    passcount = 100;
+    for(pass = 1; pass <= passcount; pass++)
+    {
+        n = 1+ap::randominteger(50);
+        upperin = ap::randomreal()>0.5;
+        l.setbounds(1, n, 1, n);
+        a.setbounds(1, n, 1, n);
+        inva.setbounds(1, n, 1, n);
+        for(i = 1; i <= n; i++)
+        {
+            for(j = i+1; j <= n; j++)
+            {
+                l(i,j) = ap::randomreal();
+                l(j,i) = l(i,j);
+            }
+            l(i,i) = 1.1+ap::randomreal();
+        }
+        for(i = 1; i <= n; i++)
+        {
+            for(j = 1; j <= n; j++)
+            {
+                minij = ap::minint(i, j);
+                v = ap::vdotproduct(l.getrow(i, 1, minij), l.getcolumn(j, 1, minij));
+                a(i,j) = v;
+                a(j,i) = v;
+                inva(i,j) = v;
+                inva(j,i) = v;
+            }
+        }
+        for(i = 1; i <= n; i++)
+        {
+            for(j = 1; j <= n; j++)
+            {
+                if( upperin )
+                {
+                    if( j<i )
+                    {
+                        inva(i,j) = 0;
+                    }
+                }
+                else
+                {
+                    if( i<j )
+                    {
+                        inva(i,j) = 0;
+                    }
+                }
+            }
+        }
+        cr = inversesymmetricpositivedefinite(inva, n, upperin);
+        ap::ap_error::make_assertion(cr, "Something strange");
+        for(i = 1; i <= n; i++)
+        {
+            for(j = 1; j <= n; j++)
+            {
+                if( upperin )
+                {
+                    if( j<i )
+                    {
+                        inva(i,j) = inva(j,i);
+                    }
+                }
+                else
+                {
+                    if( i<j )
+                    {
+                        inva(i,j) = inva(j,i);
+                    }
+                }
+            }
+        }
+        for(i = 1; i <= n; i++)
+        {
+            for(j = 1; j <= n; j++)
+            {
+                v = ap::vdotproduct(a.getrow(i, 1, n), inva.getcolumn(j, 1, n));
+                if( j==i )
+                {
+                    err = ap::maxreal(err, fabs(v-1));
+                }
+                else
+                {
+                    err = ap::maxreal(err, fabs(v));
+                }
+            }
+        }
+    }
+    printf("Pass count %0ld\nInverseSymmetricPositiveDefinite error is %5.3le\n",
+        long(passcount),
+        double(err));
+}
+
+
+