alglib 0.1.1

data/ext/alglib/crcond.h

@@ -0,0 +1,148 @@
+/*************************************************************************
+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 _crcond_h
+#define _crcond_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "clu.h"
+#include "ctrlinsolve.h"
+
+
+/*************************************************************************
+Estimate of a matrix condition number (1-norm)
+
+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).
+
+Input parameters:
+    A   -   matrix. Array whose indexes range within [0..N-1, 0..N-1].
+    N   -   size of matrix A.
+
+Result: 1/LowerBound(cond(A))
+*************************************************************************/
+double cmatrixrcond1(const ap::complex_2d_array& a, int n);
+
+
+/*************************************************************************
+Estimate of the condition number of a matrix given by its LU decomposition (1-norm)
+
+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).
+
+Input parameters:
+    LUDcmp      -   LU decomposition of a matrix in compact form. Output of
+                    the CMatrixLU subroutine.
+    N           -   size of matrix A.
+
+Result: 1/LowerBound(cond(A))
+*************************************************************************/
+double cmatrixlurcond1(const ap::complex_2d_array& ludcmp, int n);
+
+
+/*************************************************************************
+Estimate of a matrix condition number (infinity-norm).
+
+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).
+
+Input parameters:
+    A   -   matrix. Array whose indexes range within [0..N-1, 0..N-1].
+    N   -   size of matrix A.
+
+Result: 1/LowerBound(cond(A))
+*************************************************************************/
+double cmatrixrcondinf(const ap::complex_2d_array& a, int n);
+
+
+/*************************************************************************
+Estimate of the condition number of a matrix given by its LU decomposition
+(infinity norm).
+
+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).
+
+Input parameters:
+    LUDcmp  -   LU decomposition of a matrix in compact form. Output of
+                the CMatrixLU subroutine.
+    N       -   size of matrix A.
+
+Result: 1/LowerBound(cond(A))
+*************************************************************************/
+double cmatrixlurcondinf(const ap::complex_2d_array& ludcmp, int n);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+*************************************************************************/
+double complexrcond1(ap::complex_2d_array a, int n);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+*************************************************************************/
+double complexrcond1lu(const ap::complex_2d_array& lu, int n);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+*************************************************************************/
+double complexrcondinf(ap::complex_2d_array a, int n);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+*************************************************************************/
+double complexrcondinflu(const ap::complex_2d_array& lu, int n);
+
+
+void internalestimatecomplexrcondlu(const ap::complex_2d_array& lu,
+     const int& n,
+     bool onenorm,
+     bool isanormprovided,
+     double anorm,
+     double& rcond);
+
+
+#endif

data/ext/alglib/creflections.cpp

