alglib 0.1.1

data/ext/alglib/ctrinverse.h

@@ -0,0 +1,98 @@
+/*************************************************************************
+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 _ctrinverse_h
+#define _ctrinverse_h
+
+#include "ap.h"
+#include "ialglib.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);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool complexinvtriangular(ap::complex_2d_array& a,
+     int n,
+     bool isupper,
+     bool isunittriangular);
+
+
+#endif

data/ext/alglib/ctrlinsolve.cpp

@@ -0,0 +1,297 @@
+
+#include <stdafx.h>
+#include "ctrlinsolve.h"
+
+/*************************************************************************
+Utility subroutine performing the "safe" solution of a  system  of  linear
+equations with triangular complex coefficient matrices.
+
+The feature of an algorithm is that it could not cause an  overflow  or  a
+division by zero regardless of the matrix used as the input. If an overflow
+is possible, an error code is returned.
+
+The algorithm can solve systems of equations with upper/lower triangular
+matrices,  with/without unit diagonal, and systems of types A*x=b, A^T*x=b,
+A^H*x=b.
+
+Input parameters:
+    A       -   system matrix.
+                Array whose indexes range within [1..N, 1..N].
+    N       -   size of matrix A.
+    X       -   right-hand member of a system.
+                Array whose index ranges within [1..N].
+    IsUpper -   matrix type. If it is True, the system matrix is the upper
+                triangular matrix and is located in the corresponding part
+                of matrix A.
+    Trans   -   problem type.
+                If Trans is:
+                    * 0, A*x=b
+                    * 1, A^T*x=b
+                    * 2, A^H*x=b
+    IsUnit  -   matrix type. If it is True, the system matrix has  a  unit
+                diagonal (the elements on the main diagonal are  not  used
+                in the calculation process), otherwise the matrix is
+                considered to be a general triangular matrix.
+    CNORM   -   array which is stored in norms of rows and columns of  the
+                matrix. If the array hasn't been filled up during previous
+                executions  of  an  algorithm  with the same matrix as the
+                input,  it  will  be  filled  up by the subroutine. If the
+                array is filled up, the subroutine uses it without filling
+                it up again.
+    NORMIN  -   flag defining the state of column norms array. If True, the
+                array is filled up.
+    WORKA   -   working array whose index ranges within [1..N].
+    WORKX   -   working array whose index ranges within [1..N].
+
+Output parameters (if the result is True):
+    X       -   solution. Array whose index ranges within [1..N].
+    CNORM   -   array of column norms whose index ranges within [1..N].
+
+Result:
+    True, if the matrix is not singular  and  the  algorithm  finished its
+        work correctly without causing an overflow.
+    False, if  the  matrix  is  singular  or  the  algorithm was cancelled
+        because of an overflow possibility.
+
+Note:
+    The disadvantage of an algorithm is that  sometimes  it  overestimates
+    an overflow probability. This is not a problem when  solving  ordinary
+    systems. If the elements of the matrix used as the input are close  to
+    MaxRealNumber, a false overflow detection is possible, but in practice
+    such matrices can rarely be found.
+    You can find more reliable subroutines in the LAPACK library
+    (xLATRS subroutine ).
+
+  -- ALGLIB --
+     Copyright 31.03.2006 by Bochkanov Sergey
+*************************************************************************/
+bool complexsafesolvetriangular(const ap::complex_2d_array& a,
+     int n,
+     ap::complex_1d_array& x,
+     bool isupper,
+     int trans,
+     bool isunit,
+     ap::complex_1d_array& worka,
+     ap::complex_1d_array& workx)
+{
+    bool result;
+    int i;
+    int l;
+    int j;
+    bool dolswp;
+    double ma;
+    double mx;
+    double v;
+    ap::complex t;
+    ap::complex r;
+    int i_;
+    int i1_;
+
+    ap::ap_error::make_assertion(trans>=0&&trans<=2, "ComplexSafeSolveTriangular: incorrect parameters!");
+    result = true;
+    
+    //
+    // Quick return if possible
+    //
+    if( n<=0 )
+    {
+        return result;
+    }
+    
+    //
+    // Main cycle
+    //
+    for(l = 1; l <= n; l++)
+    {
+        
+        //
+        // Prepare subtask L
+        //
+        dolswp = false;
+        if( trans==0 )
+        {
+            if( isupper )
+            {
+                i = n+1-l;
+                i1_ = (i) - (1);
+                for(i_=1; i_<=l;i_++)
+                {
+                    worka(i_) = a(i,i_+i1_);
+                }
+                i1_ = (i) - (1);
+                for(i_=1; i_<=l;i_++)
+                {
+                    workx(i_) = x(i_+i1_);
+                }
+                dolswp = true;
+            }
+            if( !isupper )
+            {
+                i = l;
+                for(i_=1; i_<=l;i_++)
+                {
+                    worka(i_) = a(i,i_);
+                }
+                for(i_=1; i_<=l;i_++)
+                {
+                    workx(i_) = x(i_);
+                }
+            }
+        }
+        if( trans==1 )
+        {
+            if( isupper )
+            {
+                i = l;
+                for(i_=1; i_<=l;i_++)
+                {
+                    worka(i_) = a(i_,i);
+                }
+                for(i_=1; i_<=l;i_++)
+                {
+                    workx(i_) = x(i_);
+                }
+            }
+            if( !isupper )
+            {
+                i = n+1-l;
+                i1_ = (i) - (1);
+                for(i_=1; i_<=l;i_++)
+                {
+                    worka(i_) = a(i_+i1_,i);
+                }
+                i1_ = (i) - (1);
+                for(i_=1; i_<=l;i_++)
+                {
+                    workx(i_) = x(i_+i1_);
+                }
+                dolswp = true;
+            }
+        }
+        if( trans==2 )
+        {
+            if( isupper )
+            {
+                i = l;
+                for(i_=1; i_<=l;i_++)
+                {
+                    worka(i_) = ap::conj(a(i_,i));
+                }
+                for(i_=1; i_<=l;i_++)
+                {
+                    workx(i_) = x(i_);
+                }
+            }
+            if( !isupper )
+            {
+                i = n+1-l;
+                i1_ = (i) - (1);
+                for(i_=1; i_<=l;i_++)
+                {
+                    worka(i_) = ap::conj(a(i_+i1_,i));
+                }
+                i1_ = (i) - (1);
+                for(i_=1; i_<=l;i_++)
+                {
+                    workx(i_) = x(i_+i1_);
+                }
+                dolswp = true;
+            }
+        }
+        if( dolswp )
+        {
+            t = workx(l);
+            workx(l) = workx(1);
+            workx(1) = t;
+            t = worka(l);
+            worka(l) = worka(1);
+            worka(1) = t;
+        }
+        if( isunit )
+        {
+            worka(l) = 1;
+        }
+        
+        //
+        // Test if workA[L]=0
+        //
+        if( worka(l)==0 )
+        {
+            result = false;
+            return result;
+        }
+        
+        //
+        // Now we have:
+        //
+        //  workA[1:L]*workX[1:L] = b[I]
+        //
+        // with known workA[1:L] and workX[1:L-1]
+        // and unknown workX[L]
+        //
+        t = 0;
+        if( l>=2 )
+        {
+            ma = 0;
+            for(j = 1; j <= l-1; j++)
+            {
+                ma = ap::maxreal(ma, ap::abscomplex(worka(j)));
+            }
+            mx = 0;
+            for(j = 1; j <= l-1; j++)
+            {
+                mx = ap::maxreal(mx, ap::abscomplex(workx(j)));
+            }
+            if( ap::maxreal(ma, mx)>1 )
+            {
+                v = ap::maxrealnumber/ap::maxreal(ma, mx);
+                v = v/(l-1);
+                if( v<ap::minreal(ma, mx) )
+                {
+                    result = false;
+                    return result;
+                }
+            }
+            t = 0.0;
+            for(i_=1; i_<=l-1;i_++)
+            {
+                t += worka(i_)*workx(i_);
+            }
+        }
+        
+        //
+        // Now we have:
+        //
+        //  workA[L]*workX[L] + T = b[I]
+        //
+        if( ap::maxreal(ap::abscomplex(t), ap::abscomplex(x(i)))>=0.5*ap::maxrealnumber )
+        {
+            result = false;
+            return result;
+        }
+        r = x(i)-t;
+        
+        //
+        // Now we have:
+        //
+        //  workA[L]*workX[L] = R
+        //
+        if( r!=0 )
+        {
+            if( log(ap::abscomplex(r))-log(ap::abscomplex(worka(l)))>=log(ap::maxrealnumber) )
+            {
+                result = false;
+                return result;
+            }
+        }
+        
+        //
+        // X[I]
+        //
+        x(i) = r/worka(l);
+    }
+    return result;
+}
+
+
+

