alglib 0.1.1

data/ext/alglib/inverseupdate.cpp

@@ -0,0 +1,480 @@
+/*************************************************************************
+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 "inverseupdate.h"
+
+/*************************************************************************
+Inverse matrix update by the Sherman-Morrison formula
+
+The algorithm updates matrix A^-1 when adding a number to an element
+of matrix A.
+
+Input parameters:
+    InvA    -   inverse of matrix A.
+                Array whose indexes range within [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    UpdRow  -   row where the element to be updated is stored.
+    UpdColumn - column where the element to be updated is stored.
+    UpdVal  -   a number to be added to the element.
+
+
+Output parameters:
+    InvA    -   inverse of modified matrix A.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+void rmatrixinvupdatesimple(ap::real_2d_array& inva,
+     int n,
+     int updrow,
+     int updcolumn,
+     double updval)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    ap::ap_error::make_assertion(updrow>=0&&updrow<n, "RMatrixInvUpdateSimple: incorrect UpdRow!");
+    ap::ap_error::make_assertion(updcolumn>=0&&updcolumn<n, "RMatrixInvUpdateSimple: incorrect UpdColumn!");
+    t1.setbounds(0, n-1);
+    t2.setbounds(0, n-1);
+    
+    //
+    // T1 = InvA * U
+    //
+    ap::vmove(t1.getvector(0, n-1), inva.getcolumn(updrow, 0, n-1));
+    
+    //
+    // T2 = v*InvA
+    //
+    ap::vmove(&t2(0), &inva(updcolumn, 0), ap::vlen(0,n-1));
+    
+    //
+    // Lambda = v * InvA * U
+    //
+    lambda = updval*inva(updcolumn,updrow);
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        vt = updval*t1(i);
+        vt = vt/(1+lambda);
+        ap::vsub(&inva(i, 0), &t2(0), ap::vlen(0,n-1), vt);
+    }
+}
+
+
+/*************************************************************************
+Inverse matrix update by the Sherman-Morrison formula
+
+The algorithm updates matrix A^-1 when adding a vector to a row
+of matrix A.
+
+Input parameters:
+    InvA    -   inverse of matrix A.
+                Array whose indexes range within [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    UpdRow  -   the row of A whose vector V was added.
+                0 <= Row <= N-1
+    V       -   the vector to be added to a row.
+                Array whose index ranges within [0..N-1].
+
+Output parameters:
+    InvA    -   inverse of modified matrix A.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+void rmatrixinvupdaterow(ap::real_2d_array& inva,
+     int n,
+     int updrow,
+     const ap::real_1d_array& v)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(0, n-1);
+    t2.setbounds(0, n-1);
+    
+    //
+    // T1 = InvA * U
+    //
+    ap::vmove(t1.getvector(0, n-1), inva.getcolumn(updrow, 0, n-1));
+    
+    //
+    // T2 = v*InvA
+    // Lambda = v * InvA * U
+    //
+    for(j = 0; j <= n-1; j++)
+    {
+        vt = ap::vdotproduct(v.getvector(0, n-1), inva.getcolumn(j, 0, n-1));
+        t2(j) = vt;
+    }
+    lambda = t2(updrow);
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        vt = t1(i)/(1+lambda);
+        ap::vsub(&inva(i, 0), &t2(0), ap::vlen(0,n-1), vt);
+    }
+}
+
+
+/*************************************************************************
+Inverse matrix update by the Sherman-Morrison formula
+
+The algorithm updates matrix A^-1 when adding a vector to a column
+of matrix A.
+
+Input parameters:
+    InvA        -   inverse of matrix A.
+                    Array whose indexes range within [0..N-1, 0..N-1].
+    N           -   size of matrix A.
+    UpdColumn   -   the column of A whose vector U was added.
+                    0 <= UpdColumn <= N-1
+    U           -   the vector to be added to a column.
+                    Array whose index ranges within [0..N-1].
+
+Output parameters:
+    InvA        -   inverse of modified matrix A.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+void rmatrixinvupdatecolumn(ap::real_2d_array& inva,
+     int n,
+     int updcolumn,
+     const ap::real_1d_array& u)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(0, n-1);
+    t2.setbounds(0, n-1);
+    
+    //
+    // T1 = InvA * U
+    // Lambda = v * InvA * U
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        vt = ap::vdotproduct(&inva(i, 0), &u(0), ap::vlen(0,n-1));
+        t1(i) = vt;
+    }
+    lambda = t1(updcolumn);
+    
+    //
+    // T2 = v*InvA
+    //
+    ap::vmove(&t2(0), &inva(updcolumn, 0), ap::vlen(0,n-1));
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        vt = t1(i)/(1+lambda);
+        ap::vsub(&inva(i, 0), &t2(0), ap::vlen(0,n-1), vt);
+    }
+}
+
+
+/*************************************************************************
+Inverse matrix update by the Sherman-Morrison formula
+
+The algorithm computes the inverse of matrix A+u*v� by using the given matrix
+A^-1 and the vectors u and v.
+
+Input parameters:
+    InvA    -   inverse of matrix A.
+                Array whose indexes range within [0..N-1, 0..N-1].
+    N       -   size of matrix A.
+    U       -   the vector modifying the matrix.
+                Array whose index ranges within [0..N-1].
+    V       -   the vector modifying the matrix.
+                Array whose index ranges within [0..N-1].
+
+Output parameters:
+    InvA - inverse of matrix A + u*v'.
+
+  -- ALGLIB --
+     Copyright 2005 by Bochkanov Sergey
+*************************************************************************/
+void rmatrixinvupdateuv(ap::real_2d_array& inva,
+     int n,
+     const ap::real_1d_array& u,
+     const ap::real_1d_array& v)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(0, n-1);
+    t2.setbounds(0, n-1);
+    
+    //
+    // T1 = InvA * U
+    // Lambda = v * T1
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        vt = ap::vdotproduct(&inva(i, 0), &u(0), ap::vlen(0,n-1));
+        t1(i) = vt;
+    }
+    lambda = ap::vdotproduct(&v(0), &t1(0), ap::vlen(0,n-1));
+    
+    //
+    // T2 = v*InvA
+    //
+    for(j = 0; j <= n-1; j++)
+    {
+        vt = ap::vdotproduct(v.getvector(0, n-1), inva.getcolumn(j, 0, n-1));
+        t2(j) = vt;
+    }
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 0; i <= n-1; i++)
+    {
+        vt = t1(i)/(1+lambda);
+        ap::vsub(&inva(i, 0), &t2(0), ap::vlen(0,n-1), vt);
+    }
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+void shermanmorrisonsimpleupdate(ap::real_2d_array& inva,
+     int n,
+     int updrow,
+     int updcolumn,
+     double updval)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(1, n);
+    t2.setbounds(1, n);
+    
+    //
+    // T1 = InvA * U
+    //
+    ap::vmove(t1.getvector(1, n), inva.getcolumn(updrow, 1, n));
+    
+    //
+    // T2 = v*InvA
+    //
+    ap::vmove(&t2(1), &inva(updcolumn, 1), ap::vlen(1,n));
+    
+    //
+    // Lambda = v * InvA * U
+    //
+    lambda = updval*inva(updcolumn,updrow);
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 1; i <= n; i++)
+    {
+        vt = updval*t1(i);
+        vt = vt/(1+lambda);
+        ap::vsub(&inva(i, 1), &t2(1), ap::vlen(1,n), vt);
+    }
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+void shermanmorrisonupdaterow(ap::real_2d_array& inva,
+     int n,
+     int updrow,
+     const ap::real_1d_array& v)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(1, n);
+    t2.setbounds(1, n);
+    
+    //
+    // T1 = InvA * U
+    //
+    ap::vmove(t1.getvector(1, n), inva.getcolumn(updrow, 1, n));
+    
+    //
+    // T2 = v*InvA
+    // Lambda = v * InvA * U
+    //
+    for(j = 1; j <= n; j++)
+    {
+        vt = ap::vdotproduct(v.getvector(1, n), inva.getcolumn(j, 1, n));
+        t2(j) = vt;
+    }
+    lambda = t2(updrow);
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 1; i <= n; i++)
+    {
+        vt = t1(i)/(1+lambda);
+        ap::vsub(&inva(i, 1), &t2(1), ap::vlen(1,n), vt);
+    }
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+void shermanmorrisonupdatecolumn(ap::real_2d_array& inva,
+     int n,
+     int updcolumn,
+     const ap::real_1d_array& u)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(1, n);
+    t2.setbounds(1, n);
+    
+    //
+    // T1 = InvA * U
+    // Lambda = v * InvA * U
+    //
+    for(i = 1; i <= n; i++)
+    {
+        vt = ap::vdotproduct(&inva(i, 1), &u(1), ap::vlen(1,n));
+        t1(i) = vt;
+    }
+    lambda = t1(updcolumn);
+    
+    //
+    // T2 = v*InvA
+    //
+    ap::vmove(&t2(1), &inva(updcolumn, 1), ap::vlen(1,n));
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 1; i <= n; i++)
+    {
+        vt = t1(i)/(1+lambda);
+        ap::vsub(&inva(i, 1), &t2(1), ap::vlen(1,n), vt);
+    }
+}
+
+
+/*************************************************************************
+Obsolete 1-based subroutine
+*************************************************************************/
+void shermanmorrisonupdateuv(ap::real_2d_array& inva,
+     int n,
+     const ap::real_1d_array& u,
+     const ap::real_1d_array& v)
+{
+    ap::real_1d_array t1;
+    ap::real_1d_array t2;
+    int i;
+    int j;
+    double lambda;
+    double vt;
+
+    t1.setbounds(1, n);
+    t2.setbounds(1, n);
+    
+    //
+    // T1 = InvA * U
+    // Lambda = v * T1
+    //
+    for(i = 1; i <= n; i++)
+    {
+        vt = ap::vdotproduct(&inva(i, 1), &u(1), ap::vlen(1,n));
+        t1(i) = vt;
+    }
+    lambda = ap::vdotproduct(&v(1), &t1(1), ap::vlen(1,n));
+    
+    //
+    // T2 = v*InvA
+    //
+    for(j = 1; j <= n; j++)
+    {
+        vt = ap::vdotproduct(v.getvector(1, n), inva.getcolumn(j, 1, n));
+        t2(j) = vt;
+    }
+    
+    //
+    // InvA = InvA - correction
+    //
+    for(i = 1; i <= n; i++)
+    {
+        vt = t1(i)/(1+lambda);
+        ap::vsub(&inva(i, 1), &t2(1), ap::vlen(1,n), vt);
+    }
+}
+
+
+