alglib 0.1.1

data/ext/alglib/rotations.h

@@ -0,0 +1,128 @@
+/*************************************************************************
+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 _rotations_h
+#define _rotations_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+Application of a sequence of  elementary rotations to a matrix
+
+The algorithm pre-multiplies the matrix by a sequence of rotation
+transformations which is given by arrays C and S. Depending on the value
+of the IsForward parameter either 1 and 2, 3 and 4 and so on (if IsForward=true)
+rows are rotated, or the rows N and N-1, N-2 and N-3 and so on, are rotated.
+
+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:
+    IsForward   -   the sequence of the rotation application.
+    M1,M2       -   the range of rows to be transformed.
+    N1, N2      -   the range of columns to be transformed.
+    C,S         -   transformation coefficients.
+                    Array whose index ranges within [1..M2-M1].
+    A           -   processed matrix.
+    WORK        -   working array whose index ranges within [N1..N2].
+
+Output parameters:
+    A           -   transformed matrix.
+
+Utility subroutine.
+*************************************************************************/
+void applyrotationsfromtheleft(bool isforward,
+     int m1,
+     int m2,
+     int n1,
+     int n2,
+     const ap::real_1d_array& c,
+     const ap::real_1d_array& s,
+     ap::real_2d_array& a,
+     ap::real_1d_array& work);
+
+
+/*************************************************************************
+Application of a sequence of  elementary rotations to a matrix
+
+The algorithm post-multiplies the matrix by a sequence of rotation
+transformations which is given by arrays C and S. Depending on the value
+of the IsForward parameter either 1 and 2, 3 and 4 and so on (if IsForward=true)
+rows are rotated, or the rows N and N-1, N-2 and N-3 and so on are rotated.
+
+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:
+    IsForward   -   the sequence of the rotation application.
+    M1,M2       -   the range of rows to be transformed.
+    N1, N2      -   the range of columns to be transformed.
+    C,S         -   transformation coefficients.
+                    Array whose index ranges within [1..N2-N1].
+    A           -   processed matrix.
+    WORK        -   working array whose index ranges within [M1..M2].
+
+Output parameters:
+    A           -   transformed matrix.
+
+Utility subroutine.
+*************************************************************************/
+void applyrotationsfromtheright(bool isforward,
+     int m1,
+     int m2,
+     int n1,
+     int n2,
+     const ap::real_1d_array& c,
+     const ap::real_1d_array& s,
+     ap::real_2d_array& a,
+     ap::real_1d_array& work);
+
+
+/*************************************************************************
+The subroutine generates the elementary rotation, so that:
+
+[  CS  SN  ]  .  [ F ]  =  [ R ]
+[ -SN  CS  ]     [ G ]     [ 0 ]
+
+CS**2 + SN**2 = 1
+*************************************************************************/
+void generaterotation(double f, double g, double& cs, double& sn, double& r);
+
+
+#endif

data/ext/alglib/rsolve.cpp

