alglib 0.1.1

data/ext/alglib/spline3.h

@@ -0,0 +1,290 @@
+/*************************************************************************
+Copyright (c) 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 _spline3_h
+#define _spline3_h
+
+#include "ap.h"
+#include "ialglib.h"
+
+/*************************************************************************
+This subroutine builds linear spline coefficients table.
+
+Input parameters:
+    X   -   spline nodes, array[0..N-1]
+    Y   -   function values, array[0..N-1]
+    N   -   points count, N>=2
+    
+Output parameters:
+    C   -   coefficients table.  Used  by  SplineInterpolation  and  other
+            subroutines from this file.
+
+  -- ALGLIB PROJECT --
+     Copyright 24.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void buildlinearspline(ap::real_1d_array x,
+     ap::real_1d_array y,
+     int n,
+     ap::real_1d_array& c);
+
+
+/*************************************************************************
+This subroutine builds cubic spline coefficients table.
+
+Input parameters:
+    X           -   spline nodes, array[0..N-1]
+    Y           -   function values, array[0..N-1]
+    N           -   points count, N>=2
+    BoundLType  -   boundary condition type for the left boundary
+    BoundL      -   left boundary condition (first or second derivative,
+                    depending on the BoundLType)
+    BoundRType  -   boundary condition type for the right boundary
+    BoundR      -   right boundary condition (first or second derivative,
+                    depending on the BoundRType)
+
+Output parameters:
+    C           -   coefficients table.  Used  by  SplineInterpolation and
+                    other subroutines from this file.
+                    
+The BoundLType/BoundRType parameters can have the following values:
+    * 0,   which  corresponds  to  the  parabolically   terminated  spline
+      (BoundL/BoundR are ignored).
+    * 1, which corresponds to the first derivative boundary condition
+    * 2, which corresponds to the second derivative boundary condition
+
+  -- ALGLIB PROJECT --
+     Copyright 23.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void buildcubicspline(ap::real_1d_array x,
+     ap::real_1d_array y,
+     int n,
+     int boundltype,
+     double boundl,
+     int boundrtype,
+     double boundr,
+     ap::real_1d_array& c);
+
+
+/*************************************************************************
+This subroutine builds cubic Hermite spline coefficients table.
+
+Input parameters:
+    X           -   spline nodes, array[0..N-1]
+    Y           -   function values, array[0..N-1]
+    D           -   derivatives, array[0..N-1]
+    N           -   points count, N>=2
+
+Output parameters:
+    C           -   coefficients table.  Used  by  SplineInterpolation and
+                    other subroutines from this file.
+
+  -- ALGLIB PROJECT --
+     Copyright 23.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void buildhermitespline(ap::real_1d_array x,
+     ap::real_1d_array y,
+     ap::real_1d_array d,
+     int n,
+     ap::real_1d_array& c);
+
+
+/*************************************************************************
+This subroutine builds Akima spline coefficients table.
+
+Input parameters:
+    X           -   spline nodes, array[0..N-1]
+    Y           -   function values, array[0..N-1]
+    N           -   points count, N>=5
+
+Output parameters:
+    C           -   coefficients table.  Used  by  SplineInterpolation and
+                    other subroutines from this file.
+
+  -- ALGLIB PROJECT --
+     Copyright 24.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void buildakimaspline(ap::real_1d_array x,
+     ap::real_1d_array y,
+     int n,
+     ap::real_1d_array& c);
+
+
+/*************************************************************************
+This subroutine calculates the value of the spline at the given point X.
+
+Input parameters:
+    C           -   coefficients table. Built by BuildLinearSpline,
+                    BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+    X           -   point
+
+Result:
+    S(x)
+
+  -- ALGLIB PROJECT --
+     Copyright 23.06.2007 by Bochkanov Sergey
+*************************************************************************/
+double splineinterpolation(const ap::real_1d_array& c, double x);
+
+
+/*************************************************************************
+This subroutine differentiates the spline.
+
+Input parameters:
+    C   -   coefficients table. Built by BuildLinearSpline,
+            BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+    X   -   point
+
+Result:
+    S   -   S(x)
+    DS  -   S'(x)
+    D2S -   S''(x)
+
+  -- ALGLIB PROJECT --
+     Copyright 24.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void splinedifferentiation(const ap::real_1d_array& c,
+     double x,
+     double& s,
+     double& ds,
+     double& d2s);
+
+
+/*************************************************************************
+This subroutine makes the copy of the spline.
+
+Input parameters:
+    C   -   coefficients table. Built by BuildLinearSpline,
+            BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+
+Result:
+    CC  -   spline copy
+
+  -- ALGLIB PROJECT --
+     Copyright 29.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void splinecopy(const ap::real_1d_array& c, ap::real_1d_array& cc);
+
+
+/*************************************************************************
+This subroutine unpacks the spline into the coefficients table.
+
+Input parameters:
+    C   -   coefficients table. Built by BuildLinearSpline,
+            BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+    X   -   point
+
+Result:
+    Tbl -   coefficients table, unpacked format, array[0..N-2, 0..5].
+            For I = 0...N-2:
+                Tbl[I,0] = X[i]
+                Tbl[I,1] = X[i+1]
+                Tbl[I,2] = C0
+                Tbl[I,3] = C1
+                Tbl[I,4] = C2
+                Tbl[I,5] = C3
+            On [x[i], x[i+1]] spline is equals to:
+                S(x) = C0 + C1*t + C2*t^2 + C3*t^3
+                t = x-x[i]
+
+  -- ALGLIB PROJECT --
+     Copyright 29.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void splineunpack(const ap::real_1d_array& c, int& n, ap::real_2d_array& tbl);
+
+
+/*************************************************************************
+This subroutine performs linear transformation of the spline argument.
+
+Input parameters:
+    C   -   coefficients table. Built by BuildLinearSpline,
+            BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+    A, B-   transformation coefficients: x = A*t + B
+Result:
+    C   -   transformed spline
+
+  -- ALGLIB PROJECT --
+     Copyright 30.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void splinelintransx(ap::real_1d_array& c, double a, double b);
+
+
+/*************************************************************************
+This subroutine performs linear transformation of the spline.
+
+Input parameters:
+    C   -   coefficients table. Built by BuildLinearSpline,
+            BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+    A, B-   transformation coefficients: S2(x) = A*S(x) + B
+Result:
+    C   -   transformed spline
+
+  -- ALGLIB PROJECT --
+     Copyright 30.06.2007 by Bochkanov Sergey
+*************************************************************************/
+void splinelintransy(ap::real_1d_array& c, double a, double b);
+
+
+/*************************************************************************
+This subroutine integrates the spline.
+
+Input parameters:
+    C   -   coefficients table. Built by BuildLinearSpline,
+            BuildHermiteSpline, BuildCubicSpline, BuildAkimaSpline.
+    X   -   right bound of the integration interval [a, x]
+Result:
+    integral(S(t)dt,a,x)
+
+  -- ALGLIB PROJECT --
+     Copyright 23.06.2007 by Bochkanov Sergey
+*************************************************************************/
+double splineintegration(const ap::real_1d_array& c, double x);
+
+
+/*************************************************************************
+Obsolete subroutine, left for backward compatibility.
+*************************************************************************/
+void spline3buildtable(int n,
+     const int& diffn,
+     ap::real_1d_array x,
+     ap::real_1d_array y,
+     const double& boundl,
+     const double& boundr,
+     ap::real_2d_array& ctbl);
+
+
+/*************************************************************************
+Obsolete subroutine, left for backward compatibility.
+*************************************************************************/
+double spline3interpolate(int n, const ap::real_2d_array& c, const double& x);
+
+
+#endif

