alglib 0.1.1

data/ext/alglib/cinverse.cpp

@@ -0,0 +1,298 @@
+/*************************************************************************
+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 "cinverse.h"
+
+/*************************************************************************
+Inversion of a complex matrix given by its LU decomposition.
+
+Input parameters:
+    A       -   LU decomposition of the matrix (output of CMatrixLU subroutine).
+    Pivots  -   table of permutations which were made during the LU decomposition
+                (the output of CMatrixLU subroutine).
+    N       -   size of matrix A.
+
+Output parameters:
+    A       -   inverse of matrix A.
+                Array whose indexes range within [0..N-1, 0..N-1].
+
+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 cmatrixluinverse(ap::complex_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     int n)
+{
+    bool result;
+    ap::complex_1d_array work;
+    int i;
+    int iws;
+    int j;
+    int jb;
+    int jj;
+    int jp;
+    ap::complex v;
+    int i_;
+
+    result = true;
+    
+    //
+    // Quick return if possible
+    //
+    if( n==0 )
+    {
+        return result;
+    }
+    work.setbounds(0, n-1);
+    
+    //
+    // Form inv(U)
+    //
+    if( !cmatrixtrinverse(a, n, true, false) )
+    {
+        result = false;
+        return result;
+    }
+    
+    //
+    // Solve the equation inv(A)*L = inv(U) for inv(A).
+    //
+    for(j = n-1; j >= 0; j--)
+    {
+        
+        //
+        // Copy current column of L to WORK and replace with zeros.
+        //
+        for(i = j+1; i <= n-1; i++)
+        {
+            work(i) = a(i,j);
+            a(i,j) = 0;
+        }
+        
+        //
+        // Compute current column of inv(A).
+        //
+        if( j<n-1 )
+        {
+            for(i = 0; i <= n-1; i++)
+            {
+                v = 0.0;
+                for(i_=j+1; i_<=n-1;i_++)
+                {
+                    v += a(i,i_)*work(i_);
+                }
+                a(i,j) = a(i,j)-v;
+            }
+        }
+    }
+    
+    //
+    // Apply column interchanges.
+    //
+    for(j = n-2; j >= 0; j--)
+    {
+        jp = pivots(j);
+        if( jp!=j )
+        {
+            for(i_=0; i_<=n-1;i_++)
+            {
+                work(i_) = a(i_,j);
+            }
+            for(i_=0; i_<=n-1;i_++)
+            {
+                a(i_,j) = a(i_,jp);
+            }
+            for(i_=0; i_<=n-1;i_++)
+            {
+                a(i_,jp) = work(i_);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Inversion of a general complex matrix.
+
+Input parameters:
+    A   -   matrix. Array whose indexes range within [0..N-1, 0..N-1].
+    N   -   size of matrix A.
+
+Output parameters:
+    A   -   inverse of matrix A.
+            Array whose indexes range within [0..N-1, 0..N-1].
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrix is singular.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+bool cmatrixinverse(ap::complex_2d_array& a, int n)
+{
+    bool result;
+    ap::integer_1d_array pivots;
+
+    cmatrixlu(a, n, n, pivots);
+    result = cmatrixluinverse(a, pivots, n);
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexinverselu(ap::complex_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     int n)
+{
+    bool result;
+    ap::complex_1d_array work;
+    int i;
+    int iws;
+    int j;
+    int jb;
+    int jj;
+    int jp;
+    int jp1;
+    ap::complex v;
+    int i_;
+
+    result = true;
+    
+    //
+    // Quick return if possible
+    //
+    if( n==0 )
+    {
+        return result;
+    }
+    work.setbounds(1, n);
+    
+    //
+    // Form inv(U)
+    //
+    if( !complexinvtriangular(a, n, true, false) )
+    {
+        result = false;
+        return result;
+    }
+    
+    //
+    // Solve the equation inv(A)*L = inv(U) for inv(A).
+    //
+    for(j = n; j >= 1; j--)
+    {
+        
+        //
+        // Copy current column of L to WORK and replace with zeros.
+        //
+        for(i = j+1; i <= n; i++)
+        {
+            work(i) = a(i,j);
+            a(i,j) = 0;
+        }
+        
+        //
+        // Compute current column of inv(A).
+        //
+        if( j<n )
+        {
+            jp1 = j+1;
+            for(i = 1; i <= n; i++)
+            {
+                v = 0.0;
+                for(i_=jp1; i_<=n;i_++)
+                {
+                    v += a(i,i_)*work(i_);
+                }
+                a(i,j) = a(i,j)-v;
+            }
+        }
+    }
+    
+    //
+    // Apply column interchanges.
+    //
+    for(j = n-1; j >= 1; j--)
+    {
+        jp = pivots(j);
+        if( jp!=j )
+        {
+            for(i_=1; i_<=n;i_++)
+            {
+                work(i_) = a(i_,j);
+            }
+            for(i_=1; i_<=n;i_++)
+            {
+                a(i_,j) = a(i_,jp);
+            }
+            for(i_=1; i_<=n;i_++)
+            {
+                a(i_,jp) = work(i_);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexinverse(ap::complex_2d_array& a, int n)
+{
+    bool result;
+    ap::integer_1d_array pivots;
+
+    complexludecomposition(a, n, n, pivots);
+    result = complexinverselu(a, pivots, n);
+    return result;
+}
+
+
+

data/ext/alglib/cinverse.h

@@ -0,0 +1,111 @@
+/*************************************************************************
+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 _cinverse_h
+#define _cinverse_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "clu.h"
+#include "ctrinverse.h"
+
+
+/*************************************************************************
+Inversion of a complex matrix given by its LU decomposition.
+
+Input parameters:
+    A       -   LU decomposition of the matrix (output of CMatrixLU subroutine).
+    Pivots  -   table of permutations which were made during the LU decomposition
+                (the output of CMatrixLU subroutine).
+    N       -   size of matrix A.
+
+Output parameters:
+    A       -   inverse of matrix A.
+                Array whose indexes range within [0..N-1, 0..N-1].
+
+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 cmatrixluinverse(ap::complex_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     int n);
+
+
+/*************************************************************************
+Inversion of a general complex matrix.
+
+Input parameters:
+    A   -   matrix. Array whose indexes range within [0..N-1, 0..N-1].
+    N   -   size of matrix A.
+
+Output parameters:
+    A   -   inverse of matrix A.
+            Array whose indexes range within [0..N-1, 0..N-1].
+
+Result:
+    True, if the matrix is not singular.
+    False, if the matrix is singular.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+bool cmatrixinverse(ap::complex_2d_array& a, int n);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexinverselu(ap::complex_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     int n);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexinverse(ap::complex_2d_array& a, int n);
+
+
+#endif

data/ext/alglib/clu.cpp

@@ -0,0 +1,337 @@
+/*************************************************************************
+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 "clu.h"
+
+/*************************************************************************
+LU decomposition of a complex general matrix of size MxN
+
+The subroutine calculates the LU decomposition of a rectangular general
+matrix with partial pivoting (with row permutations).
+
+Input parameters:
+    A   -   matrix A whose indexes range within [0..M-1, 0..N-1].
+    M   -   number of rows in matrix A.
+    N   -   number of columns in matrix A.
+
+Output parameters:
+    A   -   matrices L and U in compact form (see below).
+            Array whose indexes range within [0..M-1, 0..N-1].
+    Pivots - permutation matrix in compact form (see below).
+            Array whose index ranges within [0..Min(M-1,N-1)].
+
+Matrix A is represented as A = P * L * U, where P is a permutation matrix,
+matrix L - lower triangular (or lower trapezoid, if M>N) matrix,
+U - upper triangular (or upper trapezoid, if M<N) matrix.
+
+Let M be equal to 4 and N be equal to 3:
+
+                   (  1          )    ( U11 U12 U13  )
+A = P1 * P2 * P3 * ( L21  1      )  * (     U22 U23  )
+                   ( L31 L32  1  )    (         U33  )
+                   ( L41 L42 L43 )
+
+Matrix L has size MxMin(M,N), matrix U has size Min(M,N)xN, matrix P(i) is
+a permutation of the identity matrix of size MxM with numbers I and Pivots[I].
+
+The algorithm returns array Pivots and the following matrix which replaces
+matrix A and contains matrices L and U in compact form (the example applies
+to M=4, N=3).
+
+ ( U11 U12 U13 )
+ ( L21 U22 U23 )
+ ( L31 L32 U33 )
+ ( L41 L42 L43 )
+
+As we can see, the unit diagonal isn't stored.
+
+  -- LAPACK routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     June 30, 1992
+*************************************************************************/
+void cmatrixlu(ap::complex_2d_array& a,
+     int m,
+     int n,
+     ap::integer_1d_array& pivots)
+{
+    int i;
+    int j;
+    int jp;
+    ap::complex_1d_array t1;
+    ap::complex s;
+    int i_;
+
+    pivots.setbounds(0, ap::minint(m-1, n-1));
+    t1.setbounds(0, ap::maxint(m-1, n-1));
+    ap::ap_error::make_assertion(m>=0&&n>=0, "Error in LUDecomposition: incorrect function arguments");
+    
+    //
+    // Quick return if possible
+    //
+    if( m==0||n==0 )
+    {
+        return;
+    }
+    for(j = 0; j <= ap::minint(m-1, n-1); j++)
+    {
+        
+        //
+        // Find pivot and test for singularity.
+        //
+        jp = j;
+        for(i = j+1; i <= m-1; i++)
+        {
+            if( ap::abscomplex(a(i,j))>ap::abscomplex(a(jp,j)) )
+            {
+                jp = i;
+            }
+        }
+        pivots(j) = jp;
+        if( a(jp,j)!=0 )
+        {
+            
+            //
+            //Apply the interchange to rows
+            //
+            if( jp!=j )
+            {
+                for(i_=0; i_<=n-1;i_++)
+                {
+                    t1(i_) = a(j,i_);
+                }
+                for(i_=0; i_<=n-1;i_++)
+                {
+                    a(j,i_) = a(jp,i_);
+                }
+                for(i_=0; i_<=n-1;i_++)
+                {
+                    a(jp,i_) = t1(i_);
+                }
+            }
+            
+            //
+            //Compute elements J+1:M of J-th column.
+            //
+            if( j<m )
+            {
+                jp = j+1;
+                s = 1/a(j,j);
+                for(i_=jp; i_<=m-1;i_++)
+                {
+                    a(i_,j) = s*a(i_,j);
+                }
+            }
+        }
+        if( j<ap::minint(m, n)-1 )
+        {
+            
+            //
+            //Update trailing submatrix.
+            //
+            jp = j+1;
+            for(i = j+1; i <= m-1; i++)
+            {
+                s = a(i,j);
+                for(i_=jp; i_<=n-1;i_++)
+                {
+                    a(i,i_) = a(i,i_) - s*a(j,i_);
+                }
+            }
+        }
+    }
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine, left for backward compatibility.
+See CMatrixLU for 0-based replacement.
+*************************************************************************/
+void complexludecomposition(ap::complex_2d_array& a,
+     int m,
+     int n,
+     ap::integer_1d_array& pivots)
+{
+    int i;
+    int j;
+    int jp;
+    ap::complex_1d_array t1;
+    ap::complex s;
+    int i_;
+
+    pivots.setbounds(1, ap::minint(m, n));
+    t1.setbounds(1, ap::maxint(m, n));
+    ap::ap_error::make_assertion(m>=0&&n>=0, "Error in ComplexLUDecomposition: incorrect function arguments");
+    
+    //
+    // Quick return if possible
+    //
+    if( m==0||n==0 )
+    {
+        return;
+    }
+    for(j = 1; j <= ap::minint(m, n); j++)
+    {
+        
+        //
+        // Find pivot and test for singularity.
+        //
+        jp = j;
+        for(i = j+1; i <= m; i++)
+        {
+            if( ap::abscomplex(a(i,j))>ap::abscomplex(a(jp,j)) )
+            {
+                jp = i;
+            }
+        }
+        pivots(j) = jp;
+        if( a(jp,j)!=0 )
+        {
+            
+            //
+            //Apply the interchange to rows
+            //
+            if( jp!=j )
+            {
+                for(i_=1; i_<=n;i_++)
+                {
+                    t1(i_) = a(j,i_);
+                }
+                for(i_=1; i_<=n;i_++)
+                {
+                    a(j,i_) = a(jp,i_);
+                }
+                for(i_=1; i_<=n;i_++)
+                {
+                    a(jp,i_) = t1(i_);
+                }
+            }
+            
+            //
+            //Compute elements J+1:M of J-th column.
+            //
+            if( j<m )
+            {
+                jp = j+1;
+                s = 1/a(j,j);
+                for(i_=jp; i_<=m;i_++)
+                {
+                    a(i_,j) = s*a(i_,j);
+                }
+            }
+        }
+        if( j<ap::minint(m, n) )
+        {
+            
+            //
+            //Update trailing submatrix.
+            //
+            jp = j+1;
+            for(i = j+1; i <= m; i++)
+            {
+                s = a(i,j);
+                for(i_=jp; i_<=n;i_++)
+                {
+                    a(i,i_) = a(i,i_) - s*a(j,i_);
+                }
+            }
+        }
+    }
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine, left for backward compatibility.
+See CMatrixLU for 0-based replacement.
+*************************************************************************/
+void complexludecompositionunpacked(ap::complex_2d_array a,
+     int m,
+     int n,
+     ap::complex_2d_array& l,
+     ap::complex_2d_array& u,
+     ap::integer_1d_array& pivots)
+{
+    int i;
+    int j;
+    int minmn;
+
+    if( m==0||n==0 )
+    {
+        return;
+    }
+    minmn = ap::minint(m, n);
+    l.setbounds(1, m, 1, minmn);
+    u.setbounds(1, minmn, 1, n);
+    complexludecomposition(a, m, n, pivots);
+    for(i = 1; i <= m; i++)
+    {
+        for(j = 1; j <= minmn; j++)
+        {
+            if( j>i )
+            {
+                l(i,j) = 0;
+            }
+            if( j==i )
+            {
+                l(i,j) = 1;
+            }
+            if( j<i )
+            {
+                l(i,j) = a(i,j);
+            }
+        }
+    }
+    for(i = 1; i <= minmn; i++)
+    {
+        for(j = 1; j <= n; j++)
+        {
+            if( j<i )
+            {
+                u(i,j) = 0;
+            }
+            if( j>=i )
+            {
+                u(i,j) = a(i,j);
+            }
+        }
+    }
+}
+
+
+