alpar@9: /* glplpf.c (LP basis factorization, Schur complement version) */ alpar@9: alpar@9: /*********************************************************************** alpar@9: * This code is part of GLPK (GNU Linear Programming Kit). alpar@9: * alpar@9: * Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, alpar@9: * 2009, 2010, 2011 Andrew Makhorin, Department for Applied Informatics, alpar@9: * Moscow Aviation Institute, Moscow, Russia. All rights reserved. alpar@9: * E-mail: . alpar@9: * alpar@9: * GLPK is free software: you can redistribute it and/or modify it alpar@9: * under the terms of the GNU General Public License as published by alpar@9: * the Free Software Foundation, either version 3 of the License, or alpar@9: * (at your option) any later version. alpar@9: * alpar@9: * GLPK is distributed in the hope that it will be useful, but WITHOUT alpar@9: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY alpar@9: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public alpar@9: * License for more details. alpar@9: * alpar@9: * You should have received a copy of the GNU General Public License alpar@9: * along with GLPK. If not, see . alpar@9: ***********************************************************************/ alpar@9: alpar@9: #include "glplpf.h" alpar@9: #include "glpenv.h" alpar@9: #define xfault xerror alpar@9: alpar@9: #define _GLPLPF_DEBUG 0 alpar@9: alpar@9: /* CAUTION: DO NOT CHANGE THE LIMIT BELOW */ alpar@9: alpar@9: #define M_MAX 100000000 /* = 100*10^6 */ alpar@9: /* maximal order of the basis matrix */ alpar@9: alpar@9: /*********************************************************************** alpar@9: * NAME alpar@9: * alpar@9: * lpf_create_it - create LP basis factorization alpar@9: * alpar@9: * SYNOPSIS alpar@9: * alpar@9: * #include "glplpf.h" alpar@9: * LPF *lpf_create_it(void); alpar@9: * alpar@9: * DESCRIPTION alpar@9: * alpar@9: * The routine lpf_create_it creates a program object, which represents alpar@9: * a factorization of LP basis. alpar@9: * alpar@9: * RETURNS alpar@9: * alpar@9: * The routine lpf_create_it returns a pointer to the object created. */ alpar@9: alpar@9: LPF *lpf_create_it(void) alpar@9: { LPF *lpf; alpar@9: #if _GLPLPF_DEBUG alpar@9: xprintf("lpf_create_it: warning: debug mode enabled\n"); alpar@9: #endif alpar@9: lpf = xmalloc(sizeof(LPF)); alpar@9: lpf->valid = 0; alpar@9: lpf->m0_max = lpf->m0 = 0; alpar@9: lpf->luf = luf_create_it(); alpar@9: lpf->m = 0; alpar@9: lpf->B = NULL; alpar@9: lpf->n_max = 50; alpar@9: lpf->n = 0; alpar@9: lpf->R_ptr = lpf->R_len = NULL; alpar@9: lpf->S_ptr = lpf->S_len = NULL; alpar@9: lpf->scf = NULL; alpar@9: lpf->P_row = lpf->P_col = NULL; alpar@9: lpf->Q_row = lpf->Q_col = NULL; alpar@9: lpf->v_size = 1000; alpar@9: lpf->v_ptr = 0; alpar@9: lpf->v_ind = NULL; alpar@9: lpf->v_val = NULL; alpar@9: lpf->work1 = lpf->work2 = NULL; alpar@9: return lpf; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * NAME alpar@9: * alpar@9: * lpf_factorize - compute LP basis factorization alpar@9: * alpar@9: * SYNOPSIS alpar@9: * alpar@9: * #include "glplpf.h" alpar@9: * int lpf_factorize(LPF *lpf, int m, const int bh[], int (*col) alpar@9: * (void *info, int j, int ind[], double val[]), void *info); alpar@9: * alpar@9: * DESCRIPTION alpar@9: * alpar@9: * The routine lpf_factorize computes the factorization of the basis alpar@9: * matrix B specified by the routine col. alpar@9: * alpar@9: * The parameter lpf specified the basis factorization data structure alpar@9: * created with the routine lpf_create_it. alpar@9: * alpar@9: * The parameter m specifies the order of B, m > 0. alpar@9: * alpar@9: * The array bh specifies the basis header: bh[j], 1 <= j <= m, is the alpar@9: * number of j-th column of B in some original matrix. The array bh is alpar@9: * optional and can be specified as NULL. alpar@9: * alpar@9: * The formal routine col specifies the matrix B to be factorized. To alpar@9: * obtain j-th column of A the routine lpf_factorize calls the routine alpar@9: * col with the parameter j (1 <= j <= n). In response the routine col alpar@9: * should store row indices and numerical values of non-zero elements alpar@9: * of j-th column of B to locations ind[1,...,len] and val[1,...,len], alpar@9: * respectively, where len is the number of non-zeros in j-th column alpar@9: * returned on exit. Neither zero nor duplicate elements are allowed. alpar@9: * alpar@9: * The parameter info is a transit pointer passed to the routine col. alpar@9: * alpar@9: * RETURNS alpar@9: * alpar@9: * 0 The factorization has been successfully computed. alpar@9: * alpar@9: * LPF_ESING alpar@9: * The specified matrix is singular within the working precision. alpar@9: * alpar@9: * LPF_ECOND alpar@9: * The specified matrix is ill-conditioned. alpar@9: * alpar@9: * For more details see comments to the routine luf_factorize. */ alpar@9: alpar@9: int lpf_factorize(LPF *lpf, int m, const int bh[], int (*col) alpar@9: (void *info, int j, int ind[], double val[]), void *info) alpar@9: { int k, ret; alpar@9: #if _GLPLPF_DEBUG alpar@9: int i, j, len, *ind; alpar@9: double *B, *val; alpar@9: #endif alpar@9: xassert(bh == bh); alpar@9: if (m < 1) alpar@9: xfault("lpf_factorize: m = %d; invalid parameter\n", m); alpar@9: if (m > M_MAX) alpar@9: xfault("lpf_factorize: m = %d; matrix too big\n", m); alpar@9: lpf->m0 = lpf->m = m; alpar@9: /* invalidate the factorization */ alpar@9: lpf->valid = 0; alpar@9: /* allocate/reallocate arrays, if necessary */ alpar@9: if (lpf->R_ptr == NULL) alpar@9: lpf->R_ptr = xcalloc(1+lpf->n_max, sizeof(int)); alpar@9: if (lpf->R_len == NULL) alpar@9: lpf->R_len = xcalloc(1+lpf->n_max, sizeof(int)); alpar@9: if (lpf->S_ptr == NULL) alpar@9: lpf->S_ptr = xcalloc(1+lpf->n_max, sizeof(int)); alpar@9: if (lpf->S_len == NULL) alpar@9: lpf->S_len = xcalloc(1+lpf->n_max, sizeof(int)); alpar@9: if (lpf->scf == NULL) alpar@9: lpf->scf = scf_create_it(lpf->n_max); alpar@9: if (lpf->v_ind == NULL) alpar@9: lpf->v_ind = xcalloc(1+lpf->v_size, sizeof(int)); alpar@9: if (lpf->v_val == NULL) alpar@9: lpf->v_val = xcalloc(1+lpf->v_size, sizeof(double)); alpar@9: if (lpf->m0_max < m) alpar@9: { if (lpf->P_row != NULL) xfree(lpf->P_row); alpar@9: if (lpf->P_col != NULL) xfree(lpf->P_col); alpar@9: if (lpf->Q_row != NULL) xfree(lpf->Q_row); alpar@9: if (lpf->Q_col != NULL) xfree(lpf->Q_col); alpar@9: if (lpf->work1 != NULL) xfree(lpf->work1); alpar@9: if (lpf->work2 != NULL) xfree(lpf->work2); alpar@9: lpf->m0_max = m + 100; alpar@9: lpf->P_row = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int)); alpar@9: lpf->P_col = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int)); alpar@9: lpf->Q_row = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int)); alpar@9: lpf->Q_col = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(int)); alpar@9: lpf->work1 = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(double)); alpar@9: lpf->work2 = xcalloc(1+lpf->m0_max+lpf->n_max, sizeof(double)); alpar@9: } alpar@9: /* try to factorize the basis matrix */ alpar@9: switch (luf_factorize(lpf->luf, m, col, info)) alpar@9: { case 0: alpar@9: break; alpar@9: case LUF_ESING: alpar@9: ret = LPF_ESING; alpar@9: goto done; alpar@9: case LUF_ECOND: alpar@9: ret = LPF_ECOND; alpar@9: goto done; alpar@9: default: alpar@9: xassert(lpf != lpf); alpar@9: } alpar@9: /* the basis matrix has been successfully factorized */ alpar@9: lpf->valid = 1; alpar@9: #if _GLPLPF_DEBUG alpar@9: /* store the basis matrix for debugging */ alpar@9: if (lpf->B != NULL) xfree(lpf->B); alpar@9: xassert(m <= 32767); alpar@9: lpf->B = B = xcalloc(1+m*m, sizeof(double)); alpar@9: ind = xcalloc(1+m, sizeof(int)); alpar@9: val = xcalloc(1+m, sizeof(double)); alpar@9: for (k = 1; k <= m * m; k++) alpar@9: B[k] = 0.0; alpar@9: for (j = 1; j <= m; j++) alpar@9: { len = col(info, j, ind, val); alpar@9: xassert(0 <= len && len <= m); alpar@9: for (k = 1; k <= len; k++) alpar@9: { i = ind[k]; alpar@9: xassert(1 <= i && i <= m); alpar@9: xassert(B[(i - 1) * m + j] == 0.0); alpar@9: xassert(val[k] != 0.0); alpar@9: B[(i - 1) * m + j] = val[k]; alpar@9: } alpar@9: } alpar@9: xfree(ind); alpar@9: xfree(val); alpar@9: #endif alpar@9: /* B = B0, so there are no additional rows/columns */ alpar@9: lpf->n = 0; alpar@9: /* reset the Schur complement factorization */ alpar@9: scf_reset_it(lpf->scf); alpar@9: /* P := Q := I */ alpar@9: for (k = 1; k <= m; k++) alpar@9: { lpf->P_row[k] = lpf->P_col[k] = k; alpar@9: lpf->Q_row[k] = lpf->Q_col[k] = k; alpar@9: } alpar@9: /* make all SVA locations free */ alpar@9: lpf->v_ptr = 1; alpar@9: ret = 0; alpar@9: done: /* return to the calling program */ alpar@9: return ret; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * The routine r_prod computes the product y := y + alpha * R * x, alpar@9: * where x is a n-vector, alpha is a scalar, y is a m0-vector. alpar@9: * alpar@9: * Since matrix R is available by columns, the product is computed as alpar@9: * a linear combination: alpar@9: * alpar@9: * y := y + alpha * (R[1] * x[1] + ... + R[n] * x[n]), alpar@9: * alpar@9: * where R[j] is j-th column of R. */ alpar@9: alpar@9: static void r_prod(LPF *lpf, double y[], double a, const double x[]) alpar@9: { int n = lpf->n; alpar@9: int *R_ptr = lpf->R_ptr; alpar@9: int *R_len = lpf->R_len; alpar@9: int *v_ind = lpf->v_ind; alpar@9: double *v_val = lpf->v_val; alpar@9: int j, beg, end, ptr; alpar@9: double t; alpar@9: for (j = 1; j <= n; j++) alpar@9: { if (x[j] == 0.0) continue; alpar@9: /* y := y + alpha * R[j] * x[j] */ alpar@9: t = a * x[j]; alpar@9: beg = R_ptr[j]; alpar@9: end = beg + R_len[j]; alpar@9: for (ptr = beg; ptr < end; ptr++) alpar@9: y[v_ind[ptr]] += t * v_val[ptr]; alpar@9: } alpar@9: return; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * The routine rt_prod computes the product y := y + alpha * R' * x, alpar@9: * where R' is a matrix transposed to R, x is a m0-vector, alpha is a alpar@9: * scalar, y is a n-vector. alpar@9: * alpar@9: * Since matrix R is available by columns, the product components are alpar@9: * computed as inner products: alpar@9: * alpar@9: * y[j] := y[j] + alpha * (j-th column of R) * x alpar@9: * alpar@9: * for j = 1, 2, ..., n. */ alpar@9: alpar@9: static void rt_prod(LPF *lpf, double y[], double a, const double x[]) alpar@9: { int n = lpf->n; alpar@9: int *R_ptr = lpf->R_ptr; alpar@9: int *R_len = lpf->R_len; alpar@9: int *v_ind = lpf->v_ind; alpar@9: double *v_val = lpf->v_val; alpar@9: int j, beg, end, ptr; alpar@9: double t; alpar@9: for (j = 1; j <= n; j++) alpar@9: { /* t := (j-th column of R) * x */ alpar@9: t = 0.0; alpar@9: beg = R_ptr[j]; alpar@9: end = beg + R_len[j]; alpar@9: for (ptr = beg; ptr < end; ptr++) alpar@9: t += v_val[ptr] * x[v_ind[ptr]]; alpar@9: /* y[j] := y[j] + alpha * t */ alpar@9: y[j] += a * t; alpar@9: } alpar@9: return; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * The routine s_prod computes the product y := y + alpha * S * x, alpar@9: * where x is a m0-vector, alpha is a scalar, y is a n-vector. alpar@9: * alpar@9: * Since matrix S is available by rows, the product components are alpar@9: * computed as inner products: alpar@9: * alpar@9: * y[i] = y[i] + alpha * (i-th row of S) * x alpar@9: * alpar@9: * for i = 1, 2, ..., n. */ alpar@9: alpar@9: static void s_prod(LPF *lpf, double y[], double a, const double x[]) alpar@9: { int n = lpf->n; alpar@9: int *S_ptr = lpf->S_ptr; alpar@9: int *S_len = lpf->S_len; alpar@9: int *v_ind = lpf->v_ind; alpar@9: double *v_val = lpf->v_val; alpar@9: int i, beg, end, ptr; alpar@9: double t; alpar@9: for (i = 1; i <= n; i++) alpar@9: { /* t := (i-th row of S) * x */ alpar@9: t = 0.0; alpar@9: beg = S_ptr[i]; alpar@9: end = beg + S_len[i]; alpar@9: for (ptr = beg; ptr < end; ptr++) alpar@9: t += v_val[ptr] * x[v_ind[ptr]]; alpar@9: /* y[i] := y[i] + alpha * t */ alpar@9: y[i] += a * t; alpar@9: } alpar@9: return; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * The routine st_prod computes the product y := y + alpha * S' * x, alpar@9: * where S' is a matrix transposed to S, x is a n-vector, alpha is a alpar@9: * scalar, y is m0-vector. alpar@9: * alpar@9: * Since matrix R is available by rows, the product is computed as a alpar@9: * linear combination: alpar@9: * alpar@9: * y := y + alpha * (S'[1] * x[1] + ... + S'[n] * x[n]), alpar@9: * alpar@9: * where S'[i] is i-th row of S. */ alpar@9: alpar@9: static void st_prod(LPF *lpf, double y[], double a, const double x[]) alpar@9: { int n = lpf->n; alpar@9: int *S_ptr = lpf->S_ptr; alpar@9: int *S_len = lpf->S_len; alpar@9: int *v_ind = lpf->v_ind; alpar@9: double *v_val = lpf->v_val; alpar@9: int i, beg, end, ptr; alpar@9: double t; alpar@9: for (i = 1; i <= n; i++) alpar@9: { if (x[i] == 0.0) continue; alpar@9: /* y := y + alpha * S'[i] * x[i] */ alpar@9: t = a * x[i]; alpar@9: beg = S_ptr[i]; alpar@9: end = beg + S_len[i]; alpar@9: for (ptr = beg; ptr < end; ptr++) alpar@9: y[v_ind[ptr]] += t * v_val[ptr]; alpar@9: } alpar@9: return; alpar@9: } alpar@9: alpar@9: #if _GLPLPF_DEBUG alpar@9: /*********************************************************************** alpar@9: * The routine check_error computes the maximal relative error between alpar@9: * left- and right-hand sides for the system B * x = b (if tr is zero) alpar@9: * or B' * x = b (if tr is non-zero), where B' is a matrix transposed alpar@9: * to B. (This routine is intended for debugging only.) */ alpar@9: alpar@9: static void check_error(LPF *lpf, int tr, const double x[], alpar@9: const double b[]) alpar@9: { int m = lpf->m; alpar@9: double *B = lpf->B; alpar@9: int i, j; alpar@9: double d, dmax = 0.0, s, t, tmax; alpar@9: for (i = 1; i <= m; i++) alpar@9: { s = 0.0; alpar@9: tmax = 1.0; alpar@9: for (j = 1; j <= m; j++) alpar@9: { if (!tr) alpar@9: t = B[m * (i - 1) + j] * x[j]; alpar@9: else alpar@9: t = B[m * (j - 1) + i] * x[j]; alpar@9: if (tmax < fabs(t)) tmax = fabs(t); alpar@9: s += t; alpar@9: } alpar@9: d = fabs(s - b[i]) / tmax; alpar@9: if (dmax < d) dmax = d; alpar@9: } alpar@9: if (dmax > 1e-8) alpar@9: xprintf("%s: dmax = %g; relative error too large\n", alpar@9: !tr ? "lpf_ftran" : "lpf_btran", dmax); alpar@9: return; alpar@9: } alpar@9: #endif alpar@9: alpar@9: /*********************************************************************** alpar@9: * NAME alpar@9: * alpar@9: * lpf_ftran - perform forward transformation (solve system B*x = b) alpar@9: * alpar@9: * SYNOPSIS alpar@9: * alpar@9: * #include "glplpf.h" alpar@9: * void lpf_ftran(LPF *lpf, double x[]); alpar@9: * alpar@9: * DESCRIPTION alpar@9: * alpar@9: * The routine lpf_ftran performs forward transformation, i.e. solves alpar@9: * the system B*x = b, where B is the basis matrix, x is the vector of alpar@9: * unknowns to be computed, b is the vector of right-hand sides. alpar@9: * alpar@9: * On entry elements of the vector b should be stored in dense format alpar@9: * in locations x[1], ..., x[m], where m is the number of rows. On exit alpar@9: * the routine stores elements of the vector x in the same locations. alpar@9: * alpar@9: * BACKGROUND alpar@9: * alpar@9: * Solution of the system B * x = b can be obtained by solving the alpar@9: * following augmented system: alpar@9: * alpar@9: * ( B F^) ( x ) ( b ) alpar@9: * ( ) ( ) = ( ) alpar@9: * ( G^ H^) ( y ) ( 0 ) alpar@9: * alpar@9: * which, using the main equality, can be written as follows: alpar@9: * alpar@9: * ( L0 0 ) ( U0 R ) ( x ) ( b ) alpar@9: * P ( ) ( ) Q ( ) = ( ) alpar@9: * ( S I ) ( 0 C ) ( y ) ( 0 ) alpar@9: * alpar@9: * therefore, alpar@9: * alpar@9: * ( x ) ( U0 R )-1 ( L0 0 )-1 ( b ) alpar@9: * ( ) = Q' ( ) ( ) P' ( ) alpar@9: * ( y ) ( 0 C ) ( S I ) ( 0 ) alpar@9: * alpar@9: * Thus, computing the solution includes the following steps: alpar@9: * alpar@9: * 1. Compute alpar@9: * alpar@9: * ( f ) ( b ) alpar@9: * ( ) = P' ( ) alpar@9: * ( g ) ( 0 ) alpar@9: * alpar@9: * 2. Solve the system alpar@9: * alpar@9: * ( f1 ) ( L0 0 )-1 ( f ) ( L0 0 ) ( f1 ) ( f ) alpar@9: * ( ) = ( ) ( ) => ( ) ( ) = ( ) alpar@9: * ( g1 ) ( S I ) ( g ) ( S I ) ( g1 ) ( g ) alpar@9: * alpar@9: * from which it follows that: alpar@9: * alpar@9: * { L0 * f1 = f f1 = inv(L0) * f alpar@9: * { => alpar@9: * { S * f1 + g1 = g g1 = g - S * f1 alpar@9: * alpar@9: * 3. Solve the system alpar@9: * alpar@9: * ( f2 ) ( U0 R )-1 ( f1 ) ( U0 R ) ( f2 ) ( f1 ) alpar@9: * ( ) = ( ) ( ) => ( ) ( ) = ( ) alpar@9: * ( g2 ) ( 0 C ) ( g1 ) ( 0 C ) ( g2 ) ( g1 ) alpar@9: * alpar@9: * from which it follows that: alpar@9: * alpar@9: * { U0 * f2 + R * g2 = f1 f2 = inv(U0) * (f1 - R * g2) alpar@9: * { => alpar@9: * { C * g2 = g1 g2 = inv(C) * g1 alpar@9: * alpar@9: * 4. Compute alpar@9: * alpar@9: * ( x ) ( f2 ) alpar@9: * ( ) = Q' ( ) alpar@9: * ( y ) ( g2 ) */ alpar@9: alpar@9: void lpf_ftran(LPF *lpf, double x[]) alpar@9: { int m0 = lpf->m0; alpar@9: int m = lpf->m; alpar@9: int n = lpf->n; alpar@9: int *P_col = lpf->P_col; alpar@9: int *Q_col = lpf->Q_col; alpar@9: double *fg = lpf->work1; alpar@9: double *f = fg; alpar@9: double *g = fg + m0; alpar@9: int i, ii; alpar@9: #if _GLPLPF_DEBUG alpar@9: double *b; alpar@9: #endif alpar@9: if (!lpf->valid) alpar@9: xfault("lpf_ftran: the factorization is not valid\n"); alpar@9: xassert(0 <= m && m <= m0 + n); alpar@9: #if _GLPLPF_DEBUG alpar@9: /* save the right-hand side vector */ alpar@9: b = xcalloc(1+m, sizeof(double)); alpar@9: for (i = 1; i <= m; i++) b[i] = x[i]; alpar@9: #endif alpar@9: /* (f g) := inv(P) * (b 0) */ alpar@9: for (i = 1; i <= m0 + n; i++) alpar@9: fg[i] = ((ii = P_col[i]) <= m ? x[ii] : 0.0); alpar@9: /* f1 := inv(L0) * f */ alpar@9: luf_f_solve(lpf->luf, 0, f); alpar@9: /* g1 := g - S * f1 */ alpar@9: s_prod(lpf, g, -1.0, f); alpar@9: /* g2 := inv(C) * g1 */ alpar@9: scf_solve_it(lpf->scf, 0, g); alpar@9: /* f2 := inv(U0) * (f1 - R * g2) */ alpar@9: r_prod(lpf, f, -1.0, g); alpar@9: luf_v_solve(lpf->luf, 0, f); alpar@9: /* (x y) := inv(Q) * (f2 g2) */ alpar@9: for (i = 1; i <= m; i++) alpar@9: x[i] = fg[Q_col[i]]; alpar@9: #if _GLPLPF_DEBUG alpar@9: /* check relative error in solution */ alpar@9: check_error(lpf, 0, x, b); alpar@9: xfree(b); alpar@9: #endif alpar@9: return; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * NAME alpar@9: * alpar@9: * lpf_btran - perform backward transformation (solve system B'*x = b) alpar@9: * alpar@9: * SYNOPSIS alpar@9: * alpar@9: * #include "glplpf.h" alpar@9: * void lpf_btran(LPF *lpf, double x[]); alpar@9: * alpar@9: * DESCRIPTION alpar@9: * alpar@9: * The routine lpf_btran performs backward transformation, i.e. solves alpar@9: * the system B'*x = b, where B' is a matrix transposed to the basis alpar@9: * matrix B, x is the vector of unknowns to be computed, b is the vector alpar@9: * of right-hand sides. alpar@9: * alpar@9: * On entry elements of the vector b should be stored in dense format alpar@9: * in locations x[1], ..., x[m], where m is the number of rows. On exit alpar@9: * the routine stores elements of the vector x in the same locations. alpar@9: * alpar@9: * BACKGROUND alpar@9: * alpar@9: * Solution of the system B' * x = b, where B' is a matrix transposed alpar@9: * to B, can be obtained by solving the following augmented system: alpar@9: * alpar@9: * ( B F^)T ( x ) ( b ) alpar@9: * ( ) ( ) = ( ) alpar@9: * ( G^ H^) ( y ) ( 0 ) alpar@9: * alpar@9: * which, using the main equality, can be written as follows: alpar@9: * alpar@9: * T ( U0 R )T ( L0 0 )T T ( x ) ( b ) alpar@9: * Q ( ) ( ) P ( ) = ( ) alpar@9: * ( 0 C ) ( S I ) ( y ) ( 0 ) alpar@9: * alpar@9: * or, equivalently, as follows: alpar@9: * alpar@9: * ( U'0 0 ) ( L'0 S') ( x ) ( b ) alpar@9: * Q' ( ) ( ) P' ( ) = ( ) alpar@9: * ( R' C') ( 0 I ) ( y ) ( 0 ) alpar@9: * alpar@9: * therefore, alpar@9: * alpar@9: * ( x ) ( L'0 S')-1 ( U'0 0 )-1 ( b ) alpar@9: * ( ) = P ( ) ( ) Q ( ) alpar@9: * ( y ) ( 0 I ) ( R' C') ( 0 ) alpar@9: * alpar@9: * Thus, computing the solution includes the following steps: alpar@9: * alpar@9: * 1. Compute alpar@9: * alpar@9: * ( f ) ( b ) alpar@9: * ( ) = Q ( ) alpar@9: * ( g ) ( 0 ) alpar@9: * alpar@9: * 2. Solve the system alpar@9: * alpar@9: * ( f1 ) ( U'0 0 )-1 ( f ) ( U'0 0 ) ( f1 ) ( f ) alpar@9: * ( ) = ( ) ( ) => ( ) ( ) = ( ) alpar@9: * ( g1 ) ( R' C') ( g ) ( R' C') ( g1 ) ( g ) alpar@9: * alpar@9: * from which it follows that: alpar@9: * alpar@9: * { U'0 * f1 = f f1 = inv(U'0) * f alpar@9: * { => alpar@9: * { R' * f1 + C' * g1 = g g1 = inv(C') * (g - R' * f1) alpar@9: * alpar@9: * 3. Solve the system alpar@9: * alpar@9: * ( f2 ) ( L'0 S')-1 ( f1 ) ( L'0 S') ( f2 ) ( f1 ) alpar@9: * ( ) = ( ) ( ) => ( ) ( ) = ( ) alpar@9: * ( g2 ) ( 0 I ) ( g1 ) ( 0 I ) ( g2 ) ( g1 ) alpar@9: * alpar@9: * from which it follows that: alpar@9: * alpar@9: * { L'0 * f2 + S' * g2 = f1 alpar@9: * { => f2 = inv(L'0) * ( f1 - S' * g2) alpar@9: * { g2 = g1 alpar@9: * alpar@9: * 4. Compute alpar@9: * alpar@9: * ( x ) ( f2 ) alpar@9: * ( ) = P ( ) alpar@9: * ( y ) ( g2 ) */ alpar@9: alpar@9: void lpf_btran(LPF *lpf, double x[]) alpar@9: { int m0 = lpf->m0; alpar@9: int m = lpf->m; alpar@9: int n = lpf->n; alpar@9: int *P_row = lpf->P_row; alpar@9: int *Q_row = lpf->Q_row; alpar@9: double *fg = lpf->work1; alpar@9: double *f = fg; alpar@9: double *g = fg + m0; alpar@9: int i, ii; alpar@9: #if _GLPLPF_DEBUG alpar@9: double *b; alpar@9: #endif alpar@9: if (!lpf->valid) alpar@9: xfault("lpf_btran: the factorization is not valid\n"); alpar@9: xassert(0 <= m && m <= m0 + n); alpar@9: #if _GLPLPF_DEBUG alpar@9: /* save the right-hand side vector */ alpar@9: b = xcalloc(1+m, sizeof(double)); alpar@9: for (i = 1; i <= m; i++) b[i] = x[i]; alpar@9: #endif alpar@9: /* (f g) := Q * (b 0) */ alpar@9: for (i = 1; i <= m0 + n; i++) alpar@9: fg[i] = ((ii = Q_row[i]) <= m ? x[ii] : 0.0); alpar@9: /* f1 := inv(U'0) * f */ alpar@9: luf_v_solve(lpf->luf, 1, f); alpar@9: /* g1 := inv(C') * (g - R' * f1) */ alpar@9: rt_prod(lpf, g, -1.0, f); alpar@9: scf_solve_it(lpf->scf, 1, g); alpar@9: /* g2 := g1 */ alpar@9: g = g; alpar@9: /* f2 := inv(L'0) * (f1 - S' * g2) */ alpar@9: st_prod(lpf, f, -1.0, g); alpar@9: luf_f_solve(lpf->luf, 1, f); alpar@9: /* (x y) := P * (f2 g2) */ alpar@9: for (i = 1; i <= m; i++) alpar@9: x[i] = fg[P_row[i]]; alpar@9: #if _GLPLPF_DEBUG alpar@9: /* check relative error in solution */ alpar@9: check_error(lpf, 1, x, b); alpar@9: xfree(b); alpar@9: #endif alpar@9: return; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * The routine enlarge_sva enlarges the Sparse Vector Area to new_size alpar@9: * locations by reallocating the arrays v_ind and v_val. */ alpar@9: alpar@9: static void enlarge_sva(LPF *lpf, int new_size) alpar@9: { int v_size = lpf->v_size; alpar@9: int used = lpf->v_ptr - 1; alpar@9: int *v_ind = lpf->v_ind; alpar@9: double *v_val = lpf->v_val; alpar@9: xassert(v_size < new_size); alpar@9: while (v_size < new_size) v_size += v_size; alpar@9: lpf->v_size = v_size; alpar@9: lpf->v_ind = xcalloc(1+v_size, sizeof(int)); alpar@9: lpf->v_val = xcalloc(1+v_size, sizeof(double)); alpar@9: xassert(used >= 0); alpar@9: memcpy(&lpf->v_ind[1], &v_ind[1], used * sizeof(int)); alpar@9: memcpy(&lpf->v_val[1], &v_val[1], used * sizeof(double)); alpar@9: xfree(v_ind); alpar@9: xfree(v_val); alpar@9: return; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * NAME alpar@9: * alpar@9: * lpf_update_it - update LP basis factorization alpar@9: * alpar@9: * SYNOPSIS alpar@9: * alpar@9: * #include "glplpf.h" alpar@9: * int lpf_update_it(LPF *lpf, int j, int bh, int len, const int ind[], alpar@9: * const double val[]); alpar@9: * alpar@9: * DESCRIPTION alpar@9: * alpar@9: * The routine lpf_update_it updates the factorization of the basis alpar@9: * matrix B after replacing its j-th column by a new vector. alpar@9: * alpar@9: * The parameter j specifies the number of column of B, which has been alpar@9: * replaced, 1 <= j <= m, where m is the order of B. alpar@9: * alpar@9: * The parameter bh specifies the basis header entry for the new column alpar@9: * of B, which is the number of the new column in some original matrix. alpar@9: * This parameter is optional and can be specified as 0. alpar@9: * alpar@9: * Row indices and numerical values of non-zero elements of the new alpar@9: * column of B should be placed in locations ind[1], ..., ind[len] and alpar@9: * val[1], ..., val[len], resp., where len is the number of non-zeros alpar@9: * in the column. Neither zero nor duplicate elements are allowed. alpar@9: * alpar@9: * RETURNS alpar@9: * alpar@9: * 0 The factorization has been successfully updated. alpar@9: * alpar@9: * LPF_ESING alpar@9: * New basis B is singular within the working precision. alpar@9: * alpar@9: * LPF_ELIMIT alpar@9: * Maximal number of additional rows and columns has been reached. alpar@9: * alpar@9: * BACKGROUND alpar@9: * alpar@9: * Let j-th column of the current basis matrix B have to be replaced by alpar@9: * a new column a. This replacement is equivalent to removing the old alpar@9: * j-th column by fixing it at zero and introducing the new column as alpar@9: * follows: alpar@9: * alpar@9: * ( B F^| a ) alpar@9: * ( B F^) ( | ) alpar@9: * ( ) ---> ( G^ H^| 0 ) alpar@9: * ( G^ H^) (-------+---) alpar@9: * ( e'j 0 | 0 ) alpar@9: * alpar@9: * where ej is a unit vector with 1 in j-th position which used to fix alpar@9: * the old j-th column of B (at zero). Then using the main equality we alpar@9: * have: alpar@9: * alpar@9: * ( B F^| a ) ( B0 F | f ) alpar@9: * ( | ) ( P 0 ) ( | ) ( Q 0 ) alpar@9: * ( G^ H^| 0 ) = ( ) ( G H | g ) ( ) = alpar@9: * (-------+---) ( 0 1 ) (-------+---) ( 0 1 ) alpar@9: * ( e'j 0 | 0 ) ( v' w'| 0 ) alpar@9: * alpar@9: * [ ( B0 F )| ( f ) ] [ ( B0 F ) | ( f ) ] alpar@9: * [ P ( )| P ( ) ] ( Q 0 ) [ P ( ) Q| P ( ) ] alpar@9: * = [ ( G H )| ( g ) ] ( ) = [ ( G H ) | ( g ) ] alpar@9: * [------------+-------- ] ( 0 1 ) [-------------+---------] alpar@9: * [ ( v' w')| 0 ] [ ( v' w') Q| 0 ] alpar@9: * alpar@9: * where: alpar@9: * alpar@9: * ( a ) ( f ) ( f ) ( a ) alpar@9: * ( ) = P ( ) => ( ) = P' * ( ) alpar@9: * ( 0 ) ( g ) ( g ) ( 0 ) alpar@9: * alpar@9: * ( ej ) ( v ) ( v ) ( ej ) alpar@9: * ( e'j 0 ) = ( v' w' ) Q => ( ) = Q' ( ) => ( ) = Q ( ) alpar@9: * ( 0 ) ( w ) ( w ) ( 0 ) alpar@9: * alpar@9: * On the other hand: alpar@9: * alpar@9: * ( B0| F f ) alpar@9: * ( P 0 ) (---+------) ( Q 0 ) ( B0 new F ) alpar@9: * ( ) ( G | H g ) ( ) = new P ( ) new Q alpar@9: * ( 0 1 ) ( | ) ( 0 1 ) ( new G new H ) alpar@9: * ( v'| w' 0 ) alpar@9: * alpar@9: * where: alpar@9: * ( G ) ( H g ) alpar@9: * new F = ( F f ), new G = ( ), new H = ( ), alpar@9: * ( v') ( w' 0 ) alpar@9: * alpar@9: * ( P 0 ) ( Q 0 ) alpar@9: * new P = ( ) , new Q = ( ) . alpar@9: * ( 0 1 ) ( 0 1 ) alpar@9: * alpar@9: * The factorization structure for the new augmented matrix remains the alpar@9: * same, therefore: alpar@9: * alpar@9: * ( B0 new F ) ( L0 0 ) ( U0 new R ) alpar@9: * new P ( ) new Q = ( ) ( ) alpar@9: * ( new G new H ) ( new S I ) ( 0 new C ) alpar@9: * alpar@9: * where: alpar@9: * alpar@9: * new F = L0 * new R => alpar@9: * alpar@9: * new R = inv(L0) * new F = inv(L0) * (F f) = ( R inv(L0)*f ) alpar@9: * alpar@9: * new G = new S * U0 => alpar@9: * alpar@9: * ( G ) ( S ) alpar@9: * new S = new G * inv(U0) = ( ) * inv(U0) = ( ) alpar@9: * ( v') ( v'*inv(U0) ) alpar@9: * alpar@9: * new H = new S * new R + new C => alpar@9: * alpar@9: * new C = new H - new S * new R = alpar@9: * alpar@9: * ( H g ) ( S ) alpar@9: * = ( ) - ( ) * ( R inv(L0)*f ) = alpar@9: * ( w' 0 ) ( v'*inv(U0) ) alpar@9: * alpar@9: * ( H - S*R g - S*inv(L0)*f ) ( C x ) alpar@9: * = ( ) = ( ) alpar@9: * ( w'- v'*inv(U0)*R -v'*inv(U0)*inv(L0)*f) ( y' z ) alpar@9: * alpar@9: * Note that new C is resulted by expanding old C with new column x, alpar@9: * row y', and diagonal element z, where: alpar@9: * alpar@9: * x = g - S * inv(L0) * f = g - S * (new column of R) alpar@9: * alpar@9: * y = w - R'* inv(U'0)* v = w - R'* (new row of S) alpar@9: * alpar@9: * z = - (new row of S) * (new column of R) alpar@9: * alpar@9: * Finally, to replace old B by new B we have to permute j-th and last alpar@9: * (just added) columns of the matrix alpar@9: * alpar@9: * ( B F^| a ) alpar@9: * ( | ) alpar@9: * ( G^ H^| 0 ) alpar@9: * (-------+---) alpar@9: * ( e'j 0 | 0 ) alpar@9: * alpar@9: * and to keep the main equality do the same for matrix Q. */ alpar@9: alpar@9: int lpf_update_it(LPF *lpf, int j, int bh, int len, const int ind[], alpar@9: const double val[]) alpar@9: { int m0 = lpf->m0; alpar@9: int m = lpf->m; alpar@9: #if _GLPLPF_DEBUG alpar@9: double *B = lpf->B; alpar@9: #endif alpar@9: int n = lpf->n; alpar@9: int *R_ptr = lpf->R_ptr; alpar@9: int *R_len = lpf->R_len; alpar@9: int *S_ptr = lpf->S_ptr; alpar@9: int *S_len = lpf->S_len; alpar@9: int *P_row = lpf->P_row; alpar@9: int *P_col = lpf->P_col; alpar@9: int *Q_row = lpf->Q_row; alpar@9: int *Q_col = lpf->Q_col; alpar@9: int v_ptr = lpf->v_ptr; alpar@9: int *v_ind = lpf->v_ind; alpar@9: double *v_val = lpf->v_val; alpar@9: double *a = lpf->work2; /* new column */ alpar@9: double *fg = lpf->work1, *f = fg, *g = fg + m0; alpar@9: double *vw = lpf->work2, *v = vw, *w = vw + m0; alpar@9: double *x = g, *y = w, z; alpar@9: int i, ii, k, ret; alpar@9: xassert(bh == bh); alpar@9: if (!lpf->valid) alpar@9: xfault("lpf_update_it: the factorization is not valid\n"); alpar@9: if (!(1 <= j && j <= m)) alpar@9: xfault("lpf_update_it: j = %d; column number out of range\n", alpar@9: j); alpar@9: xassert(0 <= m && m <= m0 + n); alpar@9: /* check if the basis factorization can be expanded */ alpar@9: if (n == lpf->n_max) alpar@9: { lpf->valid = 0; alpar@9: ret = LPF_ELIMIT; alpar@9: goto done; alpar@9: } alpar@9: /* convert new j-th column of B to dense format */ alpar@9: for (i = 1; i <= m; i++) alpar@9: a[i] = 0.0; alpar@9: for (k = 1; k <= len; k++) alpar@9: { i = ind[k]; alpar@9: if (!(1 <= i && i <= m)) alpar@9: xfault("lpf_update_it: ind[%d] = %d; row number out of rang" alpar@9: "e\n", k, i); alpar@9: if (a[i] != 0.0) alpar@9: xfault("lpf_update_it: ind[%d] = %d; duplicate row index no" alpar@9: "t allowed\n", k, i); alpar@9: if (val[k] == 0.0) alpar@9: xfault("lpf_update_it: val[%d] = %g; zero element not allow" alpar@9: "ed\n", k, val[k]); alpar@9: a[i] = val[k]; alpar@9: } alpar@9: #if _GLPLPF_DEBUG alpar@9: /* change column in the basis matrix for debugging */ alpar@9: for (i = 1; i <= m; i++) alpar@9: B[(i - 1) * m + j] = a[i]; alpar@9: #endif alpar@9: /* (f g) := inv(P) * (a 0) */ alpar@9: for (i = 1; i <= m0+n; i++) alpar@9: fg[i] = ((ii = P_col[i]) <= m ? a[ii] : 0.0); alpar@9: /* (v w) := Q * (ej 0) */ alpar@9: for (i = 1; i <= m0+n; i++) vw[i] = 0.0; alpar@9: vw[Q_col[j]] = 1.0; alpar@9: /* f1 := inv(L0) * f (new column of R) */ alpar@9: luf_f_solve(lpf->luf, 0, f); alpar@9: /* v1 := inv(U'0) * v (new row of S) */ alpar@9: luf_v_solve(lpf->luf, 1, v); alpar@9: /* we need at most 2 * m0 available locations in the SVA to store alpar@9: new column of matrix R and new row of matrix S */ alpar@9: if (lpf->v_size < v_ptr + m0 + m0) alpar@9: { enlarge_sva(lpf, v_ptr + m0 + m0); alpar@9: v_ind = lpf->v_ind; alpar@9: v_val = lpf->v_val; alpar@9: } alpar@9: /* store new column of R */ alpar@9: R_ptr[n+1] = v_ptr; alpar@9: for (i = 1; i <= m0; i++) alpar@9: { if (f[i] != 0.0) alpar@9: v_ind[v_ptr] = i, v_val[v_ptr] = f[i], v_ptr++; alpar@9: } alpar@9: R_len[n+1] = v_ptr - lpf->v_ptr; alpar@9: lpf->v_ptr = v_ptr; alpar@9: /* store new row of S */ alpar@9: S_ptr[n+1] = v_ptr; alpar@9: for (i = 1; i <= m0; i++) alpar@9: { if (v[i] != 0.0) alpar@9: v_ind[v_ptr] = i, v_val[v_ptr] = v[i], v_ptr++; alpar@9: } alpar@9: S_len[n+1] = v_ptr - lpf->v_ptr; alpar@9: lpf->v_ptr = v_ptr; alpar@9: /* x := g - S * f1 (new column of C) */ alpar@9: s_prod(lpf, x, -1.0, f); alpar@9: /* y := w - R' * v1 (new row of C) */ alpar@9: rt_prod(lpf, y, -1.0, v); alpar@9: /* z := - v1 * f1 (new diagonal element of C) */ alpar@9: z = 0.0; alpar@9: for (i = 1; i <= m0; i++) z -= v[i] * f[i]; alpar@9: /* update factorization of new matrix C */ alpar@9: switch (scf_update_exp(lpf->scf, x, y, z)) alpar@9: { case 0: alpar@9: break; alpar@9: case SCF_ESING: alpar@9: lpf->valid = 0; alpar@9: ret = LPF_ESING; alpar@9: goto done; alpar@9: case SCF_ELIMIT: alpar@9: xassert(lpf != lpf); alpar@9: default: alpar@9: xassert(lpf != lpf); alpar@9: } alpar@9: /* expand matrix P */ alpar@9: P_row[m0+n+1] = P_col[m0+n+1] = m0+n+1; alpar@9: /* expand matrix Q */ alpar@9: Q_row[m0+n+1] = Q_col[m0+n+1] = m0+n+1; alpar@9: /* permute j-th and last (just added) column of matrix Q */ alpar@9: i = Q_col[j], ii = Q_col[m0+n+1]; alpar@9: Q_row[i] = m0+n+1, Q_col[m0+n+1] = i; alpar@9: Q_row[ii] = j, Q_col[j] = ii; alpar@9: /* increase the number of additional rows and columns */ alpar@9: lpf->n++; alpar@9: xassert(lpf->n <= lpf->n_max); alpar@9: /* the factorization has been successfully updated */ alpar@9: ret = 0; alpar@9: done: /* return to the calling program */ alpar@9: return ret; alpar@9: } alpar@9: alpar@9: /*********************************************************************** alpar@9: * NAME alpar@9: * alpar@9: * lpf_delete_it - delete LP basis factorization alpar@9: * alpar@9: * SYNOPSIS alpar@9: * alpar@9: * #include "glplpf.h" alpar@9: * void lpf_delete_it(LPF *lpf) alpar@9: * alpar@9: * DESCRIPTION alpar@9: * alpar@9: * The routine lpf_delete_it deletes LP basis factorization specified alpar@9: * by the parameter lpf and frees all memory allocated to this program alpar@9: * object. */ alpar@9: alpar@9: void lpf_delete_it(LPF *lpf) alpar@9: { luf_delete_it(lpf->luf); alpar@9: #if _GLPLPF_DEBUG alpar@9: if (lpf->B != NULL) xfree(lpf->B); alpar@9: #else alpar@9: xassert(lpf->B == NULL); alpar@9: #endif alpar@9: if (lpf->R_ptr != NULL) xfree(lpf->R_ptr); alpar@9: if (lpf->R_len != NULL) xfree(lpf->R_len); alpar@9: if (lpf->S_ptr != NULL) xfree(lpf->S_ptr); alpar@9: if (lpf->S_len != NULL) xfree(lpf->S_len); alpar@9: if (lpf->scf != NULL) scf_delete_it(lpf->scf); alpar@9: if (lpf->P_row != NULL) xfree(lpf->P_row); alpar@9: if (lpf->P_col != NULL) xfree(lpf->P_col); alpar@9: if (lpf->Q_row != NULL) xfree(lpf->Q_row); alpar@9: if (lpf->Q_col != NULL) xfree(lpf->Q_col); alpar@9: if (lpf->v_ind != NULL) xfree(lpf->v_ind); alpar@9: if (lpf->v_val != NULL) xfree(lpf->v_val); alpar@9: if (lpf->work1 != NULL) xfree(lpf->work1); alpar@9: if (lpf->work2 != NULL) xfree(lpf->work2); alpar@9: xfree(lpf); alpar@9: return; alpar@9: } alpar@9: alpar@9: /* eof */