alglib 0.1.1

data/ext/alglib/trlinsolve.h

@@ -0,0 +1,73 @@
+
+#ifndef _trlinsolve_h
+#define _trlinsolve_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+Utility subroutine performing the "safe" solution of system of linear
+equations with triangular coefficient matrices.
+
+The subroutine uses scaling and solves the scaled system A*x=s*b (where  s
+is  a  scalar  value)  instead  of  A*x=b,  choosing  s  so  that x can be
+represented by a floating-point number. The closer the system  gets  to  a
+singular, the less s is. If the system is singular, s=0 and x contains the
+non-trivial solution of equation A*x=0.
+
+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.
+
+The algorithm can solve systems of equations with  upper/lower  triangular
+matrices,  with/without unit diagonal, and systems of type A*x=b or A'*x=b
+(where A' is a transposed matrix A).
+
+Input parameters:
+    A       -   system matrix. Array whose indexes range within [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    X       -   right-hand member of a system.
+                Array whose index ranges within [0..N-1].
+    IsUpper -   matrix type. If it is True, the system matrix is the upper
+                triangular and is located in  the  corresponding  part  of
+                matrix A.
+    Trans   -   problem type. If it is True, the problem to be  solved  is
+                A'*x=b, otherwise it is A*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.
+
+Output parameters:
+    X       -   solution. Array whose index ranges within [0..N-1].
+    S       -   scaling factor.
+
+  -- LAPACK auxiliary 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 rmatrixtrsafesolve(const ap::real_2d_array& a,
+     int n,
+     ap::real_1d_array& x,
+     double& s,
+     bool isupper,
+     bool istrans,
+     bool isunit);
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+See RMatrixTRSafeSolve for 0-based replacement.
+*************************************************************************/
+void safesolvetriangular(const ap::real_2d_array& a,
+     int n,
+     ap::real_1d_array& x,
+     double& s,
+     bool isupper,
+     bool istrans,
+     bool isunit,
+     bool normin,
+     ap::real_1d_array& cnorm);
+
+
+#endif

data/ext/alglib/tsort.cpp

@@ -0,0 +1,405 @@
+/*************************************************************************
+Copyright 2008 by 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 "tsort.h"
+
+void tagsort(ap::real_1d_array& a,
+     int n,
+     ap::integer_1d_array& p1,
+     ap::integer_1d_array& p2)
+{
+    int i;
+    int j;
+    int k;
+    int t;
+    double tmp;
+    int tmpi;
+    ap::integer_1d_array pv;
+    ap::integer_1d_array vp;
+    int lv;
+    int lp;
+    int rv;
+    int rp;
+
+    
+    //
+    // Special cases
+    //
+    if( n<=0 )
+    {
+        return;
+    }
+    if( n==1 )
+    {
+        p1.setbounds(0, 0);
+        p2.setbounds(0, 0);
+        p1(0) = 0;
+        p2(0) = 0;
+        return;
+    }
+    
+    //
+    // General case, N>1: prepare permutations table P1
+    //
+    p1.setbounds(0, n-1);
+    for(i = 0; i <= n-1; i++)
+    {
+        p1(i) = i;
+    }
+    
+    //
+    // General case, N>1: sort, update P1
+    //
+    tagsortfasti(a, p1, n);
+    
+    //
+    // General case, N>1: fill permutations table P2
+    //
+    // To fill P2 we maintain two arrays:
+    // * PV, Position(Value). PV[i] contains position of I-th key at the moment
+    // * VP, Value(Position). VP[i] contains key which has position I at the moment
+    //
+    // At each step we making permutation of two items:
+    //   Left, which is given by position/value pair LP/LV
+    //   and Right, which is given by RP/RV
+    // and updating PV[] and VP[] correspondingly.
+    //
+    pv.setbounds(0, n-1);
+    vp.setbounds(0, n-1);
+    p2.setbounds(0, n-1);
+    for(i = 0; i <= n-1; i++)
+    {
+        pv(i) = i;
+        vp(i) = i;
+    }
+    for(i = 0; i <= n-1; i++)
+    {
+        
+        //
+        // calculate LP, LV, RP, RV
+        //
+        lp = i;
+        lv = vp(lp);
+        rv = p1(i);
+        rp = pv(rv);
+        
+        //
+        // Fill P2
+        //
+        p2(i) = rp;
+        
+        //
+        // update PV and VP
+        //
+        vp(lp) = rv;
+        vp(rp) = lv;
+        pv(lv) = rp;
+        pv(rv) = lp;
+    }
+}
+
+
+void tagsortfasti(ap::real_1d_array& a, ap::integer_1d_array& b, int n)
+{
+    int i;
+    int j;
+    int k;
+    int t;
+    double tmp;
+    int tmpi;
+
+    
+    //
+    // Special cases
+    //
+    if( n<=1 )
+    {
+        return;
+    }
+    
+    //
+    // General case, N>1: sort, update B
+    //
+    i = 2;
+    do
+    {
+        t = i;
+        while(t!=1)
+        {
+            k = t/2;
+            if( a(k-1)>=a(t-1) )
+            {
+                t = 1;
+            }
+            else
+            {
+                tmp = a(k-1);
+                a(k-1) = a(t-1);
+                a(t-1) = tmp;
+                tmpi = b(k-1);
+                b(k-1) = b(t-1);
+                b(t-1) = tmpi;
+                t = k;
+            }
+        }
+        i = i+1;
+    }
+    while(i<=n);
+    i = n-1;
+    do
+    {
+        tmp = a(i);
+        a(i) = a(0);
+        a(0) = tmp;
+        tmpi = b(i);
+        b(i) = b(0);
+        b(0) = tmpi;
+        t = 1;
+        while(t!=0)
+        {
+            k = 2*t;
+            if( k>i )
+            {
+                t = 0;
+            }
+            else
+            {
+                if( k<i )
+                {
+                    if( a(k)>a(k-1) )
+                    {
+                        k = k+1;
+                    }
+                }
+                if( a(t-1)>=a(k-1) )
+                {
+                    t = 0;
+                }
+                else
+                {
+                    tmp = a(k-1);
+                    a(k-1) = a(t-1);
+                    a(t-1) = tmp;
+                    tmpi = b(k-1);
+                    b(k-1) = b(t-1);
+                    b(t-1) = tmpi;
+                    t = k;
+                }
+            }
+        }
+        i = i-1;
+    }
+    while(i>=1);
+}
+
+
+void tagsortfastr(ap::real_1d_array& a, ap::real_1d_array& b, int n)
+{
+    int i;
+    int j;
+    int k;
+    int t;
+    double tmp;
+    double tmpr;
+
+    
+    //
+    // Special cases
+    //
+    if( n<=1 )
+    {
+        return;
+    }
+    
+    //
+    // General case, N>1: sort, update B
+    //
+    i = 2;
+    do
+    {
+        t = i;
+        while(t!=1)
+        {
+            k = t/2;
+            if( a(k-1)>=a(t-1) )
+            {
+                t = 1;
+            }
+            else
+            {
+                tmp = a(k-1);
+                a(k-1) = a(t-1);
+                a(t-1) = tmp;
+                tmpr = b(k-1);
+                b(k-1) = b(t-1);
+                b(t-1) = tmpr;
+                t = k;
+            }
+        }
+        i = i+1;
+    }
+    while(i<=n);
+    i = n-1;
+    do
+    {
+        tmp = a(i);
+        a(i) = a(0);
+        a(0) = tmp;
+        tmpr = b(i);
+        b(i) = b(0);
+        b(0) = tmpr;
+        t = 1;
+        while(t!=0)
+        {
+            k = 2*t;
+            if( k>i )
+            {
+                t = 0;
+            }
+            else
+            {
+                if( k<i )
+                {
+                    if( a(k)>a(k-1) )
+                    {
+                        k = k+1;
+                    }
+                }
+                if( a(t-1)>=a(k-1) )
+                {
+                    t = 0;
+                }
+                else
+                {
+                    tmp = a(k-1);
+                    a(k-1) = a(t-1);
+                    a(t-1) = tmp;
+                    tmpr = b(k-1);
+                    b(k-1) = b(t-1);
+                    b(t-1) = tmpr;
+                    t = k;
+                }
+            }
+        }
+        i = i-1;
+    }
+    while(i>=1);
+}
+
+
+void tagsortfast(ap::real_1d_array& a, int n)
+{
+    int i;
+    int j;
+    int k;
+    int t;
+    double tmp;
+    double tmpr;
+
+    
+    //
+    // Special cases
+    //
+    if( n<=1 )
+    {
+        return;
+    }
+    
+    //
+    // General case, N>1: sort, update B
+    //
+    i = 2;
+    do
+    {
+        t = i;
+        while(t!=1)
+        {
+            k = t/2;
+            if( a(k-1)>=a(t-1) )
+            {
+                t = 1;
+            }
+            else
+            {
+                tmp = a(k-1);
+                a(k-1) = a(t-1);
+                a(t-1) = tmp;
+                t = k;
+            }
+        }
+        i = i+1;
+    }
+    while(i<=n);
+    i = n-1;
+    do
+    {
+        tmp = a(i);
+        a(i) = a(0);
+        a(0) = tmp;
+        t = 1;
+        while(t!=0)
+        {
+            k = 2*t;
+            if( k>i )
+            {
+                t = 0;
+            }
+            else
+            {
+                if( k<i )
+                {
+                    if( a(k)>a(k-1) )
+                    {
+                        k = k+1;
+                    }
+                }
+                if( a(t-1)>=a(k-1) )
+                {
+                    t = 0;
+                }
+                else
+                {
+                    tmp = a(k-1);
+                    a(k-1) = a(t-1);
+                    a(t-1) = tmp;
+                    t = k;
+                }
+            }
+        }
+        i = i-1;
+    }
+    while(i>=1);
+}
+
+
+