alglib 0.1.1

data/ext/alglib/csolve.h

@@ -0,0 +1,99 @@
+
+#ifndef _csolve_h
+#define _csolve_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "clu.h"
+
+
+/*************************************************************************
+Solving a system of linear equations with a system matrix given by its
+LU decomposition.
+
+The algorithm solves a system of linear equations whose matrix is given by
+its LU decomposition. In case of a singular matrix, the algorithm  returns
+False.
+
+The algorithm solves systems with a square matrix only.
+
+Input parameters:
+    A       -   LU decomposition of a system matrix in compact  form  (the
+                result of the RMatrixLU subroutine).
+    Pivots  -   row permutation table (the result of a
+                RMatrixLU subroutine).
+    B       -   right side of a system.
+                Array whose index ranges within [0..N-1].
+    N       -   size of matrix A.
+
+Output parameters:
+    X       -   solution of a system.
+                Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrux is singular. In this case, X doesn't contain a
+solution.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+bool cmatrixlusolve(const ap::complex_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     ap::complex_1d_array b,
+     int n,
+     ap::complex_1d_array& x);
+
+
+/*************************************************************************
+Solving a system of linear equations.
+
+The algorithm solves a system of linear equations by using the
+LU decomposition. The algorithm solves systems with a square matrix only.
+
+Input parameters:
+    A   -   system matrix.
+            Array whose indexes range within [0..N-1, 0..N-1].
+    B   -   right side of a system.
+            Array whose indexes range within [0..N-1].
+    N   -   size of matrix A.
+
+Output parameters:
+    X   -   solution of a system.
+            Array whose index ranges within [0..N-1].
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrix is singular. In this case, X doesn't contain a
+solution.
+
+  -- ALGLIB --
+     Copyright 2005-2008 by Bochkanov Sergey
+*************************************************************************/
+bool cmatrixsolve(ap::complex_2d_array a,
+     ap::complex_1d_array b,
+     int n,
+     ap::complex_1d_array& x);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexsolvesystemlu(const ap::complex_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     ap::complex_1d_array b,
+     int n,
+     ap::complex_1d_array& x);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexsolvesystem(ap::complex_2d_array a,
+     ap::complex_1d_array b,
+     int n,
+     ap::complex_1d_array& x);
+
+
+#endif

data/ext/alglib/ctrinverse.cpp