data/ext/alglib/srcond.cpp

@@ -0,0 +1,595 @@
+/*************************************************************************
+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 "srcond.h"
+
+/*************************************************************************
+Condition number estimate of a symmetric matrix
+
+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).
+
+It should be noted that 1-norm and inf-norm condition numbers of symmetric
+matrices are equal, so the algorithm doesn't take into account the
+differences between these types of norms.
+
+Input parameters:
+    A       -   symmetric definite matrix which is given by its upper or
+                lower triangle depending on IsUpper.
+                Array with elements [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    IsUpper -   storage format.
+
+Result:
+    1/LowerBound(cond(A))
+*************************************************************************/
+double smatrixrcond(const ap::real_2d_array& a, int n, bool isupper)
+{
+    double result;
+    int i;
+    int j;
+    ap::real_2d_array a1;
+
+    a1.setbounds(1, n, 1, n);
+    for(i = 1; i <= n; i++)
+    {
+        if( isupper )
+        {
+            for(j = i; j <= n; j++)
+            {
+                a1(i,j) = a(i-1,j-1);
+            }
+        }
+        else
+        {
+            for(j = 1; j <= i; j++)
+            {
+                a1(i,j) = a(i-1,j-1);
+            }
+        }
+    }
+    result = rcondsymmetric(a1, n, isupper);
+    return result;
+}
+
+
+/*************************************************************************
+Condition number estimate of a matrix given by LDLT-decomposition
+
+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).
+
+It should be noted that 1-norm and inf-norm condition numbers of symmetric
+matrices are equal, so the algorithm doesn't take into account the
+differences between these types of norms.
+
+Input parameters:
+    L       -   LDLT-decomposition of matrix A given by the upper or lower
+                triangle depending on IsUpper.
+                Output of SMatrixLDLT subroutine.
+    Pivots  -   table of permutations which were made during LDLT-decomposition,
+                Output of SMatrixLDLT subroutine.
+    N       -   size of matrix A.
+    IsUpper -   storage format.
+
+Result:
+    1/LowerBound(cond(A))
+*************************************************************************/
+double smatrixldltrcond(const ap::real_2d_array& l,
+     const ap::integer_1d_array& pivots,
+     int n,
+     bool isupper)
+{
+    double result;
+    int i;
+    int j;
+    ap::real_2d_array l1;
+    ap::integer_1d_array p1;
+
+    l1.setbounds(1, n, 1, n);
+    for(i = 1; i <= n; i++)
+    {
+        if( isupper )
+        {
+            for(j = i; j <= n; j++)
+            {
+                l1(i,j) = l(i-1,j-1);
+            }
+        }
+        else
+        {
+            for(j = 1; j <= i; j++)
+            {
+                l1(i,j) = l(i-1,j-1);
+            }
+        }
+    }
+    p1.setbounds(1, n);
+    for(i = 1; i <= n; i++)
+    {
+        if( pivots(i-1)>=0 )
+        {
+            p1(i) = pivots(i-1)+1;
+        }
+        else
+        {
+            p1(i) = -(pivots(i-1)+n+1);
+        }
+    }
+    result = rcondldlt(l1, p1, n, isupper);
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+double rcondsymmetric(ap::real_2d_array a, int n, bool isupper)
+{
+    double result;
+    int i;
+    int j;
+    int im;
+    int jm;
+    double v;
+    double nrm;
+    ap::integer_1d_array pivots;
+
+    nrm = 0;
+    for(j = 1; j <= n; j++)
+    {
+        v = 0;
+        for(i = 1; i <= n; i++)
+        {
+            im = i;
+            jm = j;
+            if( isupper&&j<i )
+            {
+                im = j;
+                jm = i;
+            }
+            if( !isupper&&j>i )
+            {
+                im = j;
+                jm = i;
+            }
+            v = v+fabs(a(im,jm));
+        }
+        nrm = ap::maxreal(nrm, v);
+    }
+    ldltdecomposition(a, n, isupper, pivots);
+    internalldltrcond(a, pivots, n, isupper, true, nrm, v);
+    result = v;
+    return result;
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+double rcondldlt(const ap::real_2d_array& l,
+     const ap::integer_1d_array& pivots,
+     int n,
+     bool isupper)
+{
+    double result;
+    double v;
+
+    internalldltrcond(l, pivots, n, isupper, false, double(0), v);
+    result = v;
+    return result;
+}
+
+
+void internalldltrcond(const ap::real_2d_array& l,
+     const ap::integer_1d_array& pivots,
+     int n,
+     bool isupper,
+     bool isnormprovided,
+     double anorm,
+     double& rcond)
+{
+    int i;
+    int ix;
+    int kase;
+    int k;
+    int km1;
+    int km2;
+    int kp1;
+    int kp2;
+    double ainvnm;
+    ap::real_1d_array work0;
+    ap::real_1d_array work1;
+    ap::real_1d_array work2;
+    ap::integer_1d_array iwork;
+    double v;
+
+    ap::ap_error::make_assertion(n>=0, "");
+    
+    //
+    // Check that the diagonal matrix D is nonsingular.
+    //
+    rcond = 0;
+    if( isupper )
+    {
+        for(i = n; i >= 1; i--)
+        {
+            if( pivots(i)>0&&l(i,i)==0 )
+            {
+                return;
+            }
+        }
+    }
+    else
+    {
+        for(i = 1; i <= n; i++)
+        {
+            if( pivots(i)>0&&l(i,i)==0 )
+            {
+                return;
+            }
+        }
+    }
+    
+    //
+    // Estimate the norm of A.
+    //
+    if( !isnormprovided )
+    {
+        kase = 0;
+        anorm = 0;
+        while(true)
+        {
+            iterativeestimate1norm(n, work1, work0, iwork, anorm, kase);
+            if( kase==0 )
+            {
+                break;
+            }
+            if( isupper )
+            {
+                
+                //
+                // Multiply by U'
+                //
+                k = n;
+                while(k>=1)
+                {
+                    if( pivots(k)>0 )
+                    {
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k);
+                        work0(k) = work0(pivots(k));
+                        work0(pivots(k)) = v;
+                        
+                        //
+                        // U(k)
+                        //
+                        km1 = k-1;
+                        v = ap::vdotproduct(work0.getvector(1, km1), l.getcolumn(k, 1, km1));
+                        work0(k) = work0(k)+v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k-1;
+                    }
+                    else
+                    {
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k-1);
+                        work0(k-1) = work0(-pivots(k-1));
+                        work0(-pivots(k-1)) = v;
+                        
+                        //
+                        // U(k)
+                        //
+                        km1 = k-1;
+                        km2 = k-2;
+                        v = ap::vdotproduct(work0.getvector(1, km2), l.getcolumn(km1, 1, km2));
+                        work0(km1) = work0(km1)+v;
+                        v = ap::vdotproduct(work0.getvector(1, km2), l.getcolumn(k, 1, km2));
+                        work0(k) = work0(k)+v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k-2;
+                    }
+                }
+                
+                //
+                // Multiply by D
+                //
+                k = n;
+                while(k>=1)
+                {
+                    if( pivots(k)>0 )
+                    {
+                        work0(k) = work0(k)*l(k,k);
+                        k = k-1;
+                    }
+                    else
+                    {
+                        v = work0(k-1);
+                        work0(k-1) = l(k-1,k-1)*work0(k-1)+l(k-1,k)*work0(k);
+                        work0(k) = l(k-1,k)*v+l(k,k)*work0(k);
+                        k = k-2;
+                    }
+                }
+                
+                //
+                // Multiply by U
+                //
+                k = 1;
+                while(k<=n)
+                {
+                    if( pivots(k)>0 )
+                    {
+                        
+                        //
+                        // U(k)
+                        //
+                        km1 = k-1;
+                        v = work0(k);
+                        ap::vadd(work0.getvector(1, km1), l.getcolumn(k, 1, km1), v);
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k);
+                        work0(k) = work0(pivots(k));
+                        work0(pivots(k)) = v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k+1;
+                    }
+                    else
+                    {
+                        
+                        //
+                        // U(k)
+                        //
+                        km1 = k-1;
+                        kp1 = k+1;
+                        v = work0(k);
+                        ap::vadd(work0.getvector(1, km1), l.getcolumn(k, 1, km1), v);
+                        v = work0(kp1);
+                        ap::vadd(work0.getvector(1, km1), l.getcolumn(kp1, 1, km1), v);
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k);
+                        work0(k) = work0(-pivots(k));
+                        work0(-pivots(k)) = v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k+2;
+                    }
+                }
+            }
+            else
+            {
+                
+                //
+                // Multiply by L'
+                //
+                k = 1;
+                while(k<=n)
+                {
+                    if( pivots(k)>0 )
+                    {
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k);
+                        work0(k) = work0(pivots(k));
+                        work0(pivots(k)) = v;
+                        
+                        //
+                        // L(k)
+                        //
+                        kp1 = k+1;
+                        v = ap::vdotproduct(work0.getvector(kp1, n), l.getcolumn(k, kp1, n));
+                        work0(k) = work0(k)+v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k+1;
+                    }
+                    else
+                    {
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k+1);
+                        work0(k+1) = work0(-pivots(k+1));
+                        work0(-pivots(k+1)) = v;
+                        
+                        //
+                        // L(k)
+                        //
+                        kp1 = k+1;
+                        kp2 = k+2;
+                        v = ap::vdotproduct(work0.getvector(kp2, n), l.getcolumn(k, kp2, n));
+                        work0(k) = work0(k)+v;
+                        v = ap::vdotproduct(work0.getvector(kp2, n), l.getcolumn(kp1, kp2, n));
+                        work0(kp1) = work0(kp1)+v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k+2;
+                    }
+                }
+                
+                //
+                // Multiply by D
+                //
+                k = n;
+                while(k>=1)
+                {
+                    if( pivots(k)>0 )
+                    {
+                        work0(k) = work0(k)*l(k,k);
+                        k = k-1;
+                    }
+                    else
+                    {
+                        v = work0(k-1);
+                        work0(k-1) = l(k-1,k-1)*work0(k-1)+l(k,k-1)*work0(k);
+                        work0(k) = l(k,k-1)*v+l(k,k)*work0(k);
+                        k = k-2;
+                    }
+                }
+                
+                //
+                // Multiply by L
+                //
+                k = n;
+                while(k>=1)
+                {
+                    if( pivots(k)>0 )
+                    {
+                        
+                        //
+                        // L(k)
+                        //
+                        kp1 = k+1;
+                        v = work0(k);
+                        ap::vadd(work0.getvector(kp1, n), l.getcolumn(k, kp1, n), v);
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k);
+                        work0(k) = work0(pivots(k));
+                        work0(pivots(k)) = v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k-1;
+                    }
+                    else
+                    {
+                        
+                        //
+                        // L(k)
+                        //
+                        kp1 = k+1;
+                        km1 = k-1;
+                        v = work0(k);
+                        ap::vadd(work0.getvector(kp1, n), l.getcolumn(k, kp1, n), v);
+                        v = work0(km1);
+                        ap::vadd(work0.getvector(kp1, n), l.getcolumn(km1, kp1, n), v);
+                        
+                        //
+                        // P(k)
+                        //
+                        v = work0(k);
+                        work0(k) = work0(-pivots(k));
+                        work0(-pivots(k)) = v;
+                        
+                        //
+                        // Next k
+                        //
+                        k = k-2;
+                    }
+                }
+            }
+        }
+    }
+    
+    //
+    // Quick return if possible
+    //
+    rcond = 0;
+    if( n==0 )
+    {
+        rcond = 1;
+        return;
+    }
+    if( anorm==0 )
+    {
+        return;
+    }
+    
+    //
+    // Estimate the 1-norm of inv(A).
+    //
+    kase = 0;
+    while(true)
+    {
+        iterativeestimate1norm(n, work1, work0, iwork, ainvnm, kase);
+        if( kase==0 )
+        {
+            break;
+        }
+        solvesystemldlt(l, pivots, work0, n, isupper, work2);
+        ap::vmove(&work0(1), &work2(1), ap::vlen(1,n));
+    }
+    
+    //
+    // Compute the estimate of the reciprocal condition number.
+    //
+    if( ainvnm!=0 )
+    {
+        v = 1/ainvnm;
+        rcond = v/anorm;
+    }
+}
+
+
+