alglib 0.1.1

data/ext/alglib/spdrcond.h

@@ -0,0 +1,118 @@
+/*************************************************************************
+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 _spdrcond_h
+#define _spdrcond_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "trlinsolve.h"
+#include "cholesky.h"
+#include "estnorm.h"
+
+
+/*************************************************************************
+Condition number estimate of a symmetric positive definite matrix.
+
+The algorithm calculates a lower bound of the condition number. In this case,
+the algorithm does not return a lower bound of the condition number, but an
+inverse number (to avoid an overflow in case of a singular matrix).
+
+It should be noted that 1-norm and inf-norm of condition numbers of symmetric
+matrices are equal, so the algorithm doesn't take into account the
+differences between these types of norms.
+
+Input parameters:
+    A       -   symmetric positive definite matrix which is given by its
+                upper or lower triangle depending on the value of
+                IsUpper. Array with elements [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   storage format.
+
+Result:
+    1/LowerBound(cond(A)), if matrix A is positive definite,
+   -1, if matrix A is not positive definite, and its condition number
+    could not be found by this algorithm.
+*************************************************************************/
+double spdmatrixrcond(const ap::real_2d_array& a, int n, bool isupper);
+
+
+/*************************************************************************
+Condition number estimate of a symmetric positive definite matrix given by
+Cholesky decomposition.
+
+The algorithm calculates a lower bound of the condition number. In this
+case, the algorithm does not return a lower bound of the condition number,
+but an inverse number (to avoid an overflow in case of a singular matrix).
+
+It should be noted that 1-norm and inf-norm condition numbers of symmetric
+matrices are equal, so the algorithm doesn't take into account the
+differences between these types of norms.
+
+Input parameters:
+    CD  - Cholesky decomposition of matrix A,
+          output of SMatrixCholesky subroutine.
+    N   - size of matrix A.
+
+Result: 1/LowerBound(cond(A))
+*************************************************************************/
+double spdmatrixcholeskyrcond(const ap::real_2d_array& a, int n, bool isupper);
+
+
+/*************************************************************************
+Obsolete subroutine
+*************************************************************************/
+double rcondspd(ap::real_2d_array a, int n, bool isupper);
+
+
+/*************************************************************************
+Obsolete subroutine
+*************************************************************************/
+double rcondcholesky(const ap::real_2d_array& cd, int n, bool isupper);
+
+
+void internalcholeskyrcond(const ap::real_2d_array& chfrm,
+     int n,
+     bool isupper,
+     bool isnormprovided,
+     double anorm,
+     double& rcond);
+
+
+#endif

data/ext/alglib/spdsolve.cpp

