ROOT   6.08/07 Reference Guide
TDecompSparse.cxx
Go to the documentation of this file.
1 // @(#)root/matrix:$Id$
2 // Authors: Fons Rademakers, Eddy Offermann Apr 2004
3
4 /*************************************************************************
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. * 9 * For the list of contributors see$ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11
12 #include "TDecompSparse.h"
13 #include "TMath.h"
14
16
17 /** \class TDecompSparse
18  \ingroup Matrix
19
20  Sparse Symmetric Decomposition class
21
22  Solve a sparse symmetric system of linear equations using a method
23  based on Gaussian elimination as discussed in Duff and Reid,
24  ACM Trans. Math. Software 9 (1983), 302-325.
25 */
26
27 ////////////////////////////////////////////////////////////////////////////////
28 /// Default constructor
29
31 {
32  fVerbose = 0;
33  InitParam();
34  memset(fInfo,0,21*sizeof(Int_t));
35 }
36
37 ////////////////////////////////////////////////////////////////////////////////
38 /// Constructor for a matrix with nrows and unspecified number of columns .
39 /// nr_nonZeros is the total number of non-zero entries in the matrix .
40
42 {
43  fVerbose = verbose;
44  InitParam();
45
46  fNrows = nRows;
47  fNnonZeros = nr_nonZeros;
48
49  fRowFact.Set(nr_nonZeros+1);
50  fColFact.Set(nr_nonZeros+1);
51  fW .Set(fNrows+1);
52  fIkeep .Set(3*(fNrows+1));
53  fIw .Set((Int_t)(1.3 * (2*fNnonZeros+3*fNrows+1)+1));
54  fIw1 .Set(2*(fNrows+1));
55
56  memset(fInfo,0,21*sizeof(Int_t));
57
58  // These parameters can only be set after sparsity/pivoting pattern is known
59  fNsteps = 0;
60  fMaxfrt = 0;
61 }
62
63 ////////////////////////////////////////////////////////////////////////////////
64 /// Constructor for a matrix with row range, [row_lwb..row_upb] and unspecified column
65 /// range . nr_nonZeros is the total number of non-zero entries in the matrix .
66
68 {
69  fVerbose = verbose;
70  InitParam();
71
72  fRowLwb = row_lwb;
73  fColLwb = row_lwb;
74  fNrows = row_upb-row_lwb+1;
75  fNnonZeros = nr_nonZeros;
76
77  fRowFact.Set(nr_nonZeros+1);
78  fColFact.Set(nr_nonZeros+1);
79  fW .Set(fNrows+1);
80  fIkeep .Set(3*(fNrows+1));
81  fIw .Set((Int_t)(1.3 * (2*fNnonZeros+3*fNrows+1)+1));
82  fIw1 .Set(2*(fNrows+1));
83
84  memset(fInfo,0,21*sizeof(Int_t));
85
86  // These parameters can only be set after sparsity/pivoting pattern is known
87  fNsteps = 0;
88  fMaxfrt = 0;
89 }
90
91 ////////////////////////////////////////////////////////////////////////////////
92 /// Constructor for matrix A .
93
95 {
96  fVerbose = verbose;
97
98  InitParam();
99  SetMatrix(a);
100
101  memset(fInfo,0,21*sizeof(Int_t));
102 }
103
104 ////////////////////////////////////////////////////////////////////////////////
105 /// Copy constructor
106
108 {
109  *this = another;
110 }
111
112 ////////////////////////////////////////////////////////////////////////////////
113 /// Static function, returning the number of non-zero entries in the upper triangular matrix .
114
116 {
117  const Int_t rowLwb = a.GetRowLwb();
118  const Int_t colLwb = a.GetColLwb();
119  const Int_t nrows = a.GetNrows();;
120  const Int_t *pRowIndex = a.GetRowIndexArray();
121  const Int_t *pColIndex = a.GetColIndexArray();
122
123  Int_t nr_nonzeros = 0;
124  for (Int_t irow = 0; irow < nrows; irow++ ) {
125  const Int_t rown = irow+rowLwb;
126  for (Int_t index = pRowIndex[irow]; index < pRowIndex[irow+1]; index++ ) {
127  const Int_t coln = pColIndex[index]+colLwb;
128  if (coln >= rown) nr_nonzeros++;
129  }
130  }
131
132  return nr_nonzeros;
133 }
134
135 ////////////////////////////////////////////////////////////////////////////////
136 /// Static function, copying the non-zero entries in the upper triangle to
137 /// array b . User should allocate enough memory for array b .
138
140 {
141  const Int_t rowLwb = a.GetRowLwb();
142  const Int_t colLwb = a.GetColLwb();
143  const Int_t nrows = a.GetNrows();;
144  const Int_t *pRowIndex = a.GetRowIndexArray();
145  const Int_t *pColIndex = a.GetColIndexArray();
146  const Double_t *pData = a.GetMatrixArray();
147
148  Int_t nr = 0;
149  for (Int_t irow = 0; irow < nrows; irow++ ) {
150  const Int_t rown = irow+rowLwb;
151  for (Int_t index = pRowIndex[irow]; index < pRowIndex[irow+1]; index++ ) {
152  const Int_t coln = pColIndex[index]+colLwb;
153  if (coln >= rown) b[nr++] = pData[index];
154  }
155  }
156 }
157
158 ////////////////////////////////////////////////////////////////////////////////
159 /// Set matrix to be decomposed .
160
162 {
163  ResetStatus();
164
165  fA.Use(*const_cast<TMatrixDSparse *>(&a));
166  fRowLwb = fA.GetRowLwb();
167  fColLwb = fA.GetColLwb();
168  fNrows = fA.GetNrows();
170
173
174  const Int_t *rowIndex = a.GetRowIndexArray();
175  const Int_t *colIndex = a.GetColIndexArray();
176
177  Int_t nr = 0;
178  for (Int_t irow = 0; irow < fNrows; irow++ ) {
179  const Int_t rown = irow+fRowLwb;
180  for (Int_t index = rowIndex[irow]; index < rowIndex[irow+1]; index++ ) {
181  const Int_t coln = colIndex[index]+fColLwb;
182  if (coln >= rown) {
183  fRowFact[nr+1] = irow+1;
184  fColFact[nr+1] = colIndex[index]+1;
185  nr++;
186  }
187  }
188  }
189
190  fW .Set(fNrows+1);
191  fIkeep.Set(3*(fNrows+1));
192  fIw .Set((Int_t)(1.3 * (2*fNnonZeros+3*fNrows+1)+1));
193  fIw1 .Set(2*(fNrows+1));
194
195  // Determine pivot sequence, set iflag = 0 in order to make InitPivot choose the order.
196  Int_t iflag = 0;
197  Double_t ops;
199  fIcntl,fCntl,fInfo,ops);
200
201  switch ( this->ErrorFlag() ) {
202  case -1 :
203  Error("SetMatrix(const TMatrixDSparse &","nRows = %d out of range",fNrows);
204  return;
205  case -2 :
206  Error("SetMatrix(const TMatrixDSparse &","nr_nonzeros = %d out of range",fNnonZeros);
207  return;
208  case -3 :
209  Error("SetMatrix(const TMatrixDSparse &",
210  "insufficient space in fIw of %d suggest reset to %d",fIw.GetSize(),this->IError());
211  return;
212  case 1 :
213  Error("SetMatrix(const TMatrixDSparse &",
214  "detected %d entries out of rage in row/col indices; ignored",this->IError());
215  return;
216  }
217
218  // set fIw and fIw1 in prep for calls to Factor and Solve
219
220 // fIw .Set((Int_t) 1.2*this->MinRealWorkspace()+1);
221  fIw .Set((Int_t) 3*this->MinRealWorkspace()+1);
222  fIw1 .Set(fNrows+1);
223  fIw2 .Set(fNsteps+1);
224 // fFact.Set((Int_t) 1.2*this->MinRealWorkspace()+1);
225  fFact.Set((Int_t) 3*this->MinRealWorkspace()+1);
226
228 }
229
230 ////////////////////////////////////////////////////////////////////////////////
231 /// Decomposition engine .
232 /// If the decomposition succeeds, bit kDecomposed is set .
233
235 {
236  if (TestBit(kDecomposed)) return kTRUE;
237
238  if ( !TestBit(kMatrixSet) ) {
239  Error("Decompose()","Matrix has not been set");
240  return kFALSE;
241  }
242
243  Int_t done = 0; Int_t tries = 0;
244  do {
245  fFact[0] = 0.;
247
250
251  switch ( this->ErrorFlag() ) {
252  case 0 :
253  done = 1;
254  break;
255  case -1 :
256  Error("Decompose()","nRows = %d out of range",fNrows);
257  return kFALSE;
258  case -2 :
259  Error("Decompose()","nr_nonzeros = %d out of range",fNnonZeros);
260  return kFALSE;
261  case -3 :
262  {
263  if (fVerbose)
264  Info("Decompose()","insufficient space of fIw: %d",fIw.GetSize());
265  const Int_t nIw_old = fIw.GetSize();
266  const Int_t nIw = (this->IError() > fIPessimism*nIw_old) ? this->IError() :
267  (Int_t)(fIPessimism*nIw_old);
268  fIw.Set(nIw);
269  if (fVerbose)
270  Info("Decompose()","resetting to fIw: %d",nIw);
271  fIPessimism *= 1.1;
272  break;
273  }
274  case -4 :
275  {
276  if (fVerbose)
277  Info("Decompose()","insufficient factorization space: %d",fFact.GetSize());
278  const Int_t nFact_old = fFact.GetSize();
279  const Int_t nFact = (this->IError() > fRPessimism*nFact_old) ? this->IError() :
280  (Int_t) (fRPessimism*nFact_old);
281  fFact.Set(nFact); fFact.Reset(0.0);
283  if (fVerbose)
284  Info("Decompose()","reseting to: %d",nFact);
285  fRPessimism *= 1.1;
286  break;
287  }
288  case -5 :
289  if (fVerbose) {
290  Info("Decompose()","matrix apparently numerically singular");
291  Info("Decompose()","detected at stage %d",this->IError());
292  Info("Decompose()","accept this factorization and hope for the best..");
293  }
294  done = 1;
295  break;
296  case -6 :
297  if (fVerbose) {
298  Info("Decompose()","change of sign of pivots detected at stage %d",this->IError());
299  Info("Decompose()","but who cares ");
300  }
301  done = 1;
302  break;
303  case -7 :
304  Error("Decompose()","value of fNsteps out of range: %d",fNsteps);
305  return kFALSE;
306  case 1 :
307  if (fVerbose) {
308  Info("Decompose()","detected %d entries out of range in row/column index",this->IError());
309  Info("Decompose()","they are ignored");
310  }
311  done = 1;
312  break;
313  case 3 :
314  if (fVerbose)
315  Info("Decompose()","rank deficient matrix detected; apparent rank = %d",this->IError());
316  done = 1;
317  break;
318  default:
319  break;
320  }
321
322  tries++;
323  } while (!done && tries < 10);
324
325  Int_t ok;
326  if ( !done && tries >= 10) {
327  ok = kFALSE;
328  if (fVerbose)
329  Error("Decompose()","did not get a factorization after 10 tries");
330  } else {
331  ok = kTRUE;
333  }
334
335  return ok;
336 }
337
338 ////////////////////////////////////////////////////////////////////////////////
339 /// Solve Ax=b . Solution returned in b.
340
342 {
343  R__ASSERT(b.IsValid());
344  if (TestBit(kSingular)) {
345  Error("Solve()","Matrix is singular");
346  return kFALSE;
347  }
348  if ( !TestBit(kDecomposed) ) {
349  if (!Decompose()) {
350  Error("Solve()","Decomposition failed");
351  return kFALSE;
352  }
353  }
354
355  if (fNrows != b.GetNrows() || fRowLwb != b.GetLwb())
356  {
357  Error("Solve(TVectorD &","vector and matrix incompatible");
358  return kFALSE;
359  }
360  b.Shift(-fRowLwb); // make sure rowlwb = 0
361
362  // save bs and store residuals
363  TVectorD resid = b;
364  TVectorD bSave = b;
365
366  Double_t bnorm = b.NormInf();
367  Double_t rnorm = 0.0;
368
369  Int_t done = 0;
370  Int_t refactorizations = 0;
371
372  while (!done && refactorizations < 10) {
373
375
376  // compute residuals
377  resid = fA*b-resid;
378  rnorm = resid.NormInf();
379
380  if (rnorm < fPrecision*(1.+bnorm)) {
381  // residuals are small enough, use this solution
382  done = 1;
383  } else if (this->GetThresholdPivoting() >= kThresholdPivotingMax
384  || refactorizations > 10) {
385  // ThresholdPivoting parameter is already too high; give up and
386  // use this solution, whatever it is (the algorithm may bomb in
387  // an outer loop).
388  done = 1;
389  } else {
390  // refactor with a higher Threshold Pivoting parameter
391  Double_t tp = this->GetThresholdPivoting();
394  this->SetThresholdPivoting(tp);
395  if (fVerbose)
396  Info("Solve","Setting ThresholdPivoting parameter to %.4e for future factorizations",
397  this->GetThresholdPivoting());
398
399  SetMatrix(fA);
400  refactorizations++;
401  resid = bSave;
402  b = bSave;
403  }
404  }
405
406  b.Shift(fRowLwb);
407  return kTRUE;
408 }
409
410 ////////////////////////////////////////////////////////////////////////////////
411 /// initializing control parameters
412
414 {
416  fIPessimism = 1.2;
417  fRPessimism = 1.2;
418
419  const Int_t ifrlvl = 5;
420
422  fIcntl[4] = 2139062143;
423  fIcntl[5] = 1;
424  fIcntl[ifrlvl+1] = 32639;
425  fIcntl[ifrlvl+2] = 32639;
426  fIcntl[ifrlvl+3] = 32639;
427  fIcntl[ifrlvl+4] = 32639;
428  fIcntl[ifrlvl+5] = 14;
429  fIcntl[ifrlvl+6] = 9;
430  fIcntl[ifrlvl+7] = 8;
431  fIcntl[ifrlvl+8] = 8;
432  fIcntl[ifrlvl+9] = 9;
433  fIcntl[ifrlvl+10] = 10;
434  fIcntl[ifrlvl+11] = 32639;
435  fIcntl[ifrlvl+12] = 32639;
436  fIcntl[ifrlvl+13] = 32639;
437  fIcntl[ifrlvl+14] = 32689;
438  fIcntl[ifrlvl+15] = 24;
439  fIcntl[ifrlvl+16] = 11;
440  fIcntl[ifrlvl+17] = 9;
441  fIcntl[ifrlvl+18] = 8;
442  fIcntl[ifrlvl+19] = 9;
443  fIcntl[ifrlvl+20] = 10;
444  fIcntl[26] = 0;
445  fIcntl[27] = 0;
446  fIcntl[28] = 0;
447  fIcntl[29] = 0;
448  fIcntl[30] = 0;
449  fCntl[1] = 0.10;
450  fCntl[2] = 1.00;
451  fCntl[3] = 0.00;
452  fCntl[4] = 0.0;
453  fCntl[5] = 0.0;
454
455  // set initial value of "Treat As Zero" parameter
457
458  // set initial value of Threshold parameter
460
461  fNsteps = 0;
462  fMaxfrt = 0;
463  fNrows = 0;
464  fNnonZeros = 0;
465 }
466
467 ////////////////////////////////////////////////////////////////////////////////
468 /// Setup Pivoting variables
469
470 void TDecompSparse::InitPivot(const Int_t n,const Int_t nz,TArrayI &Airn,TArrayI &Aicn,
471  TArrayI &Aiw,TArrayI &Aikeep,TArrayI &Aiw1,Int_t &nsteps,
472  const Int_t iflag,Int_t *icntl,Double_t *cntl,Int_t *info,
473  Double_t &ops)
474 {
475  Int_t i,iwfr,k,l1,l2,lliw;
476
477  Int_t *irn = Airn.GetArray();
478  Int_t *icn = Aicn.GetArray();
479  Int_t *iw = Aiw.GetArray();
480  Int_t *ikeep = Aikeep.GetArray();
481  Int_t *iw1 = Aiw1.GetArray();
482  const Int_t liw = Aiw.GetSize()-1;
483
484  for (i = 1; i < 16; i++)
485  info[i] = 0;
486
487  if (icntl[3] > 0 && icntl[2] > 0) {
488  ::Info("TDecompSparse::InitPivot","Start with n = %d nz = %d liw = %d iflag = %d",n,nz,liw,iflag);
489  nsteps = 0;
490  k = TMath::Min(8,nz);
491  if (icntl[3] > 1) k = nz;
492  if (k > 0) {
493  printf("matrix non-zeros:\n");
494  for (i = 1; i < k+1; i++) {
495  printf("%d %d ",irn[i],icn[i]);
496  if (i%5 == 0 || i == k) printf("\n");
497  }
498  }
499
500  k = TMath::Min(10,n);
501  if (icntl[3] > 1) k = n;
502  if (iflag == 1 && k > 0) {
503  for (i = 1; i < k+1; i++) {
504  printf("%d ",ikeep[i]);
505  if (i%10 == 0 || i == k) printf("\n");
506  }
507  }
508  }
509
510  if (n >= 1 && n <= icntl[4]) {
511  if (nz < 0) {
512  info[1] = -2;
513  if (icntl[1] > 0)
514  ::Error("TDecompSparse::InitPivot","info[1]= %d; value of nz out of range .. = %d",info[1],nz);
515  return;
516  }
517  lliw = liw-2*n;
518  l1 = lliw+1;
519  l2 = l1+n;
520  if (iflag != 1) {
521  if (liw < 2*nz+3*n+1) {
522  info[1] = -3;
523  info[2] = 2*nz+3*n+1;
524  if (icntl[1] > 0)
525  ::Error("TDecompSparse::InitPivot","info[1]= %d; liw too small, must be increased from %d to at least %d",info[1],liw,info[2]);
526  return;
527  }
528  InitPivot_sub1(n,nz,irn,icn,iw,iw1,iw1+n+1,iw+l1-1,iwfr,icntl,info);
529  InitPivot_sub2(n,iw1,iw,lliw,iwfr,iw+l1-1,iw+l2-1,ikeep+n+1,
530  ikeep+2*(n+1),ikeep,icntl[4],info[11],cntl[2]);
531  } else {
532  if (liw < nz+3*n+1) {
533  info[1] = -3;
534  info[2] = nz+3*n+1;
535  if (icntl[1] > 0)
536  ::Error("TDecompSparse::InitPivot","info[1]= %d; liw too small, must be increased from %d to at least %d",info[1],liw,info[2]);
537  return;
538  }
539  InitPivot_sub3(n,nz,irn,icn,ikeep,iw,iw1,iw1+n+1,iw+l1-1,iwfr,icntl,info);
540  InitPivot_sub4(n,iw1,iw,lliw,iwfr,ikeep,ikeep+n+1,iw+l1-1,iw+l2-1,info[11]);
541  }
542  InitPivot_sub5(n,iw1,iw+l1-1,ikeep,ikeep+n+1,ikeep+2*(n+1),iw+l2-1,nsteps,icntl[5]);
543  if (nz >= 1) iw[1] = irn[1]+1;
544  InitPivot_sub6(n,nz,irn,icn,ikeep,ikeep+2*(n+1),ikeep+n+1,iw+l2-1,
545  nsteps,iw1,iw1+n+1,iw,info,ops);
546  } else {
547  info[1] = -1;
548  if (icntl[1] > 0)
549  ::Error("TDecompSparse::InitPivot","info[1]= %d; value of n out of range ... = %d",info[1],n);
550  return;
551  }
552
553  if (icntl[3] <= 0 || icntl[2] <= 0) return;
554
555  printf("Leaving with nsteps =%d info(1)=%d ops=%14.5e ierror=%d\n",nsteps,info[1],ops,info[2]);
557  info[3],info[4],info[5],info[6],info[7],info[8],info[11]);
558
559  k = TMath::Min(9,n);
560  if (icntl[3] > 1) k = n;
561  if (k > 0) {
562  printf("ikeep[0][.]=\n");
563  for (i = 1; i < k+1; i++) {
564  printf("%d ",ikeep[i]);
565  if (k%10 == 0 || i == k) printf("\n");
566  }
567  }
568  k = TMath::Min(k,nsteps);
569  if (k > 0) {
570  printf("ikeep[2][.]=\n");
571  for (i = 1; i < k+1; i++) {
572  printf("%d ",ikeep[2*(n+1)+i]);
573  if (k%10 == 0 || i == k) printf("\n");
574  }
575  }
576 }
577
578 ////////////////////////////////////////////////////////////////////////////////
579 /// Factorization routine, the workhorse for the decomposition step
580
581 void TDecompSparse::Factor(const Int_t n,const Int_t nz,TArrayI &Airn,TArrayI &Aicn,TArrayD &Aa,
582  TArrayI &Aiw,TArrayI &Aikeep,const Int_t nsteps,Int_t &maxfrt,
583  TArrayI &Aiw1,Int_t *icntl,Double_t *cntl,Int_t *info)
584 {
585  Int_t i,iapos,iblk,ipos,irows,j1,j2,jj,k,kblk,kz,len,ncols,nrows,nz1;
586
587  Int_t *irn = Airn.GetArray();
588  Int_t *icn = Aicn.GetArray();
589  Int_t *iw = Aiw.GetArray();
590  Int_t *ikeep = Aikeep.GetArray();
591  Int_t *iw1 = Aiw1.GetArray();
592  Double_t *a = Aa.GetArray();
593
594  const Int_t la = Aa.GetSize()-1;
595  const Int_t liw = Aiw.GetSize()-1;
596
597  info[1] = 0;
598  if (icntl[3] > 0 && icntl[2] > 0) {
599  printf("entering Factor with n=%d nz=%d la=%d liw=%d nsteps=%d u=%10.2e\n",
600  n,nz,la,liw,nsteps,cntl[1]);
601  kz = TMath::Min(6,nz);
602  if (icntl[3] > 1) kz = nz;
603  if (nz > 0) {
604  printf("matrix non-zeros:\n");
605  for (i = 1; i < kz+1; i++) {
606  printf("%16.3e %d %d ",a[i],irn[i],icn[i]);
607  if (i%2 == 0 || i==kz) printf("\n");
608  }
609  }
610  k = TMath::Min(9,n);
611  if (icntl[3] > 1) k = n;
612  if (k > 0) {
613  printf("ikeep(0,.)=\n");
614  for (i = 1; i < k+1; i++) {
615  printf("%d ",ikeep[i]);
616  if (i%10 == 0 || i == k) printf("\n");
617  }
618  }
619  k = TMath::Min(k,nsteps);
620  if (k > 0) {
621  printf("ikeep(1,.)=\n");
622  for (i = 1; i < k+1; i++) {
623  printf("%d ",ikeep[n+1+i]);
624  if (i%10 == 0 || i == k) printf("\n");
625  }
626  printf("ikeep(2,.)=\n");
627  for (i = 1; i < k+1; i++) {
628  printf("%d ",ikeep[2*(n+1)+i]);
629  if (i%10 == 0 || i == k) printf("\n");
630  }
631  }
632  }
633
634  if (n < 1 || n > icntl[4])
635  info[1] = -1;
636  else if (nz < 0)
637  info[1] = -2;
638  else if (liw < nz) {
639  info[1] = -3;
640  info[2] = nz;
641  } else if (la < nz+n) {
642  info[1] = -4;
643  info[2] = nz+n;
644  } else if (nsteps < 1 || nsteps > n)
645  info[1] = -7;
646  else {
647  Factor_sub1(n,nz,nz1,a,la,irn,icn,iw,liw,ikeep,iw1,icntl,info);
648  if (info[1] != -3 && info[1] != -4) {
649  Factor_sub2(n,nz1,a,la,iw,liw,ikeep,ikeep+2*(n+1),nsteps,maxfrt,ikeep+n+1,iw1,icntl,cntl,info);
650  if (info[1] == 3 && icntl[2] > 0)
651  ::Warning("TDecompSparse::Factor","info[1]= %d; matrix is singular. rank=%d",info[1],info[2]);
652  }
653  }
654
655  if (icntl[1] > 0) {
656  switch(info[1]) {
657  case -1:
658  ::Error("TDecompSparse::Factor","info[1]= %d; value of n out of range ... =%d",info[1],n);
659  break;
660
661  case -2:
662  ::Error("TDecompSparse::Factor","info[1]= %d; value of nz out of range ... =%d",info[1],nz);
663  break;
664
665  case -3:
666  ::Error("TDecompSparse::Factor","info[1]= %d; liw too small, must be increased from %d to at least %d",info[1],liw,info[2]);
667  break;
668
669  case -4:
670  ::Error("TDecompSparse::Factor","info[1]= %d; la too small, must be increased from %d to at least %d",info[1],la,info[2]);
671  break;
672
673  case -5:
674  ::Error("TDecompSparse::Factor","info[1]= %d; zero pivot at stage %d zero pivot at stage",info[1],info[2]);
675  break;
676
677  case -6:
678  ::Error("TDecompSparse::Factor","info[1]= %d; change in sign of pivot encountered when factoring allegedly definite matrix",info[1]);
679  break;
680
681  case -7:
682  ::Error("TDecompSparse::Factor","info[1]= %d; nsteps is out of range",info[1]);
683  break;
684  }
685  }
686
687  if (icntl[3] <= 0 || icntl[2] <= 0 || info[1] < 0)
688  return;
689
690  ::Info("TDecompSparse::Factor","leaving Factor with maxfrt=%d info[1]=%d nrlbdu=%d nirbdu=%d ncmpbr=%d ncmpbi=%d ntwo=%d ierror=%d",
691  maxfrt,info[1],info[9],info[10],info[12],info[13],info[14],info[2]);
692
693  if (info[1] < 0) return;
694
695  kblk = TMath::Abs(iw[1]+0);
696  if (kblk == 0) return;
697  if (icntl[3] == 1) kblk = 1;
698  ipos = 2;
699  iapos = 1;
700
701  for (iblk = 1; iblk < kblk+1; iblk++) {
702  ncols = iw[ipos];
703  nrows = iw[ipos+1];
704  j1 = ipos+2;
705  if (ncols <= 0) {
706  ncols = -ncols;
707  nrows = 1;
708  j1 = j1-1;
709  }
710  ::Info("TDecompSparse::Factor","block pivot =%d nrows =%d ncols =%d",iblk,nrows,ncols);
711  j2 = j1+ncols-1;
712  ipos = j2+1;
713
714  printf(" column indices =\n");
715  for (jj = j1; jj < j2+1; jj++) {
716  printf("%d ",iw[jj]);
717  if (jj%10 == 0 || jj == j2) printf("\n");
718  }
719
720  printf(" real entries .. each row starts on a new line\n");
721  len = ncols;
722  for (irows = 1; irows < nrows+1; irows++) {
723  j1 = iapos;
724  j2 = iapos+len-1;
725  for (jj = j1; jj < j2+1; jj++) {
726  printf("%13.4e ",a[jj]);
727  if (jj%5 == 0 || jj == j2) printf("\n");
728  }
729  len = len-1;
730  iapos = j2+1;
731  }
732  }
733 }
734
735 ////////////////////////////////////////////////////////////////////////////////
736 /// Main routine for solving Ax=b
737
739  TArrayD &Aw,const Int_t maxfrt,TVectorD &b,TArrayI &Aiw1,
740  const Int_t nsteps,Int_t *icntl,Int_t *info)
741 {
742  Int_t i,iapos,iblk,ipos,irows,j1,j2,jj,k,kblk,latop,len,nblk,ncols,nrows;
743
744  Double_t *a = Aa.GetArray();
745  Double_t *w = Aw.GetArray();
746  Int_t *iw = Aiw.GetArray();
747  Int_t *iw1 = Aiw1.GetArray();
748  Double_t *rhs = new Double_t[n+1];
749  rhs[0] = 0.;
750  memcpy(rhs+1,b.GetMatrixArray(),n*sizeof(Double_t));
751  const Int_t la = Aa.GetSize()-1;
752  const Int_t liw = Aiw.GetSize()-1;
753
754  info[1] = 0;
755  k = 0;
756  if (icntl[3] > 0 && icntl[2] > 0) {
757  printf("nentering Solve with n=%d la=%d liw=%d maxfrt=%d nsteps=%d",n,la,liw,maxfrt,nsteps);
758
759  kblk = TMath::Abs(iw[1]+0);
760  if (kblk != 0) {
761  if (icntl[3] == 1) kblk = 1;
762  ipos = 2;
763  iapos = 1;
764  for (iblk = 1; iblk < kblk+1; iblk++) {
765  ncols = iw[ipos];
766  nrows = iw[ipos+1];
767  j1 = ipos+2;
768  if (ncols <= 0) {
769  ncols = -ncols;
770  nrows = 1;
771  j1 = j1-1;
772  }
773  printf("block pivot=%d nrows=%d ncols=%d\n",iblk,nrows,ncols);
774  j2 = j1+ncols-1;
775  ipos = j2+1;
776  printf("column indices =\n");
777  for (jj = j1; jj < j2+1; jj++) {
778  printf("%d ",iw[jj]);
779  if (jj%10 == 0 || jj == j2) printf("\n");
780  }
781  printf("real entries .. each row starts on a new line\n");
782  len = ncols;
783  for (irows = 1; irows < nrows+1; irows++) {
784  j1 = iapos;
785  j2 = iapos+len-1;
786  for (jj = j1; jj < j2+1; jj++) {
787  printf("%13.3e ",a[jj]);
788  if (jj%5 == 0 || jj == j2) printf("\n");
789  }
790  len = len-1;
791  iapos = j2+1;
792  }
793  }
794  }
795
796  k = TMath::Min(10,n);
797  if (icntl[3] > 1) k = n;
798  if (n > 0) {
799  printf("rhs =\n");
800  for (i = 1; i < k+1; i++) {
801  printf("%13.3e ",rhs[i]);
802  if (i%5 == 0 || i == k) printf("\n");
803  }
804  }
805  }
806
807  nblk = 0;
808  if (iw[1] == 0) {
809  nblk = 0;
810  for (i = 1; i < n+1; i++)
811  rhs[i] = 0.0;
812  } else {
813  nblk = (iw[1] <= 0) ? -iw[1] : iw[1];
814  Solve_sub1(n,a,iw+1,w,rhs,iw1,nblk,latop,icntl);
815  Solve_sub2(n,a,iw+1,w,rhs,iw1,nblk,latop,icntl);
816  }
817
818  if (icntl[3] > 0 && icntl[2] > 0) {
819  printf("leaving Solve with:\n");
820  if (n > 0) {
821  printf("rhs =\n");
822  for (i = 1; i < k+1; i++) {
823  printf("%13.3e ",rhs[i]);
824  if (i%5 == 0 || i == k) printf("\n");
825  }
826  }
827  }
828
829  memcpy(b.GetMatrixArray(),rhs+1,n*sizeof(Double_t));
830  delete [] rhs;
831 }
832
833 ////////////////////////////////////////////////////////////////////////////////
834 /// Help routine for pivoting setup
835
836 void TDecompSparse::InitPivot_sub1(const Int_t n,const Int_t nz,Int_t *irn,Int_t *icn,
837  Int_t *iw,Int_t *ipe,Int_t *iq,Int_t *flag,
838  Int_t &iwfr,Int_t *icntl,Int_t *info)
839 {
840  Int_t i,id,j,jn,k,k1,k2,l,last,lr,n1,ndup;
841
842  info[2] = 0;
843  for (i = 1; i < n+1; i++)
844  ipe[i] = 0;
845  lr = nz;
846
847  if (nz != 0) {
848  for (k = 1; k < nz+1; k++) {
849  i = irn[k];
850  j = icn[k];
851
852  Bool_t outRange = (i < 1 || i > n || j < 1 || j > n);
853  if (outRange) {
854  info[2] = info[2]+1;
855  info[1] = 1;
856  if (info[2] <= 1 && icntl[2]> 0)
857  ::Warning("TDecompSparse::InitPivot_sub1","info[1]= %d; %d th non-zero (in row=%d and column=%d) ignored",info[1],k,i,j);
858  }
859
860  if (outRange || i == j) {
861  i = 0;
862  j = 0;
863  } else {
864  ipe[i] = ipe[i]+1;
865  ipe[j] = ipe[j]+1;
866  }
867  iw[k] = j;
868  lr = lr+1;
869  iw[lr] = i;
870  }
871  }
872
873  iq[1] = 1;
874  n1 = n-1;
875  if (n1 > 0) {
876  for (i = 1; i < n1+1; i++) {
877  flag[i] = 0;
878  if (ipe[i] == 0) ipe[i] = -1;
879  iq[i+1] = ipe[i]+iq[i]+1;
880  ipe[i] = iq[i];
881  }
882  }
883
884  last = ipe[n]+iq[n];
885  flag[n] = 0;
886  if (lr < last) {
887  k1 = lr+1;
888  for (k = k1; k < last+1; k++)
889  iw[k] = 0;
890  }
891  ipe[n] = iq[n];
892  iwfr = last+1;
893  if (nz != 0) {
894  for (k = 1; k < nz+1; k++) {
895  j = iw[k];
896  if (j <= 0) continue;
897  l = k;
898  iw[k] = 0;
899  for (id = 1; id < nz+1; id++) {
900  if (l <= nz)
901  l = l+nz;
902  else
903  l = l-nz;
904  i = iw[l];
905  iw[l] = 0;
906  if (i >= j) {
907  l = iq[j]+1;
908  iq[j] = l;
909  jn = iw[l];
910  iw[l] = -i;
911  } else {
912  l = iq[i]+1;
913  iq[i] = l;
914  jn = iw[l];
915  iw[l] = -j;
916  }
917  j = jn;
918  if (j <= 0) break;
919  }
920  }
921  }
922
923  ndup = 0;
924
925  for (i = 1; i < n+1; i++) {
926  k1 = ipe[i]+1;
927  k2 = iq[i];
928  if (k1 > k2) {
929  ipe[i] = 0;
930  iq[i] = 0;
931  } else {
932  for (k = k1; k < k2+1; k++) {
933  j = -iw[k];
934  if (j <= 0) break;
935  l = iq[j]+1;
936  iq[j] = l;
937  iw[l] = i;
938  iw[k] = j;
939  if (flag[j] == i) {
940  ndup = ndup + 1;
941  iw[l] = 0;
942  iw[k] = 0;
943  }
944  flag[j] = i;
945  }
946
947  iq[i] = iq[i]-ipe[i];
948  if (ndup == 0) iw[k1-1] = iq[i];
949  }
950  }
951
952  if (ndup != 0) {
953  iwfr = 1;
954  for (i = 1; i < n+1; i++) {
955  k1 = ipe[i]+1;
956  if (k1 == 1) continue;
957  k2 = iq[i]+ipe[i];
958  l = iwfr;
959  ipe[i] = iwfr;
960  iwfr = iwfr+1;
961  for (k = k1; k < k2+1; k++) {
962  if (iw[k] == 0) continue;
963  iw[iwfr] = iw[k];
964  iwfr = iwfr+1;
965  }
966  iw[l] = iwfr-l-1;
967  }
968  }
969
970 }
971
972 ////////////////////////////////////////////////////////////////////////////////
973 /// Help routine for pivoting setup
974
975 void TDecompSparse::InitPivot_sub2(const Int_t n,Int_t *ipe,Int_t *iw,const Int_t lw,
976  Int_t &iwfr,Int_t *nv,Int_t *nxt,Int_t *lst,Int_t *ipd,
977  Int_t *flag,const Int_t iovflo,Int_t &ncmpa,
978  const Double_t fratio)
979 {
980  Int_t i,id,idl,idn,ie,ip,is,jp,jp1,jp2,js,k,k1,k2,ke,kp,kp0,kp1,
981  kp2,ks,l,len,limit,ln,ls,lwfr,md,me,ml,ms,nel,nflg,np,
982  np0,ns,nvpiv,nvroot,root;
983
984  for (i = 1; i < n+1; i++) {
985  ipd[i] = 0;
986  nv[i] = 1;
987  flag[i] = iovflo;
988  }
989
990  js = 0;
991  ms = 0;
992  ncmpa = 0;
993  md = 1;
994  nflg = iovflo;
995  nel = 0;
996  root = n+1;
997  nvroot = 0;
998  for (is = 1; is < n+1; is++) {
999  k = ipe[is];
1000  if (k > 0) {
1001  id = iw[k]+1;
1002  ns = ipd[id];
1003  if (ns > 0) lst[ns] = is;
1004  nxt[is] = ns;
1005  ipd[id] = is;
1006  lst[is] = -id;
1007  } else {
1008  nel = nel+1;
1009  flag[is] = -1;
1010  nxt[is] = 0;
1011  lst[is] = 0;
1012  }
1013  }
1014
1015  for (ml = 1; ml < n+1; ml++) {
1016  if (nel+nvroot+1 >= n) break;
1017  for (id = md; id < n+1; id++) {
1018  ms = ipd[id];
1019  if (ms > 0) break;
1020  }
1021
1022  md = id;
1023  nvpiv = nv[ms];
1024  ns = nxt[ms];
1025  nxt[ms] = 0;
1026  lst[ms] = 0;
1027  if (ns > 0) lst[ns] = -id;
1028  ipd[id] = ns;
1029  me = ms;
1030  nel = nel+nvpiv;
1031  idn = 0;
1032  kp = ipe[me];
1033  flag[ms] = -1;
1034  ip = iwfr;
1035  len = iw[kp];
1036  jp = 0;
1037  for (kp1 = 1; kp1 < len+1; kp1++) {
1038  kp = kp+1;
1039  ke = iw[kp];
1040  if (flag[ke] > -2) {
1041  if (flag[ke] <= 0) {
1042  if (ipe[ke] != -root) continue;
1043  ke = root;
1044  if (flag[ke] <= 0) continue;
1045  }
1046  jp = kp-1;
1047  ln = len-kp1+1;
1048  ie = ms;
1049  } else {
1050  ie = ke;
1051  jp = ipe[ie];
1052  ln = iw[jp];
1053  }
1054
1055  for (jp1 = 1; jp1 < ln+1; jp1++) {
1056  jp = jp+1;
1057  is = iw[jp];
1058  if (flag[is] <= 0) {
1059  if (ipe[is] == -root) {
1060  is = root;
1061  iw[jp] = root;
1062  if (flag[is] <= 0) continue;
1063  } else
1064  continue;
1065  }
1066  flag[is] = 0;
1067  if (iwfr >= lw) {
1068  ipe[ms] = kp;
1069  iw[kp] = len-kp1;
1070  ipe[ie] = jp;
1071  iw[jp] = ln-jp1;
1072  InitPivot_sub2a(n,ipe,iw,ip-1,lwfr,ncmpa);
1073  jp2 = iwfr-1;
1074  iwfr = lwfr;
1075  if (ip <= jp2) {
1076  for (jp = ip; jp < jp2+1; jp++) {
1077  iw[iwfr] = iw[jp];
1078  iwfr = iwfr+1;
1079  }
1080  }
1081  ip = lwfr;
1082  jp = ipe[ie];
1083  kp = ipe[me];
1084  }
1085  iw[iwfr] = is;
1086  idn = idn+nv[is];
1087  iwfr = iwfr+1;
1088  ls = lst[is];
1089  lst[is] = 0;
1090  ns = nxt[is];
1091  nxt[is] = 0;
1092  if (ns > 0) lst[ns] = ls;
1093  if (ls < 0) {
1094  ls = -ls;
1095  ipd[ls] = ns;
1096  } else if (ls > 0)
1097  nxt[ls] = ns;
1098  }
1099
1100  if (ie == ms)
1101  break;
1102  ipe[ie] = -me;
1103  flag[ie] = -1;
1104  }
1105
1106  nv[ms] = idn+nvpiv;
1107  if (iwfr != ip) {
1108  k1 = ip;
1109  k2 = iwfr-1;
1110  limit = TMath::Nint(fratio*(n-nel));
1111
1112  for (k = k1; k < k2+1; k++) {
1113  is = iw[k];
1114  if (is == root) continue;
1115  if (nflg <= 2) {
1116  for (i = 1; i < n+1; i++) {
1117  if (flag[i] > 0) flag[i] = iovflo;
1118  if (flag[i] <= -2) flag[i] = -iovflo;
1119  }
1120  nflg = iovflo;
1121  }
1122  nflg = nflg-1;
1123  id = idn;
1124  kp1 = ipe[is]+1;
1125  np = kp1;
1126  kp2 = iw[kp1-1]+kp1-1;
1127
1128  Int_t skip = 0;
1129  for (kp = kp1; kp < kp2+1; kp++) {
1130  ke = iw[kp];
1131  if (flag[ke] == -1) {
1132  if (ipe[ke] != -root) continue;
1133  ke = root;
1134  iw[kp] = root;
1135  if (flag[ke] == -1) continue;
1136  }
1137  if (flag[ke] >= 0) {
1138  skip = 1;
1139  break;
1140  }
1141  jp1 = ipe[ke]+1;
1142  jp2 = iw[jp1-1]+jp1-1;
1143  idl = id;
1144  for (jp = jp1; jp < jp2+1; jp++) {
1145  js = iw[jp];
1146  if (flag[js] <= nflg) continue;
1147  id = id+nv[js];
1148  flag[js] = nflg;
1149  }
1150  if (id <= idl) {
1151  Int_t skip2 = 0;
1152  for (jp = jp1; jp < jp2+1; jp++) {
1153  js = iw[jp];
1154  if (flag[js] != 0) {
1155  skip2 = 1;
1156  break;
1157  }
1158  }
1159  if (skip2) {
1160  iw[np] = ke;
1161  flag[ke] = -nflg;
1162  np = np+1;
1163  } else {
1164  ipe[ke] = -me;
1165  flag[ke] = -1;
1166  }
1167  } else {
1168  iw[np] = ke;
1169  flag[ke] = -nflg;
1170  np = np+1;
1171  }
1172  }
1173
1174  if (!skip)
1175  np0 = np;
1176  else {
1177  np0 = np;
1178  kp0 = kp;
1179  for (kp = kp0; kp < kp2+1; kp++) {
1180  ks = iw[kp];
1181  if (flag[ks] <= nflg) {
1182  if (ipe[ks] == -root) {
1183  ks = root;
1184  iw[kp] = root;
1185  if (flag[ks] <= nflg) continue;
1186  } else
1187  continue;
1188  }
1189  id = id+nv[ks];
1190  flag[ks] = nflg;
1191  iw[np] = ks;
1192  np = np+1;
1193  }
1194  }
1195
1196  Int_t doit = 2;
1197  if (id < limit) {
1198  iw[np] = iw[np0];
1199  iw[np0] = iw[kp1];
1200  iw[kp1] = me;
1201  iw[kp1-1] = np-kp1+1;
1202  js = ipd[id];
1203  for (l = 1; l < n+1; l++) {
1204  if (js <= 0) {
1205  doit = 3;
1206  break;
1207  }
1208  kp1 = ipe[js]+1;
1209  if (iw[kp1] != me) {
1210  doit = 3;
1211  break;
1212  }
1213  kp2 = kp1-1+iw[kp1-1];
1214  Int_t stayInLoop = 0;
1215  for (kp = kp1; kp < kp2+1; kp++) {
1216  ie = iw[kp];
1217  if (TMath::Abs(flag[ie]+0) > nflg) {
1218  stayInLoop = 1;
1219  break;
1220  }
1221  }
1222  if (!stayInLoop) {
1223  doit = 1;
1224  break;
1225  }
1226  js = nxt[js];
1227  }
1228  }
1229
1230  if (doit == 1) {
1231  ipe[js] = -is;
1232  nv[is] = nv[is]+nv[js];
1233  nv[js] = 0;
1234  flag[js] = -1;
1235  ns = nxt[js];
1236  ls = lst[js];
1237  if (ns > 0) lst[ns] = is;
1238  if (ls > 0) nxt[ls] = is;
1239  lst[is] = ls;
1240  nxt[is] = ns;
1241  lst[js] = 0;
1242  nxt[js] = 0;
1243  if (ipd[id] == js) ipd[id] = is;
1244  } else if (doit == 2) {
1245  if (nvroot == 0) {
1246  root = is;
1247  ipe[is] = 0;
1248  } else {
1249  iw[k] = root;
1250  ipe[is] = -root;
1251  nv[root] = nv[root]+nv[is];
1252  nv[is] = 0;
1253  flag[is] = -1;
1254  }
1255  nvroot = nv[root];
1256  } else if (doit == 3) {
1257  ns = ipd[id];
1258  if (ns > 0) lst[ns] = is;
1259  nxt[is] = ns;
1260  ipd[id] = is;
1261  lst[is] = -id;
1262  md = TMath::Min(md,id);
1263  }
1264  }
1265
1266  for (k = k1; k < k2+1; k++) {
1267  is = iw[k];
1268  if (nv[is] == 0) continue;
1269  flag[is] = nflg;
1270  iw[ip] = is;
1271  ip = ip+1;
1272  }
1273  iwfr = k1;
1274  flag[me] = -nflg;
1275  iw[ip] = iw[k1];
1276  iw[k1] = ip-k1;
1277  ipe[me] = k1;
1278  iwfr = ip+1;
1279  } else
1280  ipe[me] = 0;
1281  }
1282
1283  for (is = 1; is < n+1; is++) {
1284  if (nxt[is] != 0 || lst[is] != 0) {
1285  if (nvroot == 0) {
1286  root = is;
1287  ipe[is] = 0;
1288  } else {
1289  ipe[is] = -root;
1290  }
1291  nvroot = nvroot+nv[is];
1292  nv[is] = 0;
1293  }
1294  }
1295
1296  for (ie = 1; ie < n+1; ie++)
1297  if (ipe[ie] > 0) ipe[ie] = -root;
1298
1299  if (nvroot> 0) nv[root] = nvroot;
1300 }
1301
1302 ////////////////////////////////////////////////////////////////////////////////
1303 /// Help routine for pivoting setup
1304
1306  Int_t &iwfr,Int_t &ncmpa)
1307 {
1308  Int_t i,ir,k,k1,k2,lwfr;
1309
1310  ncmpa = ncmpa+1;
1311  for (i = 1; i < n+1; i++) {
1312  k1 = ipe[i];
1313  if (k1 <= 0) continue;
1314  ipe[i] = iw[k1];
1315  iw[k1] = -i;
1316  }
1317
1318  iwfr = 1;
1319  lwfr = iwfr;
1320  for (ir = 1; ir < n+1; ir++) {
1321  if (lwfr > lw) break;
1322  Int_t skip = 1;
1323  for (k = lwfr; k < lw+1; k++) {
1324  if (iw[k] < 0) {
1325  skip = 0;
1326  break;
1327  }
1328  }
1329  if (skip) break;
1330  i = -iw[k];
1331  iw[iwfr] = ipe[i];
1332  ipe[i] = iwfr;
1333  k1 = k+1;
1334  k2 = k+iw[iwfr];
1335  iwfr = iwfr+1;
1336  if (k1 <= k2) {
1337  for (k = k1; k < k2+1; k++) {
1338  iw[iwfr] = iw[k];
1339  iwfr = iwfr+1;
1340  }
1341  }
1342  lwfr = k2+1;
1343  }
1344 }
1345
1346 ////////////////////////////////////////////////////////////////////////////////
1347 /// Help routine for pivoting setup
1348
1349 void TDecompSparse::InitPivot_sub3(const Int_t n,const Int_t nz,Int_t *irn,Int_t *icn,
1350  Int_t *perm,Int_t *iw,Int_t *ipe,Int_t *iq,
1351  Int_t *flag,Int_t &iwfr,Int_t *icntl,Int_t *info)
1352 {
1353  Int_t i,id,in,j,jdummy,k,k1,k2,l,lbig,len;
1354
1355  info[1] = 0;
1356  info[2] = 0;
1357  for (i = 1; i < n+1; i++)
1358  iq[i] = 0;
1359
1360  if (nz != 0) {
1361  for (k = 1; k < nz+1; k++) {
1362  i = irn[k];
1363  j = icn[k];
1364  iw[k] = -i;
1365
1366  Bool_t outRange = (i < 1 || i > n || j < 1 || j > n);
1367  if (outRange) {
1368  info[2] = info[2]+1;
1369  info[1] = 1;
1370  if (info[2] <= 1 && icntl[2] > 0)
1371  ::Warning("TDecompSparse::InitPivot_sub3","info[1]= %d; %d 'th non-zero (in row %d and column %d) ignored",info[1],k,i,j);
1372  }
1373
1374  if (outRange || i==j) {
1375  iw[k] = 0;
1376  } else {
1377  if (perm[j] <= perm[i])
1378  iq[j] = iq[j]+1;
1379  else
1380  iq[i] = iq[i]+1;
1381  }
1382  }
1383  }
1384
1385  iwfr = 1;
1386  lbig = 0;
1387  for (i = 1; i < n+1; i++) {
1388  l = iq[i];
1389  lbig = TMath::Max(l,lbig);
1390  iwfr = iwfr+l;
1391  ipe[i] = iwfr-1;
1392  }
1393
1394  if (nz != 0) {
1395  for (k = 1; k < nz+1; k++) {
1396  i = -iw[k];
1397  if (i <= 0) continue;
1398  l = k;
1399  iw[k] = 0;
1400  for (id = 1; id < nz+1; id++) {
1401  j = icn[l];
1402  if (perm[i] >= perm[j]) {
1403  l = ipe[j];
1404  ipe[j] = l-1;
1405  in = iw[l];
1406  iw[l] = i;
1407  } else {
1408  l = ipe[i];
1409  ipe[i] = l-1;
1410  in = iw[l];
1411  iw[l] = j;
1412  }
1413  i = -in;
1414  if (i <= 0) continue;
1415  }
1416  }
1417
1418  k = iwfr-1;
1419  l = k+n;
1420  iwfr = l+1;
1421  for (i = 1; i < n+1; i++) {
1422  flag[i] = 0;
1423  j = n+1-i;
1424  len = iq[j];
1425  if (len > 0) {
1426  for (jdummy = 1; jdummy < len+1; jdummy++) {
1427  iw[l] = iw[k];
1428  k = k-1;
1429  l = l-1;
1430  }
1431  }
1432  ipe[j] = l;
1433  l = l-1;
1434  }
1435
1436  if (lbig < icntl[4]) {
1437  for (i = 1; i < n+1; i++) {
1438  k = ipe[i];
1439  iw[k] = iq[i];
1440  if (iq[i] == 0) ipe[i] = 0;
1441  }
1442  } else {
1443  iwfr = 1;
1444  for (i = 1; i < n+1; i++) {
1445  k1 = ipe[i]+1;
1446  k2 = ipe[i]+iq[i];
1447  if (k1 > k2) {
1448  ipe[i] = 0;
1449  } else {
1450  ipe[i] = iwfr;
1451  iwfr = iwfr+1;
1452  for (k = k1; k < k2+1; k++) {
1453  j = iw[k];
1454  if (flag[j] == i) continue;
1455  iw[iwfr] = j;
1456  iwfr = iwfr+1;
1457  flag[j] = i;
1458  }
1459  k = ipe[i];
1460  iw[k] = iwfr-k-1;
1461  }
1462  }
1463  }
1464  }
1465
1466 }
1467
1468 ////////////////////////////////////////////////////////////////////////////////
1469 /// Help routine for pivoting setup
1470
1471 void TDecompSparse::InitPivot_sub4(const Int_t n,Int_t *ipe,Int_t *iw,const Int_t lw,
1472  Int_t &iwfr,Int_t *ips,Int_t *ipv,Int_t *nv,Int_t *flag,
1473  Int_t &ncmpa)
1474 {
1475  Int_t i,ie,ip,j,je,jp,jp1,jp2,js,kdummy,ln,lwfr,me,minjs,ml,ms;
1476
1477  for (i = 1; i < n+1; i++) {
1478  flag[i] = 0;
1479  nv[i] = 0;
1480  j = ips[i];
1481  ipv[j] = i;
1482  }
1483
1484  ncmpa = 0;
1485  for (ml = 1; ml < n+1; ml++) {
1486  ms = ipv[ml];
1487  me = ms;
1488  flag[ms] = me;
1489  ip = iwfr;
1490  minjs = n;
1491  ie = me;
1492
1493  for (kdummy = 1; kdummy < n+1; kdummy++) {
1494  jp = ipe[ie];
1495  ln = 0;
1496  if (jp > 0) {
1497  ln = iw[jp];
1498  for (jp1 = 1; jp1 < ln+1; jp1++) {
1499  jp = jp+1;
1500  js = iw[jp];
1501  if (flag[js] == me) continue;
1502  flag[js] = me;
1503  if (iwfr >= lw) {
1504  ipe[ie] = jp;
1505  iw[jp] = ln-jp1;
1506  InitPivot_sub2a(n,ipe,iw,ip-1,lwfr,ncmpa);
1507  jp2 = iwfr-1;
1508  iwfr = lwfr;
1509  if (ip <= jp2) {
1510  for (jp = ip; jp < jp2+1; jp++) {
1511  iw[iwfr] = iw[jp];
1512  iwfr = iwfr+1;
1513  }
1514  }
1515  ip = lwfr;
1516  jp = ipe[ie];
1517  }
1518  iw[iwfr] = js;
1519  minjs = TMath::Min(minjs,ips[js]+0);
1520  iwfr = iwfr+1;
1521  }
1522  }
1523  ipe[ie] = -me;
1524  je = nv[ie];
1525  nv[ie] = ln+1;
1526  ie = je;
1527  if (ie == 0) break;
1528  }
1529
1530  if (iwfr <= ip) {
1531  ipe[me] = 0;
1532  nv[me] = 1;
1533  } else {
1534  minjs = ipv[minjs];
1535  nv[me] = nv[minjs];
1536  nv[minjs] = me;
1537  iw[iwfr] = iw[ip];
1538  iw[ip] = iwfr-ip;
1539  ipe[me] = ip;
1540  iwfr = iwfr+1;
1541  }
1542  }
1543 }
1544
1545 ////////////////////////////////////////////////////////////////////////////////
1546 /// Help routine for pivoting setup
1547
1549  Int_t *na,Int_t *nd,Int_t &nsteps,const Int_t nemin)
1550 {
1551  Int_t i,ib,iff,il,is,ison,k,l,nr;
1552
1553  il = 0;
1554  for (i = 1; i < n+1; i++) {
1555  ips[i] = 0;
1556  ne[i] = 0;
1557  }
1558  for (i = 1; i < n+1; i++) {
1559  if (nv[i] > 0) continue;
1560  iff = -ipe[i];
1561  is = -ips[iff];
1562  if (is > 0) ipe[i] = is;
1563  ips[iff] = -i;
1564  }
1565
1566  nr = n+1;
1567  for (i = 1; i < n+1; i++) {
1568  if (nv[i] <= 0) continue;
1569  iff = -ipe[i];
1570  if (iff != 0) {
1571  is = -ips[iff];
1572  if (is > 0)
1573  ipe[i] = is;
1574  ips[iff] = -i;
1575  } else {
1576  nr = nr-1;
1577  ne[nr] = i;
1578  }
1579  }
1580
1581  is = 1;
1582  i = 0;
1583  for (k = 1; k < n+1; k++) {
1584  if (i <= 0) {
1585  i = ne[nr];
1586  ne[nr] = 0;
1587  nr = nr+1;
1588  il = n;
1589  na[n] = 0;
1590  }
1591  for (l = 1; l < n+1; l++) {
1592  if (ips[i] >= 0) break;
1593  ison = -ips[i];
1594  ips[i] = 0;
1595  i = ison;
1596  il = il-1;
1597  na[il] = 0;
1598  }
1599
1600  ips[i] = k;
1601  ne[is] = ne[is]+1;
1602  if (nv[i] > 0) {
1603  if (il < n) na[il+1] = na[il+1]+1;
1604  na[is] = na[il];
1605  nd[is] = nv[i];
1606
1607  Bool_t doit = (na[is] == 1 && (nd[is-1]-ne[is-1] == nd[is])) ||
1608  (na[is] != 1 && ne[is] < nemin && na[is] != 0 && ne[is-1] < nemin);
1609
1610  if (doit) {
1611  na[is-1] = na[is-1]+na[is]-1;
1612  nd[is-1] = nd[is]+ne[is-1];
1613  ne[is-1] = ne[is]+ne[is-1];
1614  ne[is] = 0;
1615  } else {
1616  is = is+1;
1617  }
1618  }
1619
1620  ib = ipe[i];
1621  if (ib >= 0) {
1622  if (ib > 0)
1623  na[il] = 0;
1624  i = ib;
1625  } else {
1626  i = -ib;
1627  il = il+1;
1628  }
1629  }
1630
1631  nsteps = is-1;
1632 }
1633
1634 ////////////////////////////////////////////////////////////////////////////////
1635 /// Help routine for pivoting setup
1636
1637 void TDecompSparse::InitPivot_sub6(const Int_t n,const Int_t nz,Int_t *irn,Int_t *icn,
1638  Int_t *perm,Int_t *na,Int_t *ne,Int_t *nd,const Int_t nsteps,
1639  Int_t *lstki,Int_t *lstkr,Int_t *iw,Int_t *info,Double_t &ops)
1640 {
1641  Int_t i,inew,iold,iorg,irow,istki,istkr,itop,itree,jold,jorg,k,lstk,nassr,nelim,nfr,nstk,
1643  Double_t delim;
1644
1645  if (nz != 0 && irn[1] == iw[1]) {
1646  irn[1] = iw[1]-1;
1647  nz2 = 0;
1648  for (iold = 1; iold < n+1; iold++) {
1649  inew = perm[iold];
1650  lstki[inew] = lstkr[iold]+1;
1651  nz2 = nz2+lstkr[iold];
1652  }
1653  nz1 = nz2/2+n;
1654  nz2 = nz2+n;
1655  } else {
1656  for (i = 1; i < n+1; i++)
1657  lstki[i] = 1;
1658  nz1 = n;
1659  if (nz != 0) {
1660  for (i = 1; i < nz+1; i++) {
1661  iold = irn[i];
1662  jold = icn[i];
1663  if (iold < 1 || iold > n) continue;
1664  if (jold < 1 || jold > n) continue;
1665  if (iold == jold) continue;
1666  nz1 = nz1+1;
1667  irow = TMath::Min(perm[iold]+0,perm[jold]+0);
1668  lstki[irow] = lstki[irow]+1;
1669  }
1670  }
1671  nz2 = nz1;
1672  }
1673
1674  ops = 0.0;
1675  istki = 0;
1676  istkr = 0;
1679  nirtot = nz1;
1680  nrltot = nz1;
1681  nirnec = nz2;
1682  nrlnec = nz2;
1683  numorg = 0;
1684  itop = 0;
1685  for (itree = 1; itree < nsteps+1; itree++) {
1686  nelim = ne[itree];
1687  delim = Double_t(nelim);
1688  nfr = nd[itree];
1689  nstk = na[itree];
1690  nassr = nfr*(nfr+1)/2;
1691  if (nstk != 0) nassr = nassr-lstkr[itop]+1;
1696  for (iorg = 1; iorg < nelim+1; iorg++) {
1697  jorg = numorg+iorg;
1698  nz2 = nz2-lstki[jorg];
1699  }
1700  numorg = numorg+nelim;
1701  if (nstk > 0) {
1702  for (k = 1; k < nstk+1; k++) {
1703  lstk = lstkr[itop];
1704  istkr = istkr-lstk;
1705  lstk = lstki[itop];
1706  istki = istki-lstk;
1707  itop = itop-1;
1708  }
1709  }
1713  ops = ops+((nfr*delim*(nfr+1)-(2*nfr+1)*delim*(delim+1)/2+delim*(delim+1)*(2*delim+1)/6)/2);
1714  if (itree == nsteps || nfr == nelim) continue;
1715  itop = itop+1;
1716  lstkr[itop] = (nfr-nelim)* (nfr-nelim+1)/2;
1717  lstki[itop] = nfr-nelim+1;
1718  istki = istki+lstki[itop];
1719  istkr = istkr+lstkr[itop];
1722  }
1723
1724  nrlnec = TMath::Max(nrlnec,n+TMath::Max(nz,nz1));
1725  nrltot = TMath::Max(nrltot,n+TMath::Max(nz,nz1));
1726  nrlnec = TMath::Min(nrlnec,nrltot);
1727  nirnec = TMath::Max(nz,nirnec);
1728  nirtot = TMath::Max(nz,nirtot);
1729  nirnec = TMath::Min(nirnec,nirtot);
1730  info[3] = nrltot;
1731  info[4] = nirtot;
1732  info[5] = nrlnec;
1733  info[6] = nirnec;
1736 }
1737
1738 ////////////////////////////////////////////////////////////////////////////////
1739 /// Help routine for factorization
1740
1742  const Int_t la,Int_t *irn,Int_t *icn,Int_t *iw,const Int_t liw,
1743  Int_t *perm,Int_t *iw2,Int_t *icntl,Int_t *info)
1744 {
1745  Int_t i,ia,ich,ii,iiw,inew,iold,ipos,j1,j2,jj,jnew,jold,jpos,k;
1746  Double_t anext,anow;
1747
1748  const Double_t zero = 0.0;
1749  info[1] = 0;
1750  ia = la;
1751  for (iold = 1; iold < n+1; iold++) {
1752  iw2[iold] = 1;
1753  a[ia] = zero;
1754  ia = ia-1;
1755  }
1756
1757  info[2] = 0;
1758  nz1 = n;
1759  if (nz != 0) {
1760  for (k = 1; k < nz+1; k++) {
1761  iold = irn[k];
1762  jold = icn[k];
1763  Bool_t outRange = (iold < 1 || iold > n || jold < 1 || jold > n);
1764
1765  inew = perm[iold];
1766  jnew = perm[jold];
1767
1768  if (!outRange && inew == jnew) {
1769  ia = la-n+iold;
1770  a[ia] = a[ia]+a[k];
1771  iw[k] = 0;
1772  } else {
1773  if (!outRange) {
1774  inew = TMath::Min(inew,jnew);
1775  iw2[inew] = iw2[inew]+1;
1776  iw[k] = -iold;
1777  nz1 = nz1+1;
1778  } else {
1779  info[1] = 1;
1780  info[2] = info[2]+1;
1781  if (info[2] <= 1 && icntl[2] > 0)
1782  ::Warning("TDecompSparse::Factor_sub1","info[1]= %d; %d 'th non-zero (in row %d and column %d) ignored",
1783  info[1],k,irn[k],icn[k]);
1784  iw[k] = 0;
1785  }
1786  }
1787  }
1788  }
1789
1790  if (nz >= nz1 || nz1 == n) {
1791  k = 1;
1792  for (i = 1; i < n+1; i++) {
1793  k = k+iw2[i];
1794  iw2[i] = k;
1795  }
1796  } else {
1797  k = 1;
1798  for (i = 1; i < n+1; i++) {
1799  k = k+iw2[i]-1;
1800  iw2[i] = k;
1801  }
1802  }
1803
1804  if (nz1 > liw) {
1805  info[1] = -3;
1806  info[2] = nz1;
1807  return;
1808  }
1809
1810  if (nz1+n > la) {
1811  info[1] = -4;
1812  info[2] = nz1+n;
1813  return;
1814  }
1815
1816  if (nz1 != n) {
1817  for (k = 1; k < nz+1; k++) {
1818  iold = -iw[k];
1819  if (iold <= 0) continue;
1820  jold = icn[k];
1821  anow = a[k];
1822  iw[k] = 0;
1823  for (ich = 1; ich < nz+1; ich++) {
1824  inew = perm[iold];
1825  jnew = perm[jold];
1826  inew = TMath::Min(inew,jnew);
1827  if (inew == perm[jold]) jold = iold;
1828  jpos = iw2[inew]-1;
1829  iold = -iw[jpos];
1830  anext = a[jpos];
1831  a[jpos] = anow;
1832  iw[jpos] = jold;
1833  iw2[inew] = jpos;
1834  if (iold == 0) break;
1835  anow = anext;
1836  jold = icn[jpos];
1837  }
1838  }
1839
1840  if (nz < nz1) {
1841  ipos = nz1;
1842  jpos = nz1-n;
1843  for (ii = 1; ii < n+1; ii++) {
1844  i = n-ii+1;
1845  j1 = iw2[i];
1846  j2 = jpos;
1847  if (j1 <= jpos) {
1848  for (jj = j1; jj < j2+1; jj++) {
1849  iw[ipos] = iw[jpos];
1850  a[ipos] = a[jpos];
1851  ipos = ipos-1;
1852  jpos = jpos-1;
1853  }
1854  }
1855  iw2[i] = ipos+1;
1856  ipos = ipos-1;
1857  }
1858  }
1859  }
1860
1861  for (iold = 1; iold < n+1; iold++) {
1862  inew = perm[iold];
1863  jpos = iw2[inew]-1;
1864  ia = la-n+iold;
1865  a[jpos] = a[ia];
1866  iw[jpos] = -iold;
1867  }
1868  ipos = nz1;
1869  ia = la;
1870  iiw = liw;
1871  for (i = 1; i < nz1+1; i++) {
1872  a[ia] = a[ipos];
1873  iw[iiw] = iw[ipos];
1874  ipos = ipos-1;
1875  ia = ia-1;
1876  iiw = iiw-1;
1877  }
1878 }
1879
1880 ////////////////////////////////////////////////////////////////////////////////
1881 /// Help routine for factorization
1882
1883 void TDecompSparse::Factor_sub2(const Int_t n,const Int_t nz,Double_t *a,const Int_t la,
1884  Int_t *iw,const Int_t liw,Int_t *perm,Int_t *nstk,
1885  const Int_t nsteps,Int_t &maxfrt,Int_t *nelim,Int_t *iw2,
1886  Int_t *icntl,Double_t *cntl,Int_t *info)
1887 {
1888  Double_t amax,amult,amult1,amult2,detpiv,rmax,swop,thresh,tmax,uu;
1889  Int_t ainput,apos,apos1,apos2,apos3,astk,astk2,azero,i,iass;
1890  Int_t ibeg,idummy,iell,iend,iexch,ifr,iinput,ioldps,iorg,ipiv;
1891  Int_t ipmnp,ipos,irow,isnpiv,istk,istk2,iswop,iwpos,j,j1;
1892  Int_t j2,jcol,jdummy,jfirst,jj,jj1,jjj,jlast,jmax,jmxmip,jnew;
1893  Int_t jnext,jpiv,jpos,k,k1,k2,kdummy,kk,kmax,krow,laell,lapos2;
1894  Int_t liell,lnass,lnpiv,lt,ltopst,nass,nblk,newel,nfront,npiv;
1895  Int_t npivp1,ntotpv,numass,numorg,numstk,pivsiz,posfac,pospv1,pospv2;
1896  Int_t ntwo,neig,ncmpbi,ncmpbr,nrlbdu,nirbdu;
1897
1898  const Double_t zero = 0.0;
1899  const Double_t half = 0.5;
1900  const Double_t one = 1.0;
1901
1902  detpiv = 0.0;
1903  apos3 = 0;
1904  isnpiv = 0;
1905  jmax = 0;
1906  jpos = 0;
1907
1908  nblk = 0;
1909  ntwo = 0;
1910  neig = 0;
1911  ncmpbi = 0;
1912  ncmpbr = 0;
1913  maxfrt = 0;
1914  nrlbdu = 0;
1915  nirbdu = 0;
1916  uu = TMath::Min(cntl[1],half);
1917  uu = TMath::Max(uu,-half);
1918  for (i = 1; i < n+1; i++)
1919  iw2[i] = 0;
1920  iwpos = 2;
1921  posfac = 1;
1922  istk = liw-nz+1;
1923  istk2 = istk-1;
1924  astk = la-nz+1;
1925  astk2 = astk-1;
1926  iinput = istk;
1927  ainput = astk;
1928  azero = 0;
1929  ntotpv = 0;
1930  numass = 0;
1931
1932  for (iass = 1; iass < nsteps+1; iass++) {
1933  nass = nelim[iass];
1934  newel = iwpos+1;
1935  jfirst = n+1;
1936  nfront = 0;
1937  numstk = nstk[iass];
1938  ltopst = 1;
1939  lnass = 0;
1940  if (numstk != 0) {
1941  j2 = istk-1;
1942  lnass = nass;
1943  ltopst = ((iw[istk]+1)*iw[istk])/2;
1944  for (iell = 1; iell < numstk+1; iell++) {
1945  jnext = jfirst;
1946  jlast = n+1;
1947  j1 = j2+2;
1948  j2 = j1-1+iw[j1-1];
1949  for (jj = j1; jj < j2+1; jj++) {
1950  j = iw[jj];
1951  if (iw2[j] > 0) continue;
1952  jnew = perm[j];
1953  if (jnew <= numass) nass = nass+1;
1954  for (idummy = 1; idummy < n+1; idummy++) {
1955  if (jnext == n+1) break;
1956  if (perm[jnext] > jnew) break;
1957  jlast = jnext;
1958  jnext = iw2[jlast];
1959  }
1960  if (jlast == n+1)
1961  jfirst = j;
1962  else
1963  iw2[jlast] = j;
1964  iw2[j] = jnext;
1965  jlast = j;
1966  nfront = nfront+1;
1967  }
1968  }
1969  lnass = nass-lnass;
1970  }
1971
1972  numorg = nelim[iass];
1973  j1 = iinput;
1974  for (iorg = 1; iorg < numorg+1; iorg++) {
1975  j = -iw[j1];
1976  for (idummy = 1; idummy < liw+1; idummy++) {
1977  jnew = perm[j];
1978  if (iw2[j] <= 0) {
1979  jlast = n+1;
1980  jnext = jfirst;
1981  for (jdummy = 1; jdummy < n+1; jdummy++) {
1982  if (jnext == n+1) break;
1983  if (perm[jnext] > jnew) break;
1984  jlast = jnext;
1985  jnext = iw2[jlast];
1986  }
1987  if (jlast == n+1)
1988  jfirst = j;
1989  else
1990  iw2[jlast] = j;
1991  iw2[j] = jnext;
1992  nfront = nfront+1;
1993  }
1994  j1 = j1+1;
1995  if (j1 > liw) break;
1996  j = iw[j1];
1997  if (j < 0) break;
1998  }
1999  }
2000
2001  if (newel+nfront >= istk)
2002  Factor_sub3(a,iw,istk,istk2,iinput,2,ncmpbr,ncmpbi);
2003  if (newel+nfront >= istk) {
2004  info[1] = -3;
2005  info[2] = liw+1+newel+nfront-istk;
2006  goto finish;
2007  }
2008
2009  j = jfirst;
2010  for (ifr = 1; ifr < nfront+1; ifr++) {
2011  newel = newel+1;
2012  iw[newel] = j;
2013  jnext = iw2[j];
2014  iw2[j] = newel-(iwpos+1);
2015  j = jnext;
2016  }
2017
2018  maxfrt = TMath::Max(maxfrt,nfront);
2019  iw[iwpos] = nfront;
2020  laell = ((nfront+1)*nfront)/2;
2021  apos2 = posfac+laell-1;
2022  if (numstk != 0) lnass = lnass*(2*nfront-lnass+1)/2;
2023
2024  if (posfac+lnass-1 >= astk || apos2 >= astk+ltopst-1) {
2025  Factor_sub3(a,iw,astk,astk2,ainput,1,ncmpbr,ncmpbi);
2026  if (posfac+lnass-1 >= astk || apos2 >= astk+ltopst-1) {
2027  info[1] = -4;
2028  info[2] = la+TMath::Max(posfac+lnass,apos2-ltopst+2)-astk;
2029  goto finish;
2030  }
2031  }
2032
2033  if (apos2 > azero) {
2034  apos = azero+1;
2035  lapos2 = TMath::Min(apos2,astk-1);
2036  if (lapos2 >= apos) {
2037  for (k= apos; k< lapos2+1; k++)
2038  a[k] = zero;
2039  }
2040  azero = apos2;
2041  }
2042
2043  if (numstk != 0) {
2044  for (iell = 1; iell < numstk+1; iell++) {
2045  j1 = istk+1;
2046  j2 = istk+iw[istk];
2047  for (jj = j1; jj < j2+1; jj++) {
2048  irow = iw[jj];
2049  irow = iw2[irow];
2050  apos = posfac+IDiag(nfront,irow);
2051  for (jjj = jj; jjj < j2+1; jjj++) {
2052  j = iw[jjj];
2053  apos2 = apos+iw2[j]-irow;
2054  a[apos2] = a[apos2]+a[astk];
2055  a[astk] = zero;
2056  astk = astk+1;
2057  }
2058  }
2059  istk = j2+1;
2060  }
2061  }
2062
2063  for (iorg = 1; iorg < numorg+1; iorg++) {
2064  j = -iw[iinput];
2065  irow = iw2[j];
2066  apos = posfac+IDiag(nfront,irow);
2067  for (idummy = 1; idummy < nz+1; idummy++) {
2068  apos2 = apos+iw2[j]-irow;
2069  a[apos2] = a[apos2]+a[ainput];
2070  ainput = ainput+1;
2071  iinput = iinput+1;
2072  if (iinput > liw) break;
2073  j = iw[iinput];
2074  if (j < 0) break;
2075  }
2076  }
2077  numass = numass+numorg;
2078  j1 = iwpos+2;
2079  j2 = iwpos+nfront+1;
2080  for (k = j1; k < j2+1; k++) {
2081  j = iw[k];
2082  iw2[j] = 0;
2083  }
2084
2085  lnpiv = -1;
2086  npiv = 0;
2087  for (kdummy = 1; kdummy < nass+1; kdummy++) {
2088  if (npiv == nass) break;
2089  if (npiv == lnpiv) break;
2090  lnpiv = npiv;
2091  npivp1 = npiv+1;
2092  jpiv = 1;
2093  for (ipiv = npivp1; ipiv < nass+1; ipiv++) {
2094  jpiv = jpiv-1;
2095  if (jpiv == 1) continue;
2096  apos = posfac+IDiag(nfront-npiv,ipiv-npiv);
2097
2098  if (uu <= zero) {
2099  if (TMath::Abs(a[apos]) <= cntl[3]) {
2100  info[1] = -5;
2101  info[2] = ntotpv+1;
2102  goto finish;
2103  }
2104  if (ntotpv <= 0) {
2105  if (a[apos] > zero) isnpiv = 1;
2106  if (a[apos] < zero) isnpiv = -1;
2107  }
2108  if ((a[apos] <= zero || isnpiv != 1) && (a[apos] >= zero || isnpiv != -1)) {
2109  if (info[1] != 2) info[2] = 0;
2110  info[2] = info[2]+1;
2111  info[1] = 2;
2112  i = ntotpv+1;
2113  if (icntl[2] > 0 && info[2] <= 10)
2114  ::Warning("TDecompSparse::Factor_sub2","info[1]= %d; pivot %d has different sign from the previous one",
2115  info[1],i);
2116  isnpiv = -isnpiv;
2117  }
2118  if ((a[apos] > zero && isnpiv == 1) || (a[apos] < zero && isnpiv == -1) || (uu == zero)) goto hack;
2119  info[1] = -6;
2120  info[2] = ntotpv+1;
2121  goto finish;
2122  }
2123
2124  amax = zero;
2125  tmax = amax;
2126  j1 = apos+1;
2127  j2 = apos+nass-ipiv;
2128  if (j2 >= j1) {
2129  for (jj = j1; jj < j2+1; jj++) {
2130  if (TMath::Abs(a[jj]) <= amax) continue;
2131  jmax = ipiv+jj-j1+1;
2132  amax = TMath::Abs(a[jj]);
2133  }
2134  }
2135  j1 = j2+1;
2136  j2 = apos+nfront-ipiv;
2137  if (j2 >= j1) {
2138  for (jj = j1; jj < j2+1; jj++)
2139  tmax = TMath::Max(TMath::Abs(a[jj]),tmax);
2140  }
2141  rmax = TMath::Max(tmax,amax);
2142  apos1 = apos;
2143  kk = nfront-ipiv;
2144  lt = ipiv-(npiv+1);
2145  if (lt != 0) {
2146  for (k = 1; k < lt+1; k++) {
2147  kk = kk+1;
2148  apos1 = apos1-kk;
2149  rmax = TMath::Max(rmax,TMath::Abs(a[apos1]));
2150  }
2151  }
2152  if (TMath::Abs(a[apos]) <= TMath::Max(cntl[3],uu*rmax)) {
2153  if (TMath::Abs(amax) <= cntl[3]) continue;
2154  apos2 = posfac+IDiag(nfront-npiv,jmax-npiv);
2155  detpiv = a[apos]*a[apos2]-amax*amax;
2156  thresh = TMath::Abs(detpiv);
2157  thresh = thresh/(uu*TMath::Max(TMath::Abs(a[apos])+amax,TMath::Abs(a[apos2])+amax));
2158  if (thresh <= rmax) continue;
2159  rmax = zero;
2160  j1 = apos2+1;
2161  j2 = apos2+nfront-jmax;
2162  if (j2 >= j1) {
2163  for (jj = j1; jj < j2+1; jj++)
2164  rmax = TMath::Max(rmax,TMath::Abs(a[jj]));
2165  }
2166  kk = nfront-jmax+1;
2167  apos3 = apos2;
2168  jmxmip = jmax-ipiv-1;
2169  if (jmxmip != 0) {
2170  for (k = 1; k < jmxmip+1; k++) {
2171  apos2 = apos2-kk;
2172  kk = kk+1;
2173  rmax = TMath::Max(rmax,TMath::Abs(a[apos2]));
2174  }
2175  }
2176  ipmnp = ipiv-npiv-1;
2177  if (ipmnp != 0) {
2178  apos2 = apos2-kk;
2179  kk = kk+1;
2180  for (k = 1; k < ipmnp+1; k++) {
2181  apos2 = apos2-kk;
2182  kk = kk+1;
2183  rmax = TMath::Max(rmax,TMath::Abs(a[apos2]));
2184  }
2185  }
2186  if (thresh <= rmax) continue;
2187  pivsiz = 2;
2188  } else {
2189  pivsiz = 1;
2190  }
2191
2192  irow = ipiv-npiv;
2193  for (krow = 1; krow < pivsiz+1; krow++) {
2194  if (irow != 1) {
2195  j1 = posfac+irow;
2196  j2 = posfac+nfront-(npiv+1);
2197  if (j2 >= j1) {
2198  apos2 = apos+1;
2199  for (jj = j1; jj < j2+1; jj++) {
2200  swop = a[apos2];
2201  a[apos2] = a[jj];
2202  a[jj] = swop;
2203  apos2 = apos2+1;
2204  }
2205  }
2206  j1 = posfac+1;
2207  j2 = posfac+irow-2;
2208  apos2 = apos;
2209  kk = nfront-(irow+npiv);
2210  if (j2 >= j1) {
2211  for (jjj = j1; jjj < j2+1; jjj++) {
2212  jj = j2-jjj+j1;
2213  kk = kk+1;
2214  apos2 = apos2-kk;
2215  swop = a[apos2];
2216  a[apos2] = a[jj];
2217  a[jj] = swop;
2218  }
2219  }
2220  if (npiv != 0) {
2221  apos1 = posfac;
2222  kk = kk+1;
2223  apos2 = apos2-kk;
2224  for (jj = 1; jj < npiv+1; jj++) {
2225  kk = kk+1;
2226  apos1 = apos1-kk;
2227  apos2 = apos2-kk;
2228  swop = a[apos2];
2229  a[apos2] = a[apos1];
2230  a[apos1] = swop;
2231  }
2232  }
2233  swop = a[apos];
2234  a[apos] = a[posfac];
2235  a[posfac] = swop;
2236  ipos = iwpos+npiv+2;
2237  iexch = iwpos+irow+npiv+1;
2238  iswop = iw[ipos];
2239  iw[ipos] = iw[iexch];
2240  iw[iexch] = iswop;
2241  }
2242  if (pivsiz == 1) continue;
2243  if (krow != 2) {
2244  irow = jmax-(npiv+1);
2245  jpos = posfac;
2246  posfac = posfac+nfront-npiv;
2247  npiv = npiv+1;
2248  apos = apos3;
2249  } else {
2250  npiv = npiv-1;
2251  posfac = jpos;
2252  }
2253  }
2254
2255  if (pivsiz != 2) {
2256 hack:
2257  a[posfac] = one/a[posfac];
2258  if (a[posfac] < zero) neig = neig+1;
2259  j1 = posfac+1;
2260  j2 = posfac+nfront-(npiv+1);
2261  if (j2 >= j1) {
2262  ibeg = j2+1;
2263  for (jj = j1; jj < j2+1; jj++) {
2264  amult = -a[jj]*a[posfac];
2265  iend = ibeg+nfront-(npiv+jj-j1+2);
2266  for (irow = ibeg; irow < iend+1; irow++) {
2267  jcol = jj+irow-ibeg;
2268  a[irow] = a[irow]+amult*a[jcol];
2269  }
2270  ibeg = iend+1;
2271  a[jj] = amult;
2272  }
2273  }
2274  npiv = npiv+1;
2275  ntotpv = ntotpv+1;
2276  jpiv = 1;
2277  posfac = posfac+nfront-npiv+1;
2278  } else {
2279  ipos = iwpos+npiv+2;
2280  ntwo = ntwo+1;
2281  iw[ipos] = -iw[ipos];
2282  pospv1 = posfac;
2283  pospv2 = posfac+nfront-npiv;
2284  swop = a[pospv2];
2285  if (detpiv < zero) neig = neig+1;
2286  if (detpiv > zero && swop < zero) neig = neig+2;
2287  a[pospv2] = a[pospv1]/detpiv;
2288  a[pospv1] = swop/detpiv;
2289  a[pospv1+1] = -a[pospv1+1]/detpiv;
2290  j1 = pospv1+2;
2291  j2 = pospv1+nfront-(npiv+1);
2292  if (j2 >= j1) {
2293  jj1 = pospv2;
2294  ibeg = pospv2+nfront-(npiv+1);
2295  for (jj = j1; jj < j2+1; jj++) {
2296  jj1 = jj1+1;
2297  amult1 =-(a[pospv1]*a[jj]+a[pospv1+1]*a[jj1]);
2298  amult2 =-(a[pospv1+1]*a[jj]+a[pospv2]*a[jj1]);
2299  iend = ibeg+nfront-(npiv+jj-j1+3);
2300  for (irow = ibeg; irow < iend+1; irow++) {
2301  k1 = jj+irow-ibeg;
2302  k2 = jj1+irow-ibeg;
2303  a[irow] = a[irow]+amult1*a[k1]+amult2*a[k2];
2304  }
2305  ibeg = iend+1;
2306  a[jj] = amult1;
2307  a[jj1] = amult2;
2308  }
2309  }
2310  npiv = npiv+2;
2311  ntotpv = ntotpv+2;
2312  jpiv = 2;
2313  posfac = pospv2+nfront-npiv+1;
2314  }
2315  }
2316  }
2317
2318  if (npiv != 0) nblk = nblk+1;
2319  ioldps = iwpos;
2320  iwpos = iwpos+nfront+2;
2321  if (npiv != 0) {
2322  if (npiv <= 1) {
2323  iw[ioldps] = -iw[ioldps];
2324  for (k = 1; k < nfront+1; k++) {
2325  j1 = ioldps+k;
2326  iw[j1] = iw[j1+1];
2327  }
2328  iwpos = iwpos-1;
2329  } else {
2330  iw[ioldps+1] = npiv;
2331  }
2332  }
2333  liell = nfront-npiv;
2334
2335  if (liell != 0 && iass != nsteps) {
2336  if (iwpos+liell >= istk)
2337  Factor_sub3(a,iw,istk,istk2,iinput,2,ncmpbr,ncmpbi);
2338  istk = istk-liell-1;
2339  iw[istk] = liell;
2340  j1 = istk;
2341  kk = iwpos-liell-1;
2342  for (k = 1; k < liell+1; k++) {
2343  j1 = j1+1;
2344  kk = kk+1;
2345  iw[j1] = iw[kk];
2346  }
2347  laell = ((liell+1)*liell)/2;
2348  kk = posfac+laell;
2349  if (kk == astk) {
2350  astk = astk-laell;
2351  } else {
2352  kmax = kk-1;
2353  for (k = 1; k < laell+1; k++) {
2354  kk = kk-1;
2355  astk = astk-1;
2356  a[astk] = a[kk];
2357  }
2358  kmax = TMath::Min(kmax,astk-1);
2359  for ( k = kk; k < kmax+1; k++)
2360  a[k] = zero;
2361  }
2362  azero = TMath::Min(azero,astk-1);
2363  }
2364  if (npiv == 0) iwpos = ioldps;
2365  }
2366
2367  iw[1] = nblk;
2368  if (ntwo > 0) iw[1] = -nblk;
2369  nrlbdu = posfac-1;
2370  nirbdu = iwpos-1;
2371
2372  if (ntotpv != n) {
2373  info[1] = 3;
2374  info[2] = ntotpv;
2375  }
2376
2377 finish:
2378  info[9] = nrlbdu;
2379  info[10] = nirbdu;
2380  info[12] = ncmpbr;
2381  info[13] = ncmpbi;
2382  info[14] = ntwo;
2383  info[15] = neig;
2384 }
2385
2386 ////////////////////////////////////////////////////////////////////////////////
2387 /// Help routine for factorization
2388
2390  const Int_t ireal,Int_t &ncmpbr,Int_t &ncmpbi)
2391 {
2392  Int_t ipos,jj,jjj;
2393
2394  ipos = itop-1;
2395  if (j2 != ipos) {
2396  if (ireal != 2) {
2397  ncmpbr = ncmpbr+1;
2398  if (j1 <= j2) {
2399  for (jjj = j1; jjj < j2+1; jjj++) {
2400  jj = j2-jjj+j1;
2401  a[ipos] = a[jj];
2402  ipos = ipos-1;
2403  }
2404  }
2405  } else {
2406  ncmpbi = ncmpbi+1;
2407  if (j1 <= j2) {
2408  for (jjj = j1; jjj < j2+1; jjj++) {
2409  jj = j2-jjj+j1;
2410  iw[ipos] = iw[jj];
2411  ipos = ipos-1;
2412  }
2413  }
2414  }
2415  j2 = itop-1;
2416  j1 = ipos+1;
2417  }
2418 }
2419
2420 ////////////////////////////////////////////////////////////////////////////////
2421 /// Help routine for solving
2422
2424  Double_t *rhs,Int_t *iw2,const Int_t nblk,Int_t &latop,
2425  Int_t *icntl)
2426 {
2427  Int_t apos,iblk,ifr,ilvl,ipiv,ipos,irhs,irow,ist,j,j1=0,j2,j3,jj,jpiv,k,k1,k2,k3,liell,npiv;
2428  Double_t w1,w2;
2429
2430  const Int_t ifrlvl = 5;
2431
2432  apos = 1;
2433  ipos = 1;
2434  j2 = 0;
2435  iblk = 0;
2436  npiv = 0;
2437  for (irow = 1; irow < n+1; irow++) {
2438  if (npiv <= 0) {
2439  iblk = iblk+1;
2440  if (iblk > nblk) break;
2441  ipos = j2+1;
2442  iw2[iblk] = ipos;
2443  liell = -iw[ipos];
2444  npiv = 1;
2445  if (liell <= 0) {
2446  liell = -liell;
2447  ipos = ipos+1;
2448  npiv = iw[ipos];
2449  }
2450  j1 = ipos+1;
2451  j2 = ipos+liell;
2452  ilvl = TMath::Min(npiv,10);
2453  if (liell < icntl[ifrlvl+ilvl]) goto hack;
2454  ifr = 0;
2455  for (jj = j1; jj < j2+1; jj++) {
2456  j = TMath::Abs(iw[jj]+0);
2457  ifr = ifr+1;
2458  w[ifr] = rhs[j];
2459  }
2460  jpiv = 1;
2461  j3 = j1;
2462
2463  for (ipiv = 1; ipiv < npiv+1; ipiv++) {
2464  jpiv = jpiv-1;
2465  if (jpiv == 1) continue;
2466
2467  if (iw[j3] >= 0) {
2468  jpiv = 1;
2469  j3 = j3+1;
2470  apos = apos+1;
2471  ist = ipiv+1;
2472  if (liell< ist) continue;
2473  w1 = w[ipiv];
2474  k = apos;
2475  for (j = ist; j < liell+1; j++) {
2476  w[j] = w[j]+a[k]*w1;
2477  k = k+1;
2478  }
2479  apos = apos+liell-ist+1;
2480  } else {
2481  jpiv = 2;
2482  j3 = j3+2;
2483  apos = apos+2;
2484  ist = ipiv+2;
2485  if (liell >= ist) {
2486  w1 = w[ipiv];
2487  w2 = w[ipiv+1];
2488  k1 = apos;
2489  k2 = apos+liell-ipiv;
2490  for (j = ist; j < liell+1; j++) {
2491  w[j] = w[j]+w1*a[k1]+w2*a[k2];
2492  k1 = k1+1;
2493  k2 = k2+1;
2494  }
2495  }
2496  apos = apos+2*(liell-ist+1)+1;
2497  }
2498  }
2499
2500  ifr = 0;
2501  for (jj = j1; jj < j2+1; jj++) {
2502  j = TMath::Abs(iw[jj]+0);
2503  ifr = ifr+1;
2504  rhs[j] = w[ifr];
2505  }
2506  npiv = 0;
2507  } else {
2508 hack:
2509  if (iw[j1] >= 0) {
2510  npiv = npiv-1;
2511  apos = apos+1;
2512  j1 = j1+1;
2513  if (j1 <= j2) {
2514  irhs = iw[j1-1];
2515  w1 = rhs[irhs];
2516  k = apos;
2517  for (j = j1; j < j2+1; j++) {
2518  irhs = TMath::Abs(iw[j]+0);
2519  rhs[irhs] = rhs[irhs]+a[k]*w1;
2520  k = k+1;
2521  }
2522  }
2523  apos = apos+j2-j1+1;
2524  } else {
2525  npiv = npiv-2;
2526  j1 = j1+2;
2527  apos = apos+2;
2528  if (j1 <= j2) {
2529  irhs = -iw[j1-2];
2530  w1 = rhs[irhs];
2531  irhs = iw[j1-1];
2532  w2 = rhs[irhs];
2533  k1 = apos;
2534  k3 = apos+j2-j1+2;
2535  for (j = j1; j < j2+1; j++) {
2536  irhs = TMath::Abs(iw[j]+0);
2537  rhs[irhs] = rhs[irhs]+w1*a[k1]+w2*a[k3];
2538  k1 = k1+1;
2539  k3 = k3+1;
2540  }
2541  }
2542  apos = apos+2*(j2-j1+1)+1;
2543  }
2544  }
2545  }
2546
2547  latop = apos-1;
2548 }
2549
2550 ////////////////////////////////////////////////////////////////////////////////
2551 /// Help routine for solving
2552
2554  Double_t *rhs,Int_t *iw2,const Int_t nblk,
2555  const Int_t latop,Int_t *icntl)
2556 {
2557  Int_t apos,apos2,i1rhs,i2rhs,iblk,ifr,iipiv,iirhs,ilvl,ipiv,ipos,irhs,ist,
2558  j,j1=0,j2=0,jj,jj1,jj2,jpiv,jpos=0,k,liell,loop,npiv;
2559  Double_t w1,w2;
2560
2561  const Int_t ifrlvl = 5;
2562
2563  apos = latop+1;
2564  npiv = 0;
2565  iblk = nblk+1;
2566  for (loop = 1; loop < n+1; loop++) {
2567  if (npiv <= 0) {
2568  iblk = iblk-1;
2569  if (iblk < 1) break;
2570  ipos = iw2[iblk];
2571  liell = -iw[ipos];
2572  npiv = 1;
2573  if (liell <= 0) {
2574  liell = -liell;
2575  ipos = ipos+1;
2576  npiv = iw[ipos];
2577  }
2578  jpos = ipos+npiv;
2579  j2 = ipos+liell;
2580  ilvl = TMath::Min(10,npiv)+10;
2581  if (liell < icntl[ifrlvl+ilvl]) goto hack;
2582  j1 = ipos+1;
2583  ifr = 0;
2584  for (jj = j1; jj < j2+1; jj++) {
2585  j = TMath::Abs(iw[jj]+0);
2586  ifr = ifr+1;
2587  w[ifr] = rhs[j];
2588  }
2589  jpiv = 1;
2590  for (iipiv = 1; iipiv < npiv+1; iipiv++) {
2591  jpiv = jpiv-1;
2592  if (jpiv == 1) continue;
2593  ipiv = npiv-iipiv+1;
2594  if (ipiv == 1 || iw[jpos-1] >= 0) {
2595  jpiv = 1;
2596  apos = apos-(liell+1-ipiv);
2597  ist = ipiv+1;
2598  w1 = w[ipiv]*a[apos];
2599  if (liell >= ist) {
2600  jj1 = apos+1;
2601  for (j = ist; j < liell+1; j++) {
2602  w1 = w1+a[jj1]*w[j];
2603  jj1 = jj1+1;
2604  }
2605  }
2606  w[ipiv] = w1;
2607  jpos = jpos-1;
2608  } else {
2609  jpiv = 2;
2610  apos2 = apos-(liell+1-ipiv);
2611  apos = apos2-(liell+2-ipiv);
2612  ist = ipiv+1;
2613  w1 = w[ipiv-1]*a[apos]+w[ipiv]*a[apos+1];
2614  w2 = w[ipiv-1]*a[apos+1]+w[ipiv]*a[apos2];
2615  if (liell >= ist) {
2616  jj1 = apos+2;
2617  jj2 = apos2+1;
2618  for (j = ist; j < liell+1; j++) {
2619  w1 = w1+w[j]*a[jj1];
2620  w2 = w2+w[j]*a[jj2];
2621  jj1 = jj1+1;
2622  jj2 = jj2+1;
2623  }
2624  }
2625  w[ipiv-1] = w1;
2626  w[ipiv] = w2;
2627  jpos = jpos-2;
2628  }
2629  }
2630  ifr = 0;
2631  for (jj = j1; jj < j2+1; jj++) {
2632  j = TMath::Abs(iw[jj]+0);
2633  ifr = ifr+1;
2634  rhs[j] = w[ifr];
2635  }
2636  npiv = 0;
2637  } else {
2638 hack:
2639  if (npiv == 1 || iw[jpos-1] >= 0) {
2640  npiv = npiv-1;
2641  apos = apos-(j2-jpos+1);
2642  iirhs = iw[jpos];
2643  w1 = rhs[iirhs]*a[apos];
2644  j1 = jpos+1;
2645  if (j1 <= j2) {
2646  k = apos+1;
2647  for (j = j1; j < j2+1; j++) {
2648  irhs = TMath::Abs(iw[j]+0);
2649  w1 = w1+a[k]*rhs[irhs];
2650  k = k+1;
2651  }
2652  }
2653  rhs[iirhs] = w1;
2654  jpos = jpos-1;
2655  } else {
2656  npiv = npiv-2;
2657  apos2 = apos-(j2-jpos+1);
2658  apos = apos2-(j2-jpos+2);
2659  i1rhs = -iw[jpos-1];
2660  i2rhs = iw[jpos];
2661  w1 = rhs[i1rhs]*a[apos]+rhs[i2rhs]*a[apos+1];
2662  w2 = rhs[i1rhs]*a[apos+1]+rhs[i2rhs]*a[apos2];
2663  j1 = jpos+1;
2664  if (j1 <= j2) {
2665  jj1 = apos+2;
2666  jj2 = apos2+1;
2667  for (j = j1; j < j2+1; j++) {
2668  irhs = TMath::Abs(iw[j]+0);
2669  w1 = w1+rhs[irhs]*a[jj1];
2670  w2 = w2+rhs[irhs]*a[jj2];
2671  jj1 = jj1+1;
2672  jj2 = jj2+1;
2673  }
2674  }
2675  rhs[i1rhs] = w1;
2676  rhs[i2rhs] = w2;
2677  jpos = jpos-2;
2678  }
2679  }
2680  }
2681 }
2682
2683 ////////////////////////////////////////////////////////////////////////////////
2684 /// Print class members
2685
2687 {
2688  TDecompBase::Print(opt);
2689
2690  printf("fPrecision = %.3f\n",fPrecision);
2691  printf("fIPessimism = %.3f\n",fIPessimism);
2692  printf("fRPessimism = %.3f\n",fRPessimism);
2693
2694  TMatrixDSparse fact(0,fNrows-1,0,fNrows-1,fNnonZeros,
2696  fact.Print("fFact");
2697 }
2698
2699 ////////////////////////////////////////////////////////////////////////////////
2700 /// Assignment operator
2701
2703 {
2704  if (this != &source) {
2705  TDecompBase::operator=(source);
2706  memcpy(fIcntl,source.fIcntl,31*sizeof(Int_t));
2707  memcpy(fCntl,source.fCntl,6*sizeof(Double_t));
2708  memcpy(fInfo,source.fInfo,21*sizeof(Int_t));
2709  fVerbose = source.fVerbose;
2710  fPrecision = source.fPrecision;
2711  fIkeep = source.fIkeep;
2712  fIw = source.fIw;
2713  fIw1 = source.fIw1;
2714  fIw2 = source.fIw2;
2715  fNsteps = source.fNsteps;
2716  fMaxfrt = source.fMaxfrt;
2717  fW = source.fW;
2718  fIPessimism = source.fIPessimism;
2719  fRPessimism = source.fRPessimism;
2720  if (fA.IsValid())
2721  fA.Use(*const_cast<TMatrixDSparse *>(&(source.fA)));
2722  fNrows = source.fNrows;
2723  fNnonZeros = source.fNnonZeros;
2724  fFact = source.fFact;
2725  fRowFact = source.fRowFact;
2726  fColFact = source.fColFact;
2727  }
2728  return *this;
2729 }
virtual const Element * GetMatrixArray() const
void SetTreatAsZero(Double_t tol)
Double_t fCntl[6]
Definition: TDecompSparse.h:58
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Definition: TObject.cxx:899
TMatrixDSparse fA
Definition: TDecompSparse.h:77
TArrayI fColFact
Definition: TDecompSparse.h:83
Double_t fRPessimism
Definition: TDecompSparse.h:74
Int_t GetRowLwb() const
Definition: TMatrixTBase.h:132
virtual void SetMatrix(const TMatrixDSparse &a)
Set matrix to be decomposed .
virtual const Int_t * GetRowIndexArray() const
static void InitPivot_sub5(const Int_t n, Int_t *ipe, Int_t *nv, Int_t *ips, Int_t *ne, Int_t *na, Int_t *nd, Int_t &nsteps, const Int_t nemin)
Help routine for pivoting setup.
Double_t fIPessimism
Definition: TDecompSparse.h:73
Int_t fRowLwb
Definition: TDecompBase.h:43
const char Option_t
Definition: RtypesCore.h:62
void Reset()
Definition: TArrayD.h:49
static void CopyUpperTriang(const TMatrixDSparse &a, Double_t *b)
Static function, copying the non-zero entries in the upper triangle to array b .
const Double_t * GetArray() const
Definition: TArrayD.h:45
static void InitPivot_sub1(const Int_t n, const Int_t nz, Int_t *irn, Int_t *icn, Int_t *iw, Int_t *ipe, Int_t *iq, Int_t *flag, Int_t &iwfr, Int_t *icntl, Int_t *info)
Help routine for pivoting setup.
const Double_t kThresholdPivotingFactor
Definition: TDecompSparse.h:49
Bool_t TestBit(UInt_t f) const
Definition: TObject.h:157
Int_t GetLwb() const
Definition: TVectorT.h:79
TArrayI fIkeep
Definition: TDecompSparse.h:65
void Print(Option_t *opt="") const
Print class members.
TDecompSparse()
Default constructor.
Decomposition Base class.
Definition: TDecompBase.h:36
#define R__ASSERT(e)
Definition: TError.h:98
static void Factor_sub3(Double_t *a, Int_t *iw, Int_t &j1, Int_t &j2, const Int_t itop, const Int_t ireal, Int_t &ncmpbr, Int_t &ncmpbi)
Help routine for factorization.
TDecompSparse & operator=(const TDecompSparse &source)
Assignment operator.
Int_t GetNrows() const
Definition: TVectorT.h:81
Short_t Min(Short_t a, Short_t b)
Definition: TMathBase.h:170
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
TArc * a
Definition: textangle.C:12
const Bool_t kFALSE
Definition: Rtypes.h:92
Element NormInf() const
Compute the infinity-norm of the vector MAX{ |v[i]| }.
Definition: TVectorT.cxx:601
Short_t Abs(Short_t d)
Definition: TMathBase.h:110
Array of integers (32 bits per element).
Definition: TArrayI.h:29
void SetBit(UInt_t f, Bool_t set)
Set or unset the user status bits as specified in f.
Definition: TObject.cxx:739
virtual Bool_t Decompose()
Decomposition engine .
Int_t GetColLwb() const
Definition: TMatrixTBase.h:135
static Int_t IDiag(Int_t ix, Int_t iy)
TDecompBase & operator=(const TDecompBase &source)
Assignment operator.
static void Solve(const Int_t n, TArrayD &Aa, TArrayI &Aiw, TArrayD &Aw, const Int_t maxfrt, TVectorD &b, TArrayI &Aiw1, const Int_t nsteps, Int_t *icntl, Int_t *info)
Main routine for solving Ax=b.
static void Solve_sub1(const Int_t n, Double_t *a, Int_t *iw, Double_t *w, Double_t *rhs, Int_t *iw2, const Int_t nblk, Int_t &latop, Int_t *icntl)
Help routine for solving.
static void Factor(const Int_t n, const Int_t nz, TArrayI &Airn, TArrayI &Aicn, TArrayD &Aa, TArrayI &Aiw, TArrayI &Aikeep, const Int_t nsteps, Int_t &maxfrt, TArrayI &Aiw1, Int_t *icntl, Double_t *cntl, Int_t *info)
Factorization routine, the workhorse for the decomposition step.
void InitParam()
initializing control parameters
const Int_t * GetArray() const
Definition: TArrayI.h:45
Int_t fColLwb
Definition: TDecompBase.h:44
XFontStruct * id
Definition: TGX11.cxx:108
void Set(Int_t n)
Set size of this array to n ints.
Definition: TArrayI.cxx:105
TArrayI fRowFact
Definition: TDecompSparse.h:82
virtual void ls(Option_t *option="") const
The ls function lists the contents of a class on stdout.
Definition: TObject.cxx:537
TVectorT< Element > & Shift(Int_t row_shift)
Definition: TVectorT.h:93
Element * GetMatrixArray()
Definition: TVectorT.h:84
static Int_t NonZerosUpperTriang(const TMatrixDSparse &a)
Static function, returning the number of non-zero entries in the upper triangular matrix ...
Int_t fInfo[21]
Definition: TDecompSparse.h:59
static void Solve_sub2(const Int_t n, Double_t *a, Int_t *iw, Double_t *w, Double_t *rhs, Int_t *iw2, const Int_t nblk, const Int_t latop, Int_t *icntl)
Help routine for solving.
Int_t GetSize() const
Definition: TArray.h:49
Bool_t IsValid() const
Definition: TVectorT.h:89
bool verbose
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
Definition: TObject.cxx:925
void Print(Option_t *opt="") const
Print class members.
Double_t GetThresholdPivoting()
TLine * l
Definition: textangle.C:4
Sparse Symmetric Decomposition class.
Definition: TDecompSparse.h:51
void ResetStatus()
Definition: TDecompBase.h:46
void SetThresholdPivoting(Double_t piv)
static void Factor_sub2(const Int_t n, const Int_t nz, Double_t *a, const Int_t la, Int_t *iw, const Int_t liw, Int_t *perm, Int_t *nstk, const Int_t nsteps, Int_t &maxfrt, Int_t *nelim, Int_t *iw2, Int_t *icntl, Double_t *cntl, Int_t *info)
Help routine for factorization.
Int_t fIcntl[31]
Definition: TDecompSparse.h:57
virtual const Int_t * GetColIndexArray() const
Int_t GetNrows() const
Definition: TMatrixTBase.h:134
Double_t fPrecision
Definition: TDecompSparse.h:61
const Double_t kInitPrecision
Definition: TDecompSparse.h:37
#define ClassImp(name)
Definition: Rtypes.h:279
double Double_t
Definition: RtypesCore.h:55
TMatrixTSparse< Element > & Use(Int_t row_lwb, Int_t row_upb, Int_t col_lwb, Int_t col_upb, Int_t nr_nonzeros, Int_t *pRowIndex, Int_t *pColIndex, Element *pData)
const Double_t kThresholdPivotingMax
Definition: TDecompSparse.h:44
Int_t MinRealWorkspace()
Array of doubles (64 bits per element).
Definition: TArrayD.h:29
void Print(Option_t *name="") const
Print the matrix as a table of elements.
static void InitPivot_sub2(const Int_t n, Int_t *ipe, Int_t *iw, const Int_t lw, Int_t &iwfr, Int_t *nv, Int_t *nxt, Int_t *lst, Int_t *ipd, Int_t *flag, const Int_t iovflo, Int_t &ncmpa, const Double_t fratio)
Help routine for pivoting setup.
static void InitPivot_sub4(const Int_t n, Int_t *ipe, Int_t *iw, const Int_t lw, Int_t &iwfr, Int_t *ips, Int_t *ipv, Int_t *nv, Int_t *flag, Int_t &ncmpa)
Help routine for pivoting setup.
const Double_t kInitTreatAsZero
Definition: TDecompSparse.h:35
static void InitPivot_sub2a(const Int_t n, Int_t *ipe, Int_t *iw, const Int_t lw, Int_t &iwfr, Int_t &ncmpa)
Help routine for pivoting setup.
Short_t Max(Short_t a, Short_t b)
Definition: TMathBase.h:202
Int_t ErrorFlag()
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
const Double_t kInitThresholdPivoting
Definition: TDecompSparse.h:36
int * iq
Definition: THbookFile.cxx:86
void SetVerbose(Int_t v)
static void InitPivot(const Int_t n, const Int_t nz, TArrayI &Airn, TArrayI &Aicn, TArrayI &Aiw, TArrayI &Aikeep, TArrayI &Aiw1, Int_t &nsteps, const Int_t iflag, Int_t *icntl, Double_t *cntl, Int_t *info, Double_t &ops)
Setup Pivoting variables.
static void InitPivot_sub6(const Int_t n, const Int_t nz, Int_t *irn, Int_t *icn, Int_t *perm, Int_t *na, Int_t *ne, Int_t *nd, const Int_t nsteps, Int_t *lstki, Int_t *lstkr, Int_t *iw, Int_t *info, Double_t &ops)
Help routine for pivoting setup.
const Bool_t kTRUE
Definition: Rtypes.h:91
Int_t Nint(T x)
Definition: TMath.h:480
void Set(Int_t n)
Set size of this array to n doubles.
Definition: TArrayD.cxx:105
static char * skip(char **buf, const char *delimiters)
Definition: civetweb.c:2039
const Int_t n
Definition: legend1.C:16
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
Definition: TObject.cxx:911
Bool_t IsValid() const
Definition: TMatrixTBase.h:157
static void Factor_sub1(const Int_t n, const Int_t nz, Int_t &nz1, Double_t *a, const Int_t la, Int_t *irn, Int_t *icn, Int_t *iw, const Int_t liw, Int_t *perm, Int_t *iw2, Int_t *icntl, Int_t *info)
Help routine for factorization.
static void InitPivot_sub3(const Int_t n, const Int_t nz, Int_t *irn, Int_t *icn, Int_t *perm, Int_t *iw, Int_t *ipe, Int_t *iq, Int_t *flag, Int_t &iwfr, Int_t *icntl, Int_t *info)
Help routine for pivoting setup.