@@ -0,0 +1,310 @@
+/*************************************************************************
+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 "creflections.h"
+
+/*************************************************************************
+Generation of an elementary complex reflection transformation
+
+The subroutine generates elementary complex reflection H of  order  N,  so
+that, for a given X, the following equality holds true:
+
+     ( X(1) )   ( Beta )
+H' * (  ..  ) = (  0   ),   H'*H = I,   Beta is a real number
+     ( X(n) )   (  0   )
+
+where
+
+              ( V(1) )
+H = 1 - Tau * (  ..  ) * ( conj(V(1)), ..., conj(V(n)) )
+              ( V(n) )
+
+where the first component of vector V equals 1.
+
+Input parameters:
+    X   -   vector. Array with elements [1..N].
+    N   -   reflection order.
+
+Output parameters:
+    X   -   components from 2 to N are replaced by vector V.
+            The first component is replaced with parameter Beta.
+    Tau -   scalar value Tau.
+
+This subroutine is the modification of CLARFG subroutines  from the LAPACK
+library. It has similar functionality except for the fact that it  doesn�t
+handle errors when intermediate results cause an overflow.
+
+  -- LAPACK auxiliary routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     September 30, 1994
+*************************************************************************/
+void complexgeneratereflection(ap::complex_1d_array& x,
+     int n,
+     ap::complex& tau)
+{
+    int j;
+    int knt;
+    ap::complex alpha;
+    double alphi;
+    double alphr;
+    double beta;
+    double xnorm;
+    double mx;
+    ap::complex t;
+    int i_;
+
+    if( n<=0 )
+    {
+        tau = 0;
+        return;
+    }
+    alpha = x(1);
+    mx = 0;
+    for(j = 2; j <= n; j++)
+    {
+        mx = ap::maxreal(ap::abscomplex(x(j)), mx);
+    }
+    xnorm = 0;
+    if( mx!=0 )
+    {
+        for(j = 2; j <= n; j++)
+        {
+            t = x(j)/mx;
+            xnorm = xnorm+(t*ap::conj(t)).x;
+        }
+        xnorm = sqrt(xnorm)*mx;
+    }
+    alphr = alpha.x;
+    alphi = alpha.y;
+    if( xnorm==0&&alphi==0 )
+    {
+        tau = 0;
+        return;
+    }
+    mx = ap::maxreal(fabs(alphr), fabs(alphi));
+    mx = ap::maxreal(mx, fabs(xnorm));
+    beta = -mx*sqrt(ap::sqr(alphr/mx)+ap::sqr(alphi/mx)+ap::sqr(xnorm/mx));
+    if( alphr<0 )
+    {
+        beta = -beta;
+    }
+    tau.x = (beta-alphr)/beta;
+    tau.y = -alphi/beta;
+    alpha = 1/(alpha-beta);
+    if( n>1 )
+    {
+        for(i_=2; i_<=n;i_++)
+        {
+            x(i_) = alpha*x(i_);
+        }
+    }
+    alpha = beta;
+    x(1) = alpha;
+}
+
+
+/*************************************************************************
+Application of an elementary reflection to a rectangular matrix of size MxN
+
+The  algorithm  pre-multiplies  the  matrix  by  an  elementary reflection
+transformation  which  is  given  by  column  V  and  scalar  Tau (see the
+description of the GenerateReflection). Not the whole matrix  but  only  a
+part of it is transformed (rows from M1 to M2, columns from N1 to N2). Only
+the elements of this submatrix are changed.
+
+Note: the matrix is multiplied by H, not by H'.   If  it  is  required  to
+multiply the matrix by H', it is necessary to pass Conj(Tau) instead of Tau.
+
+Input parameters:
+    C       -   matrix to be transformed.
+    Tau     -   scalar defining transformation.
+    V       -   column defining transformation.
+                Array whose index ranges within [1..M2-M1+1]
+    M1, M2  -   range of rows to be transformed.
+    N1, N2  -   range of columns to be transformed.
+    WORK    -   working array whose index goes from N1 to N2.
+
+Output parameters:
+    C       -   the result of multiplying the input matrix C by the
+                transformation matrix which is given by Tau and V.
+                If N1>N2 or M1>M2, C is not modified.
+
+  -- LAPACK auxiliary routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     September 30, 1994
+*************************************************************************/
+void complexapplyreflectionfromtheleft(ap::complex_2d_array& c,
+     ap::complex tau,
+     const ap::complex_1d_array& v,
+     int m1,
+     int m2,
+     int n1,
+     int n2,
+     ap::complex_1d_array& work)
+{
+    ap::complex t;
+    int i;
+    int vm;
+    int i_;
+
+    if( tau==0||n1>n2||m1>m2 )
+    {
+        return;
+    }
+    
+    //
+    // w := C^T * conj(v)
+    //
+    vm = m2-m1+1;
+    for(i = n1; i <= n2; i++)
+    {
+        work(i) = 0;
+    }
+    for(i = m1; i <= m2; i++)
+    {
+        t = ap::conj(v(i+1-m1));
+        for(i_=n1; i_<=n2;i_++)
+        {
+            work(i_) = work(i_) + t*c(i,i_);
+        }
+    }
+    
+    //
+    // C := C - tau * v * w^T
+    //
+    for(i = m1; i <= m2; i++)
+    {
+        t = v(i-m1+1)*tau;
+        for(i_=n1; i_<=n2;i_++)
+        {
+            c(i,i_) = c(i,i_) - t*work(i_);
+        }
+    }
+}
+
+
+/*************************************************************************
+Application of an elementary reflection to a rectangular matrix of size MxN
+
+The  algorithm  post-multiplies  the  matrix  by  an elementary reflection
+transformation  which  is  given  by  column  V  and  scalar  Tau (see the
+description  of  the  GenerateReflection). Not the whole matrix but only a
+part  of  it  is  transformed (rows from M1 to M2, columns from N1 to N2).
+Only the elements of this submatrix are changed.
+
+Input parameters:
+    C       -   matrix to be transformed.
+    Tau     -   scalar defining transformation.
+    V       -   column defining transformation.
+                Array whose index ranges within [1..N2-N1+1]
+    M1, M2  -   range of rows to be transformed.
+    N1, N2  -   range of columns to be transformed.
+    WORK    -   working array whose index goes from M1 to M2.
+
+Output parameters:
+    C       -   the result of multiplying the input matrix C by the
+                transformation matrix which is given by Tau and V.
+                If N1>N2 or M1>M2, C is not modified.
+
+  -- LAPACK auxiliary routine (version 3.0) --
+     Univ. of Tennessee, Univ. of California Berkeley, NAG Ltd.,
+     Courant Institute, Argonne National Lab, and Rice University
+     September 30, 1994
+*************************************************************************/
+void complexapplyreflectionfromtheright(ap::complex_2d_array& c,
+     ap::complex tau,
+     ap::complex_1d_array& v,
+     int m1,
+     int m2,
+     int n1,
+     int n2,
+     ap::complex_1d_array& work)
+{
+    ap::complex t;
+    int i;
+    int vm;
+    int i_;
+    int i1_;
+
+    if( tau==0||n1>n2||m1>m2 )
+    {
+        return;
+    }
+    
+    //
+    // w := C * v
+    //
+    vm = n2-n1+1;
+    for(i = m1; i <= m2; i++)
+    {
+        i1_ = (1)-(n1);
+        t = 0.0;
+        for(i_=n1; i_<=n2;i_++)
+        {
+            t += c(i,i_)*v(i_+i1_);
+        }
+        work(i) = t;
+    }
+    
+    //
+    // C := C - w * conj(v^T)
+    //
+    for(i_=1; i_<=vm;i_++)
+    {
+        v(i_) = ap::conj(v(i_));
+    }
+    for(i = m1; i <= m2; i++)
+    {
+        t = work(i)*tau;
+        i1_ = (1) - (n1);
+        for(i_=n1; i_<=n2;i_++)
+        {
+            c(i,i_) = c(i,i_) - t*v(i_+i1_);
+        }
+    }
+    for(i_=1; i_<=vm;i_++)
+    {
+        v(i_) = ap::conj(v(i_));
+    }
+}
+
+
+