alglib 0.1.1

data/ext/alglib/sbisinv.h

@@ -0,0 +1,171 @@
+/*************************************************************************
+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.
+*************************************************************************/
+
+#ifndef _sbisinv_h
+#define _sbisinv_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+#include "sblas.h"
+#include "reflections.h"
+#include "tridiagonal.h"
+#include "blas.h"
+#include "tdbisinv.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);
+
+
+/*************************************************************************
+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);
+
+
+/*************************************************************************
+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);
+
+
+/*************************************************************************
+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);
+
+
+#endif

data/ext/alglib/sblas.cpp

@@ -0,0 +1,185 @@
+/*************************************************************************
+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 "sblas.h"
+
+void symmetricmatrixvectormultiply(const ap::real_2d_array& a,
+     bool isupper,
+     int i1,
+     int i2,
+     const ap::real_1d_array& x,
+     double alpha,
+     ap::real_1d_array& y)
+{
+    int i;
+    int ba1;
+    int ba2;
+    int by1;
+    int by2;
+    int bx1;
+    int bx2;
+    int n;
+    double v;
+
+    n = i2-i1+1;
+    if( n<=0 )
+    {
+        return;
+    }
+    
+    //
+    // Let A = L + D + U, where
+    //  L is strictly lower triangular (main diagonal is zero)
+    //  D is diagonal
+    //  U is strictly upper triangular (main diagonal is zero)
+    //
+    // A*x = L*x + D*x + U*x
+    //
+    // Calculate D*x first
+    //
+    for(i = i1; i <= i2; i++)
+    {
+        y(i-i1+1) = a(i,i)*x(i-i1+1);
+    }
+    
+    //
+    // Add L*x + U*x
+    //
+    if( isupper )
+    {
+        for(i = i1; i <= i2-1; i++)
+        {
+            
+            //
+            // Add L*x to the result
+            //
+            v = x(i-i1+1);
+            by1 = i-i1+2;
+            by2 = n;
+            ba1 = i+1;
+            ba2 = i2;
+            ap::vadd(&y(by1), &a(i, ba1), ap::vlen(by1,by2), v);
+            
+            //
+            // Add U*x to the result
+            //
+            bx1 = i-i1+2;
+            bx2 = n;
+            ba1 = i+1;
+            ba2 = i2;
+            v = ap::vdotproduct(&x(bx1), &a(i, ba1), ap::vlen(bx1,bx2));
+            y(i-i1+1) = y(i-i1+1)+v;
+        }
+    }
+    else
+    {
+        for(i = i1+1; i <= i2; i++)
+        {
+            
+            //
+            // Add L*x to the result
+            //
+            bx1 = 1;
+            bx2 = i-i1;
+            ba1 = i1;
+            ba2 = i-1;
+            v = ap::vdotproduct(&x(bx1), &a(i, ba1), ap::vlen(bx1,bx2));
+            y(i-i1+1) = y(i-i1+1)+v;
+            
+            //
+            // Add U*x to the result
+            //
+            v = x(i-i1+1);
+            by1 = 1;
+            by2 = i-i1;
+            ba1 = i1;
+            ba2 = i-1;
+            ap::vadd(&y(by1), &a(i, ba1), ap::vlen(by1,by2), v);
+        }
+    }
+    ap::vmul(&y(1), ap::vlen(1,n), alpha);
+}
+
+
+void symmetricrank2update(ap::real_2d_array& a,
+     bool isupper,
+     int i1,
+     int i2,
+     const ap::real_1d_array& x,
+     const ap::real_1d_array& y,
+     ap::real_1d_array& t,
+     double alpha)
+{
+    int i;
+    int tp1;
+    int tp2;
+    double v;
+
+    if( isupper )
+    {
+        for(i = i1; i <= i2; i++)
+        {
+            tp1 = i+1-i1;
+            tp2 = i2-i1+1;
+            v = x(i+1-i1);
+            ap::vmove(&t(tp1), &y(tp1), ap::vlen(tp1,tp2), v);
+            v = y(i+1-i1);
+            ap::vadd(&t(tp1), &x(tp1), ap::vlen(tp1,tp2), v);
+            ap::vmul(&t(tp1), ap::vlen(tp1,tp2), alpha);
+            ap::vadd(&a(i, i), &t(tp1), ap::vlen(i,i2));
+        }
+    }
+    else
+    {
+        for(i = i1; i <= i2; i++)
+        {
+            tp1 = 1;
+            tp2 = i+1-i1;
+            v = x(i+1-i1);
+            ap::vmove(&t(tp1), &y(tp1), ap::vlen(tp1,tp2), v);
+            v = y(i+1-i1);
+            ap::vadd(&t(tp1), &x(tp1), ap::vlen(tp1,tp2), v);
+            ap::vmul(&t(tp1), ap::vlen(tp1,tp2), alpha);
+            ap::vadd(&a(i, i1), &t(tp1), ap::vlen(i1,i));
+        }
+    }
+}
+
+
+

data/ext/alglib/sblas.h

@@ -0,0 +1,64 @@
+/*************************************************************************
+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 _sblas_h
+#define _sblas_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+void symmetricmatrixvectormultiply(const ap::real_2d_array& a,
+     bool isupper,
+     int i1,
+     int i2,
+     const ap::real_1d_array& x,
+     double alpha,
+     ap::real_1d_array& y);
+
+
+void symmetricrank2update(ap::real_2d_array& a,
+     bool isupper,
+     int i1,
+     int i2,
+     const ap::real_1d_array& x,
+     const ap::real_1d_array& y,
+     ap::real_1d_array& t,
+     double alpha);
+
+
+#endif

data/ext/alglib/schur.cpp

@@ -0,0 +1,156 @@
+/*************************************************************************
+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 "schur.h"
+
+/*************************************************************************
+Subroutine performing the Schur decomposition of a general matrix by using
+the QR algorithm with multiple shifts.
+
+The source matrix A is represented as S'*A*S = T, where S is an orthogonal
+matrix (Schur vectors), T - upper quasi-triangular matrix (with blocks of
+sizes 1x1 and 2x2 on the main diagonal).
+
+Input parameters:
+    A   -   matrix to be decomposed.
+            Array whose indexes range within [0..N-1, 0..N-1].
+    N   -   size of A, N>=0.
+
+
+Output parameters:
+    A   -   contains matrix T.
+            Array whose indexes range within [0..N-1, 0..N-1].
+    S   -   contains Schur vectors.
+            Array whose indexes range within [0..N-1, 0..N-1].
+
+Note 1:
+    The block structure of matrix T can be easily recognized: since all
+    the elements below the blocks are zeros, the elements a[i+1,i] which
+    are equal to 0 show the block border.
+
+Note 2:
+    The algorithm performance depends on the value of the internal parameter
+    NS of the InternalSchurDecomposition subroutine which defines the number
+    of shifts in the QR algorithm (similarly to the block width in block-matrix
+    algorithms in linear algebra). If you require maximum performance on
+    your machine, it is recommended to adjust this parameter manually.
+
+Result:
+    True,
+        if the algorithm has converged and parameters A and S contain the result.
+    False,
+        if the algorithm has not converged.
+
+Algorithm implemented on the basis of the DHSEQR subroutine (LAPACK 3.0 library).
+*************************************************************************/
+bool rmatrixschur(ap::real_2d_array& a, int n, ap::real_2d_array& s)
+{
+    bool result;
+    ap::real_1d_array tau;
+    ap::real_1d_array wi;
+    ap::real_1d_array wr;
+    ap::real_2d_array a1;
+    ap::real_2d_array s1;
+    int info;
+    int i;
+    int j;
+
+    
+    //
+    // Upper Hessenberg form of the 0-based matrix
+    //
+    rmatrixhessenberg(a, n, tau);
+    rmatrixhessenbergunpackq(a, n, tau, s);
+    
+    //
+    // Convert from 0-based arrays to 1-based,
+    // then call InternalSchurDecomposition
+    // Awkward, of course, but Schur decompisiton subroutine
+    // is too complex to fix it.
+    //
+    //
+    a1.setbounds(1, n, 1, n);
+    s1.setbounds(1, n, 1, n);
+    for(i = 1; i <= n; i++)
+    {
+        for(j = 1; j <= n; j++)
+        {
+            a1(i,j) = a(i-1,j-1);
+            s1(i,j) = s(i-1,j-1);
+        }
+    }
+    internalschurdecomposition(a1, n, 1, 1, wr, wi, s1, info);
+    result = info==0;
+    
+    //
+    // convert from 1-based arrays to -based
+    //
+    for(i = 1; i <= n; i++)
+    {
+        for(j = 1; j <= n; j++)
+        {
+            a(i-1,j-1) = a1(i,j);
+            s(i-1,j-1) = s1(i,j);
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+See RMatrixSchur for 0-based replacement.
+*************************************************************************/
+bool schurdecomposition(ap::real_2d_array& a, int n, ap::real_2d_array& s)
+{
+    bool result;
+    ap::real_1d_array tau;
+    ap::real_1d_array wi;
+    ap::real_1d_array wr;
+    int info;
+
+    toupperhessenberg(a, n, tau);
+    unpackqfromupperhessenberg(a, n, tau, s);
+    internalschurdecomposition(a, n, 1, 1, wr, wi, s, info);
+    result = info==0;
+    return result;
+}
+
+
+