data/ext/alglib/ctrlinsolve.h

@@ -0,0 +1,81 @@
+
+#ifndef _ctrlinsolve_h
+#define _ctrlinsolve_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+Utility subroutine performing the "safe" solution of a  system  of  linear
+equations with triangular complex coefficient matrices.
+
+The feature of an algorithm is that it could not cause an  overflow  or  a
+division by zero regardless of the matrix used as the input. If an overflow
+is possible, an error code is returned.
+
+The algorithm can solve systems of equations with upper/lower triangular
+matrices,  with/without unit diagonal, and systems of types A*x=b, A^T*x=b,
+A^H*x=b.
+
+Input parameters:
+    A       -   system matrix.
+                Array whose indexes range within [1..N, 1..N].
+    N       -   size of matrix A.
+    X       -   right-hand member of a system.
+                Array whose index ranges within [1..N].
+    IsUpper -   matrix type. If it is True, the system matrix is the upper
+                triangular matrix and is located in the corresponding part
+                of matrix A.
+    Trans   -   problem type.
+                If Trans is:
+                    * 0, A*x=b
+                    * 1, A^T*x=b
+                    * 2, A^H*x=b
+    IsUnit  -   matrix type. If it is True, the system matrix has  a  unit
+                diagonal (the elements on the main diagonal are  not  used
+                in the calculation process), otherwise the matrix is
+                considered to be a general triangular matrix.
+    CNORM   -   array which is stored in norms of rows and columns of  the
+                matrix. If the array hasn't been filled up during previous
+                executions  of  an  algorithm  with the same matrix as the
+                input,  it  will  be  filled  up by the subroutine. If the
+                array is filled up, the subroutine uses it without filling
+                it up again.
+    NORMIN  -   flag defining the state of column norms array. If True, the
+                array is filled up.
+    WORKA   -   working array whose index ranges within [1..N].
+    WORKX   -   working array whose index ranges within [1..N].
+
+Output parameters (if the result is True):
+    X       -   solution. Array whose index ranges within [1..N].
+    CNORM   -   array of column norms whose index ranges within [1..N].
+
+Result:
+    True, if the matrix is not singular  and  the  algorithm  finished its
+        work correctly without causing an overflow.
+    False, if  the  matrix  is  singular  or  the  algorithm was cancelled
+        because of an overflow possibility.
+
+Note:
+    The disadvantage of an algorithm is that  sometimes  it  overestimates
+    an overflow probability. This is not a problem when  solving  ordinary
+    systems. If the elements of the matrix used as the input are close  to
+    MaxRealNumber, a false overflow detection is possible, but in practice
+    such matrices can rarely be found.
+    You can find more reliable subroutines in the LAPACK library
+    (xLATRS subroutine ).
+
+  -- ALGLIB --
+     Copyright 31.03.2006 by Bochkanov Sergey
+*************************************************************************/
+bool complexsafesolvetriangular(const ap::complex_2d_array& a,
+     int n,
+     ap::complex_1d_array& x,
+     bool isupper,
+     int trans,
+     bool isunit,
+     ap::complex_1d_array& worka,
+     ap::complex_1d_array& workx);
+
+
+#endif