/*************************************************************************
This function restarts LinLSQRIteration
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrrestart(linlsqrstate state)
{
state.rstate.ia = new int[1+1];
state.rstate.ra = new double[0+1];
state.rstate.stage = -1;
clearrfields(state);
}
/*************************************************************************
Clears request fileds (to be sure that we don't forgot to clear something)
*************************************************************************/
private static void clearrfields(linlsqrstate state)
{
state.xupdated = false;
state.needmv = false;
state.needmtv = false;
state.needmv2 = false;
state.needvmv = false;
state.needprec = false;
}
/*************************************************************************
LSQR solver: results.
This function must be called after LinLSQRSolve
INPUT PARAMETERS:
State - algorithm state
OUTPUT PARAMETERS:
X - array[N], solution
Rep - optimization report:
* Rep.TerminationType completetion code:
* 1 ||Rk||<=EpsB*||B||
* 4 ||A^T*Rk||/(||A||*||Rk||)<=EpsA
* 5 MaxIts steps was taken
* 7 rounding errors prevent further progress,
X contains best point found so far.
(sometimes returned on singular systems)
* Rep.IterationsCount contains iterations count
* NMV countains number of matrix-vector calculations
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrresults(linlsqrstate state,
ref double[] x,
linlsqrreport rep)
{
int i_ = 0;
x = new double[0];
alglib.ap.assert(!state.running, "LinLSQRResult: you can not call this function when LinLSQRIteration is running");
if( alglib.ap.len(x)<state.n )
{
x = new double[state.n];
}
for(i_=0; i_<=state.n-1;i_++)
{
x[i_] = state.rx[i_];
}
rep.iterationscount = state.repiterationscount;
rep.nmv = state.repnmv;
rep.terminationtype = state.repterminationtype;
}
/*************************************************************************
This function turns on/off reporting.
INPUT PARAMETERS:
State - structure which stores algorithm state
NeedXRep- whether iteration reports are needed or not
If NeedXRep is True, algorithm will call rep() callback function if it is
provided to MinCGOptimize().
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsetxrep(linlsqrstate state,
bool needxrep)
{
state.xrep = needxrep;
}
/*************************************************************************
Procedure for solution of A*x=b with sparse A.
INPUT PARAMETERS:
State - algorithm state
A - sparse M*N matrix in the CRS format (you MUST contvert it
to CRS format by calling SparseConvertToCRS() function
BEFORE you pass it to this function).
B - right part, array[M]
RESULT:
This function returns no result.
You can get solution by calling LinCGResults()
NOTE: this function uses lightweight preconditioning - multiplication by
inverse of diag(A). If you want, you can turn preconditioning off by
calling LinLSQRSetPrecUnit(). However, preconditioning cost is low
and preconditioner is very important for solution of badly scaled
problems.
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsolvesparse(linlsqrstate state,
sparse.sparsematrix a,
double[] b)
{
int n = 0;
int i = 0;
int j = 0;
int t0 = 0;
int t1 = 0;
double v = 0;
n = state.n;
alglib.ap.assert(!state.running, "LinLSQRSolveSparse: you can not call this function when LinLSQRIteration is running");
alglib.ap.assert(alglib.ap.len(b)>=state.m, "LinLSQRSolveSparse: Length(B)<M");
alglib.ap.assert(apserv.isfinitevector(b, state.m), "LinLSQRSolveSparse: B contains infinite or NaN values");
//
// Allocate temporaries
//
apserv.rvectorsetlengthatleast(ref state.tmpd, n);
apserv.rvectorsetlengthatleast(ref state.tmpx, n);
//
// Compute diagonal scaling matrix D
//
if( state.prectype==0 )
{
//
// Default preconditioner - inverse of column norms
//
for(i=0; i<=n-1; i++)
{
state.tmpd[i] = 0;
}
t0 = 0;
t1 = 0;
while( sparse.sparseenumerate(a, ref t0, ref t1, ref i, ref j, ref v) )
{
state.tmpd[j] = state.tmpd[j]+math.sqr(v);
}
for(i=0; i<=n-1; i++)
{
if( (double)(state.tmpd[i])>(double)(0) )
{
state.tmpd[i] = 1/Math.Sqrt(state.tmpd[i]);
}
else
{
state.tmpd[i] = 1;
}
}
}
else
{
//
// No diagonal scaling
//
for(i=0; i<=n-1; i++)
{
state.tmpd[i] = 1;
}
}
//
// Solve.
//
// Instead of solving A*x=b we solve preconditioned system (A*D)*(inv(D)*x)=b.
// Transformed A is not calculated explicitly, we just modify multiplication
// by A or A'. After solution we modify State.RX so it will store untransformed
// variables
//
linlsqrsetb(state, b);
linlsqrrestart(state);
while( linlsqriteration(state) )
{
if( state.needmv )
{
for(i=0; i<=n-1; i++)
{
state.tmpx[i] = state.tmpd[i]*state.x[i];
}
sparse.sparsemv(a, state.tmpx, ref state.mv);
}
if( state.needmtv )
{
sparse.sparsemtv(a, state.x, ref state.mtv);
for(i=0; i<=n-1; i++)
{
state.mtv[i] = state.tmpd[i]*state.mtv[i];
}
}
}
for(i=0; i<=n-1; i++)
{
state.rx[i] = state.tmpd[i]*state.rx[i];
}
}
/*************************************************************************
This function sets stopping criteria.
INPUT PARAMETERS:
EpsA - algorithm will be stopped if ||A^T*Rk||/(||A||*||Rk||)<=EpsA.
EpsB - algorithm will be stopped if ||Rk||<=EpsB*||B||
MaxIts - algorithm will be stopped if number of iterations
more than MaxIts.
OUTPUT PARAMETERS:
State - structure which stores algorithm state
NOTE: if EpsA,EpsB,EpsC and MaxIts are zero then these variables will
be setted as default values.
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsetcond(linlsqrstate state,
double epsa,
double epsb,
int maxits)
{
alglib.ap.assert(!state.running, "LinLSQRSetCond: you can not call this function when LinLSQRIteration is running");
alglib.ap.assert(math.isfinite(epsa) && (double)(epsa)>=(double)(0), "LinLSQRSetCond: EpsA is negative, INF or NAN");
alglib.ap.assert(math.isfinite(epsb) && (double)(epsb)>=(double)(0), "LinLSQRSetCond: EpsB is negative, INF or NAN");
alglib.ap.assert(maxits>=0, "LinLSQRSetCond: MaxIts is negative");
if( ((double)(epsa)==(double)(0) && (double)(epsb)==(double)(0)) && maxits==0 )
{
state.epsa = atol;
state.epsb = btol;
state.maxits = state.n;
}
else
{
state.epsa = epsa;
state.epsb = epsb;
state.maxits = maxits;
}
}
/*************************************************************************
This function sets optional Tikhonov regularization coefficient.
It is zero by default.
INPUT PARAMETERS:
LambdaI - regularization factor, LambdaI>=0
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsetlambdai(linlsqrstate state,
double lambdai)
{
alglib.ap.assert(!state.running, "LinLSQRSetLambdaI: you can not set LambdaI, because function LinLSQRIteration is running");
alglib.ap.assert(math.isfinite(lambdai) && (double)(lambdai)>=(double)(0), "LinLSQRSetLambdaI: LambdaI is infinite or NaN");
state.lambdai = lambdai;
}
/*************************************************************************
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static bool linlsqriteration(linlsqrstate state)
{
bool result = new bool();
int summn = 0;
double bnorm = 0;
int i = 0;
int i_ = 0;
//
// Reverse communication preparations
// I know it looks ugly, but it works the same way
// anywhere from C++ to Python.
//
// This code initializes locals by:
// * random values determined during code
// generation - on first subroutine call
// * values from previous call - on subsequent calls
//
if( state.rstate.stage>=0 )
{
summn = state.rstate.ia[0];
i = state.rstate.ia[1];
bnorm = state.rstate.ra[0];
}
else
{
summn = -983;
i = -989;
bnorm = -834;
}
if( state.rstate.stage==0 )
{
goto lbl_0;
}
if( state.rstate.stage==1 )
{
goto lbl_1;
}
if( state.rstate.stage==2 )
{
goto lbl_2;
}
if( state.rstate.stage==3 )
{
goto lbl_3;
}
if( state.rstate.stage==4 )
{
goto lbl_4;
}
if( state.rstate.stage==5 )
{
goto lbl_5;
}
if( state.rstate.stage==6 )
{
goto lbl_6;
}
//
// Routine body
//
alglib.ap.assert(alglib.ap.len(state.b)>0, "LinLSQRIteration: using non-allocated array B");
bnorm = Math.Sqrt(state.bnorm2);
state.running = true;
state.repnmv = 0;
clearrfields(state);
state.repiterationscount = 0;
summn = state.m+state.n;
state.r2 = state.bnorm2;
//
//estimate for ANorm
//
normestimator.normestimatorrestart(state.nes);
lbl_7:
if( !normestimator.normestimatoriteration(state.nes) )
{
goto lbl_8;
}
if( !state.nes.needmv )
{
goto lbl_9;
}
for(i_=0; i_<=state.n-1;i_++)
{
state.x[i_] = state.nes.x[i_];
}
state.repnmv = state.repnmv+1;
clearrfields(state);
state.needmv = true;
state.rstate.stage = 0;
goto lbl_rcomm;
lbl_0:
state.needmv = false;
for(i_=0; i_<=state.m-1;i_++)
{
state.nes.mv[i_] = state.mv[i_];
}
goto lbl_7;
lbl_9:
if( !state.nes.needmtv )
{
goto lbl_11;
}
for(i_=0; i_<=state.m-1;i_++)
{
state.x[i_] = state.nes.x[i_];
}
//
//matrix-vector multiplication
//
state.repnmv = state.repnmv+1;
clearrfields(state);
state.needmtv = true;
state.rstate.stage = 1;
goto lbl_rcomm;
lbl_1:
state.needmtv = false;
for(i_=0; i_<=state.n-1;i_++)
{
state.nes.mtv[i_] = state.mtv[i_];
}
goto lbl_7;
lbl_11:
goto lbl_7;
lbl_8:
normestimator.normestimatorresults(state.nes, ref state.anorm);
//
//initialize .RX by zeros
//
for(i=0; i<=state.n-1; i++)
{
state.rx[i] = 0;
}
//
//output first report
//
if( !state.xrep )
{
goto lbl_13;
}
for(i_=0; i_<=state.n-1;i_++)
{
state.x[i_] = state.rx[i_];
}
clearrfields(state);
state.xupdated = true;
state.rstate.stage = 2;
goto lbl_rcomm;
lbl_2:
state.xupdated = false;
lbl_13:
//
// LSQR, Step 0.
//
// Algorithm outline corresponds to one which was described at p.50 of
// "LSQR - an algorithm for sparse linear equations and sparse least
// squares" by C.Paige and M.Saunders with one small addition - we
// explicitly extend system matrix by additional N lines in order
// to handle non-zero lambda, i.e. original A is replaced by
// [ A ]
// A_mod = [ ]
// [ lambda*I ].
//
// Step 0:
// x[0] = 0
// beta[1]*u[1] = b
// alpha[1]*v[1] = A_mod'*u[1]
// w[1] = v[1]
// phiBar[1] = beta[1]
// rhoBar[1] = alpha[1]
// d[0] = 0
//
// NOTE:
// There are three criteria for stopping:
// (S0) maximum number of iterations
// (S1) ||Rk||<=EpsB*||B||;
// (S2) ||A^T*Rk||/(||A||*||Rk||)<=EpsA.
// It is very important that S2 always checked AFTER S1. It is necessary
// to avoid division by zero when Rk=0.
//
state.betai = bnorm;
if( (double)(state.betai)==(double)(0) )
{
//
// Zero right part
//
state.running = false;
state.repterminationtype = 1;
result = false;
return result;
}
for(i=0; i<=summn-1; i++)
{
if( i<state.m )
{
state.ui[i] = state.b[i]/state.betai;
}
else
{
state.ui[i] = 0;
}
state.x[i] = state.ui[i];
}
state.repnmv = state.repnmv+1;
clearrfields(state);
state.needmtv = true;
state.rstate.stage = 3;
goto lbl_rcomm;
lbl_3:
state.needmtv = false;
for(i=0; i<=state.n-1; i++)
{
state.mtv[i] = state.mtv[i]+state.lambdai*state.ui[state.m+i];
}
state.alphai = 0;
for(i=0; i<=state.n-1; i++)
{
state.alphai = state.alphai+state.mtv[i]*state.mtv[i];
}
state.alphai = Math.Sqrt(state.alphai);
if( (double)(state.alphai)==(double)(0) )
{
//
// Orthogonality stopping criterion is met
//
state.running = false;
state.repterminationtype = 4;
result = false;
return result;
}
for(i=0; i<=state.n-1; i++)
{
state.vi[i] = state.mtv[i]/state.alphai;
state.omegai[i] = state.vi[i];
}
state.phibari = state.betai;
state.rhobari = state.alphai;
for(i=0; i<=state.n-1; i++)
{
state.d[i] = 0;
}
state.dnorm = 0;
//
// Steps I=1, 2, ...
//
lbl_15:
if( false )
{
goto lbl_16;
}
//
// At I-th step State.RepIterationsCount=I.
//
state.repiterationscount = state.repiterationscount+1;
//
// Bidiagonalization part:
// beta[i+1]*u[i+1] = A_mod*v[i]-alpha[i]*u[i]
// alpha[i+1]*v[i+1] = A_mod'*u[i+1] - beta[i+1]*v[i]
//
// NOTE: beta[i+1]=0 or alpha[i+1]=0 will lead to successful termination
// in the end of the current iteration. In this case u/v are zero.
// NOTE2: algorithm won't fail on zero alpha or beta (there will be no
// division by zero because it will be stopped BEFORE division
// occurs). However, near-zero alpha and beta won't stop algorithm
// and, although no division by zero will happen, orthogonality
// in U and V will be lost.
//
for(i_=0; i_<=state.n-1;i_++)
{
state.x[i_] = state.vi[i_];
}
state.repnmv = state.repnmv+1;
clearrfields(state);
state.needmv = true;
state.rstate.stage = 4;
goto lbl_rcomm;
lbl_4:
state.needmv = false;
for(i=0; i<=state.n-1; i++)
{
state.mv[state.m+i] = state.lambdai*state.vi[i];
}
state.betaip1 = 0;
for(i=0; i<=summn-1; i++)
{
state.uip1[i] = state.mv[i]-state.alphai*state.ui[i];
state.betaip1 = state.betaip1+state.uip1[i]*state.uip1[i];
}
if( (double)(state.betaip1)!=(double)(0) )
{
state.betaip1 = Math.Sqrt(state.betaip1);
for(i=0; i<=summn-1; i++)
{
state.uip1[i] = state.uip1[i]/state.betaip1;
}
}
for(i_=0; i_<=state.m-1;i_++)
{
state.x[i_] = state.uip1[i_];
}
state.repnmv = state.repnmv+1;
clearrfields(state);
state.needmtv = true;
state.rstate.stage = 5;
goto lbl_rcomm;
lbl_5:
state.needmtv = false;
for(i=0; i<=state.n-1; i++)
{
state.mtv[i] = state.mtv[i]+state.lambdai*state.uip1[state.m+i];
}
state.alphaip1 = 0;
for(i=0; i<=state.n-1; i++)
{
state.vip1[i] = state.mtv[i]-state.betaip1*state.vi[i];
state.alphaip1 = state.alphaip1+state.vip1[i]*state.vip1[i];
}
if( (double)(state.alphaip1)!=(double)(0) )
{
state.alphaip1 = Math.Sqrt(state.alphaip1);
for(i=0; i<=state.n-1; i++)
{
state.vip1[i] = state.vip1[i]/state.alphaip1;
}
}
//
// Build next orthogonal transformation
//
state.rhoi = apserv.safepythag2(state.rhobari, state.betaip1);
state.ci = state.rhobari/state.rhoi;
state.si = state.betaip1/state.rhoi;
state.theta = state.si*state.alphaip1;
state.rhobarip1 = -(state.ci*state.alphaip1);
state.phii = state.ci*state.phibari;
state.phibarip1 = state.si*state.phibari;
//
// Update .RNorm
//
// This tricky formula is necessary because simply writing
// State.R2:=State.PhiBarIP1*State.PhiBarIP1 does NOT guarantees
// monotonic decrease of R2. Roundoff error combined with 80-bit
// precision used internally by Intel chips allows R2 to increase
// slightly in some rare, but possible cases. This property is
// undesirable, so we prefer to guard against R increase.
//
state.r2 = Math.Min(state.r2, state.phibarip1*state.phibarip1);
//
// Update d and DNorm, check condition-related stopping criteria
//
for(i=0; i<=state.n-1; i++)
{
state.d[i] = 1/state.rhoi*(state.vi[i]-state.theta*state.d[i]);
state.dnorm = state.dnorm+state.d[i]*state.d[i];
}
if( (double)(Math.Sqrt(state.dnorm)*state.anorm)>=(double)(state.epsc) )
{
state.running = false;
state.repterminationtype = 7;
result = false;
return result;
}
//
// Update x, output report
//
for(i=0; i<=state.n-1; i++)
{
state.rx[i] = state.rx[i]+state.phii/state.rhoi*state.omegai[i];
}
if( !state.xrep )
{
goto lbl_17;
}
for(i_=0; i_<=state.n-1;i_++)
{
state.x[i_] = state.rx[i_];
}
clearrfields(state);
state.xupdated = true;
state.rstate.stage = 6;
goto lbl_rcomm;
lbl_6:
state.xupdated = false;
lbl_17:
//
// Check stopping criteria
// 1. achieved required number of iterations;
// 2. ||Rk||<=EpsB*||B||;
// 3. ||A^T*Rk||/(||A||*||Rk||)<=EpsA;
//
if( state.maxits>0 && state.repiterationscount>=state.maxits )
{
//
// Achieved required number of iterations
//
state.running = false;
state.repterminationtype = 5;
result = false;
return result;
}
if( (double)(state.phibarip1)<=(double)(state.epsb*bnorm) )
{
//
// ||Rk||<=EpsB*||B||, here ||Rk||=PhiBar
//
state.running = false;
state.repterminationtype = 1;
result = false;
return result;
}
if( (double)(state.alphaip1*Math.Abs(state.ci)/state.anorm)<=(double)(state.epsa) )
{
//
// ||A^T*Rk||/(||A||*||Rk||)<=EpsA, here ||A^T*Rk||=PhiBar*Alpha[i+1]*|.C|
//
state.running = false;
state.repterminationtype = 4;
result = false;
return result;
}
//
// Update omega
//
for(i=0; i<=state.n-1; i++)
{
state.omegaip1[i] = state.vip1[i]-state.theta/state.rhoi*state.omegai[i];
}
//
// Prepare for the next iteration - rename variables:
// u[i] := u[i+1]
// v[i] := v[i+1]
// rho[i] := rho[i+1]
// ...
//
for(i_=0; i_<=summn-1;i_++)
{
state.ui[i_] = state.uip1[i_];
}
for(i_=0; i_<=state.n-1;i_++)
{
state.vi[i_] = state.vip1[i_];
}
for(i_=0; i_<=state.n-1;i_++)
{
state.omegai[i_] = state.omegaip1[i_];
}
state.alphai = state.alphaip1;
state.betai = state.betaip1;
state.phibari = state.phibarip1;
state.rhobari = state.rhobarip1;
goto lbl_15;
lbl_16:
result = false;
return result;
//
// Saving state
//
lbl_rcomm:
result = true;
state.rstate.ia[0] = summn;
state.rstate.ia[1] = i;
state.rstate.ra[0] = bnorm;
return result;
}
/*************************************************************************
This function changes preconditioning settings of LinCGSolveSparse()
function. LinCGSolveSparse() will use diagonal of the system matrix as
preconditioner. This preconditioning mode is active by default.
INPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 19.11.2012 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsetprecdiag(linlsqrstate state)
{
alglib.ap.assert(!state.running, "LinLSQRSetPrecDiag: you can not change preconditioner, because function LinCGIteration is running!");
state.prectype = 0;
}
/*************************************************************************
This function sets right part. By default, right part is zero.
INPUT PARAMETERS:
B - right part, array[N].
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsetb(linlsqrstate state,
double[] b)
{
int i = 0;
alglib.ap.assert(!state.running, "LinLSQRSetB: you can not change B when LinLSQRIteration is running");
alglib.ap.assert(state.m<=alglib.ap.len(b), "LinLSQRSetB: Length(B)<M");
alglib.ap.assert(apserv.isfinitevector(b, state.m), "LinLSQRSetB: B contains infinite or NaN values");
state.bnorm2 = 0;
for(i=0; i<=state.m-1; i++)
{
state.b[i] = b[i];
state.bnorm2 = state.bnorm2+b[i]*b[i];
}
}
/*************************************************************************
This function initializes linear LSQR Solver. This solver is used to solve
non-symmetric (and, possibly, non-square) problems. Least squares solution
is returned for non-compatible systems.
USAGE:
1. User initializes algorithm state with LinLSQRCreate() call
2. User tunes solver parameters with LinLSQRSetCond() and other functions
3. User calls LinLSQRSolveSparse() function which takes algorithm state
and SparseMatrix object.
4. User calls LinLSQRResults() to get solution
5. Optionally, user may call LinLSQRSolveSparse() again to solve another
problem with different matrix and/or right part without reinitializing
LinLSQRState structure.
INPUT PARAMETERS:
M - number of rows in A
N - number of variables, N>0
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrcreate(int m,
int n,
linlsqrstate state)
{
int i = 0;
alglib.ap.assert(m>0, "LinLSQRCreate: M<=0");
alglib.ap.assert(n>0, "LinLSQRCreate: N<=0");
state.m = m;
state.n = n;
state.prectype = 0;
state.epsa = atol;
state.epsb = btol;
state.epsc = 1/Math.Sqrt(math.machineepsilon);
state.maxits = 0;
state.lambdai = 0;
state.xrep = false;
state.running = false;
//
// * allocate arrays
// * set RX to NAN (just for the case user calls Results() without
// calling SolveSparse()
// * set B to zero
//
normestimator.normestimatorcreate(m, n, 2, 2, state.nes);
state.rx = new double[state.n];
state.ui = new double[state.m+state.n];
state.uip1 = new double[state.m+state.n];
state.vip1 = new double[state.n];
state.vi = new double[state.n];
state.omegai = new double[state.n];
state.omegaip1 = new double[state.n];
state.d = new double[state.n];
state.x = new double[state.m+state.n];
state.mv = new double[state.m+state.n];
state.mtv = new double[state.n];
state.b = new double[state.m];
for(i=0; i<=n-1; i++)
{
state.rx[i] = Double.NaN;
}
for(i=0; i<=m-1; i++)
{
state.b[i] = 0;
}
state.rstate.ia = new int[1+1];
state.rstate.ra = new double[0+1];
state.rstate.stage = -1;
}
public override alglib.apobject make_copy()
{
linlsqrstate _result = new linlsqrstate();
_result.nes = (normestimator.normestimatorstate)nes.make_copy();
_result.rx = (double[])rx.Clone();
_result.b = (double[])b.Clone();
_result.n = n;
_result.m = m;
_result.prectype = prectype;
_result.ui = (double[])ui.Clone();
_result.uip1 = (double[])uip1.Clone();
_result.vi = (double[])vi.Clone();
_result.vip1 = (double[])vip1.Clone();
_result.omegai = (double[])omegai.Clone();
_result.omegaip1 = (double[])omegaip1.Clone();
_result.alphai = alphai;
_result.alphaip1 = alphaip1;
_result.betai = betai;
_result.betaip1 = betaip1;
_result.phibari = phibari;
_result.phibarip1 = phibarip1;
_result.phii = phii;
_result.rhobari = rhobari;
_result.rhobarip1 = rhobarip1;
_result.rhoi = rhoi;
_result.ci = ci;
_result.si = si;
_result.theta = theta;
_result.lambdai = lambdai;
_result.d = (double[])d.Clone();
_result.anorm = anorm;
_result.bnorm2 = bnorm2;
_result.dnorm = dnorm;
_result.r2 = r2;
_result.x = (double[])x.Clone();
_result.mv = (double[])mv.Clone();
_result.mtv = (double[])mtv.Clone();
_result.epsa = epsa;
_result.epsb = epsb;
_result.epsc = epsc;
_result.maxits = maxits;
_result.xrep = xrep;
_result.xupdated = xupdated;
_result.needmv = needmv;
_result.needmtv = needmtv;
_result.needmv2 = needmv2;
_result.needvmv = needvmv;
_result.needprec = needprec;
_result.repiterationscount = repiterationscount;
_result.repnmv = repnmv;
_result.repterminationtype = repterminationtype;
_result.running = running;
_result.tmpd = (double[])tmpd.Clone();
_result.tmpx = (double[])tmpx.Clone();
_result.rstate = (rcommstate)rstate.make_copy();
return _result;
}
/*************************************************************************
Procedure for solution of A*x=b with sparse A.
INPUT PARAMETERS:
State - algorithm state
A - sparse M*N matrix in the CRS format (you MUST contvert it
to CRS format by calling SparseConvertToCRS() function
BEFORE you pass it to this function).
B - right part, array[M]
RESULT:
This function returns no result.
You can get solution by calling LinCGResults()
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
public static void linlsqrsolvesparse(linlsqrstate state,
sparse.sparsematrix a,
double[] b)
{
alglib.ap.assert(!state.running, "LinLSQRSolveSparse: you can not call this function when LinLSQRIteration is running");
alglib.ap.assert(alglib.ap.len(b)>=state.m, "LinLSQRSolveSparse: Length(B)<M");
alglib.ap.assert(apserv.isfinitevector(b, state.m), "LinLSQRSolveSparse: B contains infinite or NaN values");
linlsqrsetb(state, b);
linlsqrrestart(state);
while( linlsqriteration(state) )
{
if( state.needmv )
{
sparse.sparsemv(a, state.x, ref state.mv);
}
if( state.needmtv )
{
sparse.sparsemtv(a, state.x, ref state.mtv);
}
}
}