@@ -0,0 +1,221 @@
+
+#include <stdafx.h>
+#include "rsolve.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 rmatrixlusolve(const ap::real_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x)
+{
+    bool result;
+    ap::real_1d_array y;
+    int i;
+    int j;
+    double v;
+
+    y.setbounds(0, n-1);
+    x.setbounds(0, n-1);
+    result = true;
+    for(i = 0; i <= n-1; i++)
+    {
+        if( a(i,i)==0 )
+        {
+            result = false;
+            return result;
+        }
+    }
+    
+    //
+    // pivots
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        if( pivots(i)!=i )
+        {
+            v = b(i);
+            b(i) = b(pivots(i));
+            b(pivots(i)) = v;
+        }
+    }
+    
+    //
+    // Ly = b
+    //
+    y(0) = b(0);
+    for(i = 1; i <= n-1; i++)
+    {
+        v = ap::vdotproduct(&a(i, 0), &y(0), ap::vlen(0,i-1));
+        y(i) = b(i)-v;
+    }
+    
+    //
+    // Ux = y
+    //
+    x(n-1) = y(n-1)/a(n-1,n-1);
+    for(i = n-2; i >= 0; i--)
+    {
+        v = ap::vdotproduct(&a(i, i+1), &x(i+1), ap::vlen(i+1,n-1));
+        x(i) = (y(i)-v)/a(i,i);
+    }
+    return result;
+}
+
+
+/*************************************************************************
+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 rmatrixsolve(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x)
+{
+    bool result;
+    ap::integer_1d_array pivots;
+    int i;
+
+    rmatrixlu(a, n, n, pivots);
+    result = rmatrixlusolve(a, pivots, b, n, x);
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool solvesystemlu(const ap::real_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x)
+{
+    bool result;
+    ap::real_1d_array y;
+    int i;
+    int j;
+    double v;
+    int ip1;
+    int im1;
+
+    y.setbounds(1, n);
+    x.setbounds(1, n);
+    result = true;
+    for(i = 1; i <= n; i++)
+    {
+        if( a(i,i)==0 )
+        {
+            result = false;
+            return result;
+        }
+    }
+    
+    //
+    // pivots
+    //
+    for(i = 1; i <= n; i++)
+    {
+        if( pivots(i)!=i )
+        {
+            v = b(i);
+            b(i) = b(pivots(i));
+            b(pivots(i)) = v;
+        }
+    }
+    
+    //
+    // Ly = b
+    //
+    y(1) = b(1);
+    for(i = 2; i <= n; i++)
+    {
+        im1 = i-1;
+        v = ap::vdotproduct(&a(i, 1), &y(1), ap::vlen(1,im1));
+        y(i) = b(i)-v;
+    }
+    
+    //
+    // Ux = y
+    //
+    x(n) = y(n)/a(n,n);
+    for(i = n-1; i >= 1; i--)
+    {
+        ip1 = i+1;
+        v = ap::vdotproduct(&a(i, ip1), &x(ip1), ap::vlen(ip1,n));
+        x(i) = (y(i)-v)/a(i,i);
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool solvesystem(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x)
+{
+    bool result;
+    ap::integer_1d_array pivots;
+    int i;
+
+    ludecomposition(a, n, n, pivots);
+    result = solvesystemlu(a, pivots, b, n, x);
+    return result;
+}
+
+
+

data/ext/alglib/rsolve.h

@@ -0,0 +1,99 @@
+
+#ifndef _rsolve_h
+#define _rsolve_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "lu.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 rmatrixlusolve(const ap::real_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     ap::real_1d_array b,
+     int n,
+     ap::real_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 rmatrixsolve(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool solvesystemlu(const ap::real_2d_array& a,
+     const ap::integer_1d_array& pivots,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool solvesystem(ap::real_2d_array a,
+     ap::real_1d_array b,
+     int n,
+     ap::real_1d_array& x);
+
+
+#endif

data/ext/alglib/sbisinv.cpp

@@ -0,0 +1,217 @@
+/*************************************************************************
+Copyright (c) 2005-2007, Sergey Bochkanov (ALGLIB project).
+
+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 "sbisinv.h"
+
+/*************************************************************************
+Subroutine for finding the eigenvalues (and eigenvectors) of  a  symmetric
+matrix  in  a  given half open interval (A, B] by using  a  bisection  and
+inverse iteration
+
+Input parameters:
+    A       -   symmetric matrix which is given by its upper or lower
+                triangular part. Array [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    ZNeeded -   flag controlling whether the eigenvectors are needed or not.
+                If ZNeeded is equal to:
+                 * 0, the eigenvectors are not returned;
+                 * 1, the eigenvectors are returned.
+    IsUpperA -  storage format of matrix A.
+    B1, B2 -    half open interval (B1, B2] to search eigenvalues in.
+
+Output parameters:
+    M       -   number of eigenvalues found in a given half-interval (M>=0).
+    W       -   array of the eigenvalues found.
+                Array whose index ranges within [0..M-1].
+    Z       -   if ZNeeded is equal to:
+                 * 0, Z hasn�t changed;
+                 * 1, Z contains eigenvectors.
+                Array whose indexes range within [0..N-1, 0..M-1].
+                The eigenvectors are stored in the matrix columns.
+
+Result:
+    True, if successful. M contains the number of eigenvalues in the given
+    half-interval (could be equal to 0), W contains the eigenvalues,
+    Z contains the eigenvectors (if needed).
+
+    False, if the bisection method subroutine wasn't able to find the
+    eigenvalues in the given interval or if the inverse iteration subroutine
+    wasn't able to find all the corresponding eigenvectors.
+    In that case, the eigenvalues and eigenvectors are not returned,
+    M is equal to 0.
+
+  -- ALGLIB --
+     Copyright 07.01.2006 by Bochkanov Sergey
+*************************************************************************/
+bool smatrixevdr(ap::real_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     double b1,
+     double b2,
+     int& m,
+     ap::real_1d_array& w,
+     ap::real_2d_array& z)
+{
+    bool result;
+    ap::real_1d_array tau;
+    ap::real_1d_array e;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "SMatrixTDEVDR: incorrect ZNeeded");
+    smatrixtd(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        smatrixtdunpackq(a, n, isupper, tau, z);
+    }
+    result = smatrixtdevdr(w, e, n, zneeded, b1, b2, m, z);
+    return result;
+}
+
+
+/*************************************************************************
+Subroutine for finding the eigenvalues and  eigenvectors  of  a  symmetric
+matrix with given indexes by using bisection and inverse iteration methods.
+
+Input parameters:
+    A       -   symmetric matrix which is given by its upper or lower
+                triangular part. Array whose indexes range within [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    ZNeeded -   flag controlling whether the eigenvectors are needed or not.
+                If ZNeeded is equal to:
+                 * 0, the eigenvectors are not returned;
+                 * 1, the eigenvectors are returned.
+    IsUpperA -  storage format of matrix A.
+    I1, I2 -    index interval for searching (from I1 to I2).
+                0 <= I1 <= I2 <= N-1.
+
+Output parameters:
+    W       -   array of the eigenvalues found.
+                Array whose index ranges within [0..I2-I1].
+    Z       -   if ZNeeded is equal to:
+                 * 0, Z hasn�t changed;
+                 * 1, Z contains eigenvectors.
+                Array whose indexes range within [0..N-1, 0..I2-I1].
+                In that case, the eigenvectors are stored in the matrix columns.
+
+Result:
+    True, if successful. W contains the eigenvalues, Z contains the
+    eigenvectors (if needed).
+
+    False, if the bisection method subroutine wasn't able to find the
+    eigenvalues in the given interval or if the inverse iteration subroutine
+    wasn't able to find all the corresponding eigenvectors.
+    In that case, the eigenvalues and eigenvectors are not returned.
+
+  -- ALGLIB --
+     Copyright 07.01.2006 by Bochkanov Sergey
+*************************************************************************/
+bool smatrixevdi(ap::real_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     int i1,
+     int i2,
+     ap::real_1d_array& w,
+     ap::real_2d_array& z)
+{
+    bool result;
+    ap::real_1d_array tau;
+    ap::real_1d_array e;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "SMatrixEVDI: incorrect ZNeeded");
+    smatrixtd(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        smatrixtdunpackq(a, n, isupper, tau, z);
+    }
+    result = smatrixtdevdi(w, e, n, zneeded, i1, i2, z);
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool symmetriceigenvaluesandvectorsininterval(ap::real_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     double b1,
+     double b2,
+     int& m,
+     ap::real_1d_array& w,
+     ap::real_2d_array& z)
+{
+    bool result;
+    ap::real_1d_array tau;
+    ap::real_1d_array e;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "SymmetricEigenValuesAndVectorsInInterval: incorrect ZNeeded");
+    totridiagonal(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        unpackqfromtridiagonal(a, n, isupper, tau, z);
+    }
+    result = tridiagonaleigenvaluesandvectorsininterval(w, e, n, zneeded, b1, b2, m, z);
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+bool symmetriceigenvaluesandvectorsbyindexes(ap::real_2d_array a,
+     int n,
+     int zneeded,
+     bool isupper,
+     int i1,
+     int i2,
+     ap::real_1d_array& w,
+     ap::real_2d_array& z)
+{
+    bool result;
+    ap::real_1d_array tau;
+    ap::real_1d_array e;
+
+    ap::ap_error::make_assertion(zneeded==0||zneeded==1, "SymmetricEigenValuesAndVectorsInInterval: incorrect ZNeeded");
+    totridiagonal(a, n, isupper, tau, w, e);
+    if( zneeded==1 )
+    {
+        unpackqfromtridiagonal(a, n, isupper, tau, z);
+    }
+    result = tridiagonaleigenvaluesandvectorsbyindexes(w, e, n, zneeded, i1, i2, z);
+    return result;
+}
+
+
+