@@ -0,0 +1,275 @@
+
+#include <stdafx.h>
+#include "spdsolve.h"
+
+/*************************************************************************
+Solving a system of linear equations with a system  matrix  given  by  its
+Cholesky decomposition.
+
+The algorithm solves systems with a square matrix only.
+
+Input parameters:
+    A       -   Cholesky decomposition of a system matrix (the result of
+                the SMatrixCholesky subroutine).
+    B       -   right side of a system.
+                Array whose index ranges within [0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   points to the triangle of matrix A in which the Cholesky
+                decomposition is stored. If IsUpper=True,  the  Cholesky
+                decomposition has the form of U'*U, and the upper triangle
+                of matrix A stores matrix U (in  that  case,  the  lower
+                triangle isn�t used and isn�t changed by the subroutine)
+                Similarly, if IsUpper = False, the Cholesky decomposition
+                has the form of L*L',  and  the  lower  triangle  stores
+                matrix L.
+
+Output parameters:
+    X       -   solution of a system.
+                Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the system is not singular. X contains the solution.
+    False, if the system is singular (there is a zero element on the main
+diagonal). In this case, X doesn't contain a solution.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+bool spdmatrixcholeskysolve(const ap::real_2d_array& a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x)
+{
+    bool result;
+    int i;
+    double v;
+
+    ap::ap_error::make_assertion(n>0, "Error: N<=0 in SolveSystemCholesky");
+    
+    //
+    // det(A)=0?
+    //
+    result = true;
+    for(i = 0; i <= n-1; i++)
+    {
+        if( a(i,i)==0 )
+        {
+            result = false;
+            return result;
+        }
+    }
+    
+    //
+    // det(A)<>0
+    //
+    x.setbounds(0, n-1);
+    if( isupper )
+    {
+        
+        //
+        // A = U'*U, solve U'*y = b first
+        //
+        b(0) = b(0)/a(0,0);
+        for(i = 1; i <= n-1; i++)
+        {
+            v = ap::vdotproduct(a.getcolumn(i, 0, i-1), b.getvector(0, i-1));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        
+        //
+        // Solve U*x = y
+        //
+        b(n-1) = b(n-1)/a(n-1,n-1);
+        for(i = n-2; i >= 0; i--)
+        {
+            v = ap::vdotproduct(&a(i, i+1), &b(i+1), ap::vlen(i+1,n-1));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        ap::vmove(&x(0), &b(0), ap::vlen(0,n-1));
+    }
+    else
+    {
+        
+        //
+        // A = L*L', solve L'*y = b first
+        //
+        b(0) = b(0)/a(0,0);
+        for(i = 1; i <= n-1; i++)
+        {
+            v = ap::vdotproduct(&a(i, 0), &b(0), ap::vlen(0,i-1));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        
+        //
+        // Solve L'*x = y
+        //
+        b(n-1) = b(n-1)/a(n-1,n-1);
+        for(i = n-2; i >= 0; i--)
+        {
+            v = ap::vdotproduct(a.getcolumn(i, i+1, n-1), b.getvector(i+1, n-1));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        ap::vmove(&x(0), &b(0), ap::vlen(0,n-1));
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Solving a system of linear equations with  a  symmetric  positive-definite
+matrix by using the Cholesky decomposition.
+
+The algorithm solves a system of linear equations whose matrix is symmetric
+and positive-definite.
+
+Input parameters:
+    A       -   upper or lower triangle part of a symmetric system matrix.
+                Array whose indexes range within [0..N-1, 0..N-1].
+    B       -   right side of a system.
+                Array whose index ranges within [0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   points to the triangle of matrix A in which the matrix is stored.
+
+Output parameters:
+    X       -   solution of a system.
+                Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the system is not singular.
+    False, if the system is singular. In this case, X doesn't contain a
+solution.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+bool spdmatrixsolve(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x)
+{
+    bool result;
+
+    result = spdmatrixcholesky(a, n, isupper);
+    if( !result )
+    {
+        return result;
+    }
+    result = spdmatrixcholeskysolve(a, b, n, isupper, x);
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-bases subroutine
+*************************************************************************/
+bool solvesystemcholesky(const ap::real_2d_array& a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x)
+{
+    bool result;
+    int i;
+    int im1;
+    int ip1;
+    double v;
+
+    ap::ap_error::make_assertion(n>0, "Error: N<=0 in SolveSystemCholesky");
+    
+    //
+    // det(A)=0?
+    //
+    result = true;
+    for(i = 1; i <= n; i++)
+    {
+        if( a(i,i)==0 )
+        {
+            result = false;
+            return result;
+        }
+    }
+    
+    //
+    // det(A)<>0
+    //
+    x.setbounds(1, n);
+    if( isupper )
+    {
+        
+        //
+        // A = U'*U, solve U'*y = b first
+        //
+        b(1) = b(1)/a(1,1);
+        for(i = 2; i <= n; i++)
+        {
+            im1 = i-1;
+            v = ap::vdotproduct(a.getcolumn(i, 1, im1), b.getvector(1, im1));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        
+        //
+        // Solve U*x = y
+        //
+        b(n) = b(n)/a(n,n);
+        for(i = n-1; i >= 1; i--)
+        {
+            ip1 = i+1;
+            v = ap::vdotproduct(&a(i, ip1), &b(ip1), ap::vlen(ip1,n));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        ap::vmove(&x(1), &b(1), ap::vlen(1,n));
+    }
+    else
+    {
+        
+        //
+        // A = L*L', solve L'*y = b first
+        //
+        b(1) = b(1)/a(1,1);
+        for(i = 2; i <= n; i++)
+        {
+            im1 = i-1;
+            v = ap::vdotproduct(&a(i, 1), &b(1), ap::vlen(1,im1));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        
+        //
+        // Solve L'*x = y
+        //
+        b(n) = b(n)/a(n,n);
+        for(i = n-1; i >= 1; i--)
+        {
+            ip1 = i+1;
+            v = ap::vdotproduct(a.getcolumn(i, ip1, n), b.getvector(ip1, n));
+            b(i) = (b(i)-v)/a(i,i);
+        }
+        ap::vmove(&x(1), &b(1), ap::vlen(1,n));
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-bases subroutine
+*************************************************************************/
+bool solvespdsystem(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x)
+{
+    bool result;
+
+    result = choleskydecomposition(a, n, isupper);
+    if( !result )
+    {
+        return result;
+    }
+    result = solvesystemcholesky(a, b, n, isupper, x);
+    return result;
+}
+
+
+

data/ext/alglib/spdsolve.h

@@ -0,0 +1,105 @@
+
+#ifndef _spdsolve_h
+#define _spdsolve_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "cholesky.h"
+
+
+/*************************************************************************
+Solving a system of linear equations with a system  matrix  given  by  its
+Cholesky decomposition.
+
+The algorithm solves systems with a square matrix only.
+
+Input parameters:
+    A       -   Cholesky decomposition of a system matrix (the result of
+                the SMatrixCholesky subroutine).
+    B       -   right side of a system.
+                Array whose index ranges within [0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   points to the triangle of matrix A in which the Cholesky
+                decomposition is stored. If IsUpper=True,  the  Cholesky
+                decomposition has the form of U'*U, and the upper triangle
+                of matrix A stores matrix U (in  that  case,  the  lower
+                triangle isn�t used and isn�t changed by the subroutine)
+                Similarly, if IsUpper = False, the Cholesky decomposition
+                has the form of L*L',  and  the  lower  triangle  stores
+                matrix L.
+
+Output parameters:
+    X       -   solution of a system.
+                Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the system is not singular. X contains the solution.
+    False, if the system is singular (there is a zero element on the main
+diagonal). In this case, X doesn't contain a solution.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+bool spdmatrixcholeskysolve(const ap::real_2d_array& a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x);
+
+
+/*************************************************************************
+Solving a system of linear equations with  a  symmetric  positive-definite
+matrix by using the Cholesky decomposition.
+
+The algorithm solves a system of linear equations whose matrix is symmetric
+and positive-definite.
+
+Input parameters:
+    A       -   upper or lower triangle part of a symmetric system matrix.
+                Array whose indexes range within [0..N-1, 0..N-1].
+    B       -   right side of a system.
+                Array whose index ranges within [0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   points to the triangle of matrix A in which the matrix is stored.
+
+Output parameters:
+    X       -   solution of a system.
+                Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the system is not singular.
+    False, if the system is singular. In this case, X doesn't contain a
+solution.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+bool spdmatrixsolve(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x);
+
+
+/*************************************************************************
+Obsolete 1-bases subroutine
+*************************************************************************/
+bool solvesystemcholesky(const ap::real_2d_array& a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x);
+
+
+/*************************************************************************
+Obsolete 1-bases subroutine
+*************************************************************************/
+bool solvespdsystem(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     bool isupper,
+     ap::real_1d_array& x);
+
+
+#endif