alglib 0.1.1

data/ext/alglib/trigintegrals.h

@@ -0,0 +1,131 @@
+/*************************************************************************
+Cephes Math Library Release 2.8:  June, 2000
+Copyright by Stephen L. Moshier
+
+Contributors:
+    * Sergey Bochkanov (ALGLIB project). Translation from C 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 _trigintegrals_h
+#define _trigintegrals_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+Sine and cosine integrals
+
+Evaluates the integrals
+
+                         x
+                         -
+                        |  cos t - 1
+  Ci(x) = eul + ln x +  |  --------- dt,
+                        |      t
+                       -
+                        0
+            x
+            -
+           |  sin t
+  Si(x) =  |  ----- dt
+           |    t
+          -
+           0
+
+where eul = 0.57721566490153286061 is Euler's constant.
+The integrals are approximated by rational functions.
+For x > 8 auxiliary functions f(x) and g(x) are employed
+such that
+
+Ci(x) = f(x) sin(x) - g(x) cos(x)
+Si(x) = pi/2 - f(x) cos(x) - g(x) sin(x)
+
+
+ACCURACY:
+   Test interval = [0,50].
+Absolute error, except relative when > 1:
+arithmetic   function   # trials      peak         rms
+   IEEE        Si        30000       4.4e-16     7.3e-17
+   IEEE        Ci        30000       6.9e-16     5.1e-17
+
+Cephes Math Library Release 2.1:  January, 1989
+Copyright 1984, 1987, 1989 by Stephen L. Moshier
+*************************************************************************/
+void sinecosineintegrals(double x, double& si, double& ci);
+
+
+/*************************************************************************
+Hyperbolic sine and cosine integrals
+
+Approximates the integrals
+
+                           x
+                           -
+                          | |   cosh t - 1
+  Chi(x) = eul + ln x +   |    -----------  dt,
+                        | |          t
+                         -
+                         0
+
+              x
+              -
+             | |  sinh t
+  Shi(x) =   |    ------  dt
+           | |       t
+            -
+            0
+
+where eul = 0.57721566490153286061 is Euler's constant.
+The integrals are evaluated by power series for x < 8
+and by Chebyshev expansions for x between 8 and 88.
+For large x, both functions approach exp(x)/2x.
+Arguments greater than 88 in magnitude return MAXNUM.
+
+
+ACCURACY:
+
+Test interval 0 to 88.
+                     Relative error:
+arithmetic   function  # trials      peak         rms
+   IEEE         Shi      30000       6.9e-16     1.6e-16
+       Absolute error, except relative when |Chi| > 1:
+   IEEE         Chi      30000       8.4e-16     1.4e-16
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1987, 2000 by Stephen L. Moshier
+*************************************************************************/
+void hyperbolicsinecosineintegrals(double x, double& shi, double& chi);
+
+
+#endif

data/ext/alglib/trinverse.cpp

@@ -0,0 +1,345 @@
+/*************************************************************************
+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 "trinverse.h"
+
+/*************************************************************************
+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, and the diagonal elements are not passed to 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 rmatrixtrinverse(ap::real_2d_array& a,
+     int n,
+     bool isupper,
+     bool isunittriangular)
+{
+    bool result;
+    bool nounit;
+    int i;
+    int j;
+    double v;
+    double ajj;
+    ap::real_1d_array t;
+
+    result = true;
+    t.setbounds(0, n-1);
+    
+    //
+    // Test the input parameters.
+    //
+    nounit = !isunittriangular;
+    if( isupper )
+    {
+        
+        //
+        // Compute inverse of upper triangular matrix.
+        //
+        for(j = 0; j <= n-1; j++)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            
+            //
+            // Compute elements 1:j-1 of j-th column.
+            //
+            if( j>0 )
+            {
+                ap::vmove(t.getvector(0, j-1), a.getcolumn(j, 0, j-1));
+                for(i = 0; i <= j-1; i++)
+                {
+                    if( i<j-1 )
+                    {
+                        v = ap::vdotproduct(&a(i, i+1), &t(i+1), ap::vlen(i+1,j-1));
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                ap::vmul(a.getcolumn(j, 0, j-1), ajj);
+            }
+        }
+    }
+    else
+    {
+        
+        //
+        // Compute inverse of lower triangular matrix.
+        //
+        for(j = n-1; j >= 0; j--)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            if( j<n-1 )
+            {
+                
+                //
+                // Compute elements j+1:n of j-th column.
+                //
+                ap::vmove(t.getvector(j+1, n-1), a.getcolumn(j, j+1, n-1));
+                for(i = j+1; i <= n-1; i++)
+                {
+                    if( i>j+1 )
+                    {
+                        v = ap::vdotproduct(&a(i, j+1), &t(j+1), ap::vlen(j+1,i-1));
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                ap::vmul(a.getcolumn(j, j+1, n-1), ajj);
+            }
+        }
+    }
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine.
+See RMatrixTRInverse for 0-based replacement.
+*************************************************************************/
+bool invtriangular(ap::real_2d_array& a,
+     int n,
+     bool isupper,
+     bool isunittriangular)
+{
+    bool result;
+    bool nounit;
+    int i;
+    int j;
+    int nmj;
+    int jm1;
+    int jp1;
+    double v;
+    double ajj;
+    ap::real_1d_array t;
+
+    result = true;
+    t.setbounds(1, n);
+    
+    //
+    // Test the input parameters.
+    //
+    nounit = !isunittriangular;
+    if( isupper )
+    {
+        
+        //
+        // Compute inverse of upper triangular matrix.
+        //
+        for(j = 1; j <= n; j++)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            
+            //
+            // Compute elements 1:j-1 of j-th column.
+            //
+            if( j>1 )
+            {
+                jm1 = j-1;
+                ap::vmove(t.getvector(1, jm1), a.getcolumn(j, 1, jm1));
+                for(i = 1; i <= j-1; i++)
+                {
+                    if( i<j-1 )
+                    {
+                        v = ap::vdotproduct(&a(i, i+1), &t(i+1), ap::vlen(i+1,jm1));
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                ap::vmul(a.getcolumn(j, 1, jm1), ajj);
+            }
+        }
+    }
+    else
+    {
+        
+        //
+        // Compute inverse of lower triangular matrix.
+        //
+        for(j = n; j >= 1; j--)
+        {
+            if( nounit )
+            {
+                if( a(j,j)==0 )
+                {
+                    result = false;
+                    return result;
+                }
+                a(j,j) = 1/a(j,j);
+                ajj = -a(j,j);
+            }
+            else
+            {
+                ajj = -1;
+            }
+            if( j<n )
+            {
+                
+                //
+                // Compute elements j+1:n of j-th column.
+                //
+                nmj = n-j;
+                jp1 = j+1;
+                ap::vmove(t.getvector(jp1, n), a.getcolumn(j, jp1, n));
+                for(i = j+1; i <= n; i++)
+                {
+                    if( i>j+1 )
+                    {
+                        v = ap::vdotproduct(&a(i, jp1), &t(jp1), ap::vlen(jp1,i-1));
+                    }
+                    else
+                    {
+                        v = 0;
+                    }
+                    if( nounit )
+                    {
+                        a(i,j) = v+a(i,i)*t(i);
+                    }
+                    else
+                    {
+                        a(i,j) = v+t(i);
+                    }
+                }
+                ap::vmul(a.getcolumn(j, jp1, n), ajj);
+            }
+        }
+    }
+    return result;
+}
+
+
+