@@ -0,0 +1,387 @@
+/*************************************************************************
+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 "ctrinverse.h"
+
+/*************************************************************************
+Complex triangular matrix inversion
+
+The subroutine inverts the following types of matrices:
+    * upper triangular
+    * upper triangular with unit diagonal
+    * lower triangular
+    * lower triangular with unit diagonal
+
+In case of an upper (lower) triangular matrix,  the  inverse  matrix  will
+also be upper (lower) triangular, and after  the  end  of  the  algorithm,
+the inverse matrix replaces the source matrix. The elements  below (above)
+the main diagonal are not changed by the algorithm.
+
+If the matrix has a unit diagonal, the inverse  matrix  also  has  a  unit
+diagonal, the diagonal elements are not passed to the algorithm, they  are
+not changed by the algorithm.
+
+Input parameters:
+    A       -   matrix.
+                Array whose indexes range within [0..N-1,0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   True, if the matrix is upper triangular.
+    IsUnitTriangular
+            -   True, if the matrix has a unit diagonal.
+
+Output parameters:
+    A       -   inverse matrix (if the problem is not degenerate).
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrix is singular.
+
+  -- LAPACK routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     February 29, 1992
+*************************************************************************/
+bool cmatrixtrinverse(ap::complex_2d_array& a,
+     int n,
+     bool isupper,
+     bool isunittriangular)
+{
+    bool result;
+    bool nounit;
+    int i;
+    int j;
+    ap::complex v;
+    ap::complex ajj;
+    ap::complex_1d_array t;
+    int i_;
+
+    result = true;
+    t.setbounds(0, n-1);
+    
+    //
+    // Test the input parameters.
+    //
+    nounit = !isunittriangular;
+    if( isupper )
+    {
+        
+        //
+        // Compute inverse of upper triangular matrix.
+        //
+        for(j = 0; j <= n-1; j++)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            
+            //
+            // Compute elements 1:j-1 of j-th column.
+            //
+            if( j>0 )
+            {
+                for(i_=0; i_<=j-1;i_++)
+                {
+                    t(i_) = a(i_,j);
+                }
+                for(i = 0; i <= j-1; i++)
+                {
+                    if( i+1<j )
+                    {
+                        v = 0.0;
+                        for(i_=i+1; i_<=j-1;i_++)
+                        {
+                            v += a(i,i_)*t(i_);
+                        }
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                for(i_=0; i_<=j-1;i_++)
+                {
+                    a(i_,j) = ajj*a(i_,j);
+                }
+            }
+        }
+    }
+    else
+    {
+        
+        //
+        // Compute inverse of lower triangular matrix.
+        //
+        for(j = n-1; j >= 0; j--)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            if( j+1<n )
+            {
+                
+                //
+                // Compute elements j+1:n of j-th column.
+                //
+                for(i_=j+1; i_<=n-1;i_++)
+                {
+                    t(i_) = a(i_,j);
+                }
+                for(i = j+1; i <= n-1; i++)
+                {
+                    if( i>j+1 )
+                    {
+                        v = 0.0;
+                        for(i_=j+1; i_<=i-1;i_++)
+                        {
+                            v += a(i,i_)*t(i_);
+                        }
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                for(i_=j+1; i_<=n-1;i_++)
+                {
+                    a(i_,j) = ajj*a(i_,j);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexinvtriangular(ap::complex_2d_array& a,
+     int n,
+     bool isupper,
+     bool isunittriangular)
+{
+    bool result;
+    bool nounit;
+    int i;
+    int j;
+    int nmj;
+    int jm1;
+    int jp1;
+    ap::complex v;
+    ap::complex ajj;
+    ap::complex_1d_array t;
+    int i_;
+
+    result = true;
+    t.setbounds(1, n);
+    
+    //
+    // Test the input parameters.
+    //
+    nounit = !isunittriangular;
+    if( isupper )
+    {
+        
+        //
+        // Compute inverse of upper triangular matrix.
+        //
+        for(j = 1; j <= n; j++)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            
+            //
+            // Compute elements 1:j-1 of j-th column.
+            //
+            if( j>1 )
+            {
+                jm1 = j-1;
+                for(i_=1; i_<=jm1;i_++)
+                {
+                    t(i_) = a(i_,j);
+                }
+                for(i = 1; i <= j-1; i++)
+                {
+                    if( i<j-1 )
+                    {
+                        v = 0.0;
+                        for(i_=i+1; i_<=jm1;i_++)
+                        {
+                            v += a(i,i_)*t(i_);
+                        }
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                for(i_=1; i_<=jm1;i_++)
+                {
+                    a(i_,j) = ajj*a(i_,j);
+                }
+            }
+        }
+    }
+    else
+    {
+        
+        //
+        // Compute inverse of lower triangular matrix.
+        //
+        for(j = n; j >= 1; j--)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            if( j<n )
+            {
+                
+                //
+                // Compute elements j+1:n of j-th column.
+                //
+                nmj = n-j;
+                jp1 = j+1;
+                for(i_=jp1; i_<=n;i_++)
+                {
+                    t(i_) = a(i_,j);
+                }
+                for(i = j+1; i <= n; i++)
+                {
+                    if( i>j+1 )
+                    {
+                        v = 0.0;
+                        for(i_=jp1; i_<=i-1;i_++)
+                        {
+                            v += a(i,i_)*t(i_);
+                        }
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                for(i_=jp1; i_<=n;i_++)
+                {
+                    a(i_,j) = ajj*a(i_,j);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+
+