00001
00002 #ifndef COIN_OSL_C_INCLUDE
00003
00004
00005 #define COIN_OSL_C_INCLUDE
00006
00007 #ifndef CLP_OSL
00008 #define CLP_OSL 0
00009 #endif
00010 #define C_EKK_GO_SPARSE 200
00011
00012 #ifdef HAVE_ENDIAN_H
00013 #include <endian.h>
00014 #if __BYTE_ORDER == __LITTLE_ENDIAN
00015 #define INTEL
00016 #endif
00017 #endif
00018
00019 #include <math.h>
00020 #include <string.h>
00021 #include <stdio.h>
00022 #include <stdlib.h>
00023
00024 #define SPARSE_UPDATE
00025 #define NO_SHIFT
00026 #include "CoinHelperFunctions.hpp"
00027
00028 #include <stddef.h>
00029 #ifdef __cplusplus
00030 extern "C"{
00031 #endif
00032
00033 int c_ekkbtrn( register const EKKfactinfo *fact,
00034 double *dwork1,
00035 int * mpt,int first_nonzero);
00036 int c_ekkbtrn_ipivrw( register const EKKfactinfo *fact,
00037 double *dwork1,
00038 int * mpt, int ipivrw,int * spare);
00039
00040 int c_ekketsj( register EKKfactinfo *fact,
00041 double *dwork1,
00042 int *mpt2, double dalpha, int orig_nincol,
00043 int npivot, int *nuspikp,
00044 const int ipivrw, int * spare);
00045 int c_ekkftrn( register const EKKfactinfo *fact,
00046 double *dwork1,
00047 double * dpermu,int * mpt, int numberNonZero);
00048
00049 int c_ekkftrn_ft( register EKKfactinfo *fact,
00050 double *dwork1, int *mpt, int *nincolp);
00051 void c_ekkftrn2( register EKKfactinfo *fact, double *dwork1,
00052 double * dpermu1,int * mpt1, int *nincolp,
00053 double *dwork1_ft, int *mpt_ft, int *nincolp_ft);
00054
00055 int c_ekklfct( register EKKfactinfo *fact);
00056 int c_ekkslcf( register const EKKfactinfo *fact);
00057 inline void c_ekkscpy(int n, const int *marr1,int *marr2)
00058 { CoinMemcpyN(marr1,n,marr2);}
00059 inline void c_ekkdcpy(int n, const double *marr1,double *marr2)
00060 { CoinMemcpyN(marr1,n,marr2);}
00061 int c_ekk_IsSet(const int * array,int bit);
00062 void c_ekk_Set(int * array,int bit);
00063 void c_ekk_Unset(int * array,int bit);
00064
00065 void c_ekkzero(int length, int n, void * array);
00066 inline void c_ekkdzero(int n, double *marray)
00067 {CoinZeroN(marray,n);}
00068 inline void c_ekkizero(int n, int *marray)
00069 {CoinZeroN(marray,n);}
00070 inline void c_ekkczero(int n, char *marray)
00071 {CoinZeroN(marray,n);}
00072 #ifdef __cplusplus
00073 }
00074 #endif
00075
00076 #define c_ekkscpy_0_1(s,ival,array) CoinFillN(array,s,ival)
00077 #define c_ekks1cpy( n,marr1,marr2) CoinMemcpyN(marr1,n, marr2)
00078 void clp_setup_pointers(EKKfactinfo * fact);
00079 void clp_memory(int type);
00080 double * clp_double(int number_entries);
00081 int * clp_int(int number_entries);
00082 void * clp_malloc(int number_entries);
00083 void clp_free(void * oldArray);
00084
00085 #define SLACK_VALUE -1.0
00086 #define C_EKK_REMOVE_LINK(hpiv,hin,link,ipivot) \
00087 { \
00088 int ipre = link[ipivot].pre; \
00089 int isuc = link[ipivot].suc; \
00090 if (ipre > 0) { \
00091 link[ipre].suc = isuc; \
00092 } \
00093 if (ipre <= 0) { \
00094 hpiv[hin[ipivot]] = isuc; \
00095 } \
00096 if (isuc > 0) { \
00097 link[isuc].pre = ipre; \
00098 } \
00099 }
00100
00101 #define C_EKK_ADD_LINK(hpiv,nzi,link, npr) \
00102 { \
00103 int ifiri = hpiv[nzi]; \
00104 hpiv[nzi] = npr; \
00105 link[npr].suc = ifiri; \
00106 link[npr].pre = 0; \
00107 if (ifiri != 0) { \
00108 link[ifiri].pre = npr; \
00109 } \
00110 }
00111 #include <assert.h>
00112 #ifdef NO_SHIFT
00113
00114 #define SHIFT_INDEX(limit) (limit)
00115 #define UNSHIFT_INDEX(limit) (limit)
00116 #define SHIFT_REF(arr,ind) (arr)[ind]
00117
00118 #else
00119
00120 #define SHIFT_INDEX(limit) ((limit)<<3)
00121 #define UNSHIFT_INDEX(limit) ((unsigned int)(limit)>>3)
00122 #define SHIFT_REF(arr,ind) (*(double*)((char*)(arr) + (ind)))
00123
00124 #endif
00125
00126 #ifdef INTEL
00127 #define NOT_ZERO(x) (((*((reinterpret_cast<unsigned char *>(&x))+7)) & 0x7F) != 0)
00128 #else
00129 #define NOT_ZERO(x) ((x) != 0.0)
00130 #endif
00131
00132 #define SWAP(type,_x,_y) { type _tmp = (_x); (_x) = (_y); (_y) = _tmp;}
00133
00134 #define UNROLL_LOOP_BODY1(code) \
00135 {{code}}
00136 #define UNROLL_LOOP_BODY2(code) \
00137 {{code} {code}}
00138 #define UNROLL_LOOP_BODY4(code) \
00139 {{code} {code} {code} {code}}
00140 #endif
00141 #ifdef COIN_OSL_CMFC
00142
00143
00144
00145
00146
00147 {
00148 #if 1
00149 int *hcoli = fact->xecadr;
00150 double *dluval = fact->xeeadr;
00151 double *dvalpv = fact->kw3adr;
00152 int *mrstrt = fact->xrsadr;
00153 int *hrowi = fact->xeradr;
00154 int *mcstrt = fact->xcsadr;
00155 int *hinrow = fact->xrnadr;
00156 int *hincol = fact->xcnadr;
00157 int *hpivro = fact->krpadr;
00158 int *hpivco = fact->kcpadr;
00159 #endif
00160 int nnentl = fact->nnentl;
00161 int nnentu = fact->nnentu;
00162 int kmxeta = fact->kmxeta;
00163 int xnewro = *xnewrop;
00164 int ncompactions = *ncompactionsp;
00165
00166 MACTION_T *maction = reinterpret_cast<MACTION_T*>(maction_void);
00167
00168 int i, j, k;
00169 double d1;
00170 int j1, j2;
00171 int jj, kk, kr, nz, jj1, jj2, kce, kcs, kqq, npr;
00172 int fill, naft;
00173 int enpr;
00174 int nres, npre;
00175 int knpr, irow, iadd32, ibase;
00176 double pivot;
00177 int count, nznpr;
00178 int nlast, epivr1;
00179 int kipis;
00180 double dpivx;
00181 int kipie, kcpiv, knprs, knpre;
00182 bool cancel;
00183 double multip, elemnt;
00184 int ipivot, jpivot, epivro, epivco, lstart, ifdens, nfirst;
00185 int nzpivj, kfill, kstart;
00186 int nmove, ileft;
00187 #ifndef C_EKKCMFY
00188 int iput, nspare;
00189 int noRoomForDense=0;
00190 int if_sparse_update=fact->if_sparse_update;
00191 #endif
00192 int irtcod = 0;
00193 const int nrow = fact->nrow;
00194
00195
00196 --maction;
00197
00198
00199 lstart = nnetas - nnentl + 1;
00200 for (i = lstart; i <= nnetas; ++i) {
00201 hrowi[i] = SHIFT_INDEX(hcoli[i]);
00202 }
00203 ifdens = 0;
00204
00205 for (i = 1; i <= nrow; ++i) {
00206 maction[i] = 0;
00207 mwork[i].pre = i - 1;
00208 mwork[i].suc = i + 1;
00209 }
00210
00211 iadd32 = 0;
00212 nlast = nrow;
00213 nfirst = 1;
00214 mwork[1].pre = nrow;
00215 mwork[nrow].suc = 1;
00216
00217 for (count = 1; count <= nrow; ++count) {
00218
00219
00220 if (! (hpivco[1] <= 0)) {
00221 int small_pivot = c_ekkcsin(fact,
00222 rlink, clink,
00223 nsingp);
00224
00225 if (small_pivot) {
00226 irtcod = 7;
00227 if (fact->invok >= 0) {
00228 goto L1050;
00229 }
00230 }
00231 if (fact->npivots >= nrow) {
00232 goto L1050;
00233 }
00234 }
00235
00236
00237 if (! (hpivro[1] <= 0)) {
00238 irtcod = c_ekkrsin(fact,
00239 rlink, clink,
00240 mwork,nfirst,
00241 nsingp,
00242
00243 &xnewco, &xnewro,
00244 &nnentu,
00245 &kmxeta, &ncompactions,
00246 &nnentl);
00247 if (irtcod != 0) {
00248 if (irtcod < 0 || fact->invok >= 0) {
00249
00250 goto L1050;
00251 }
00252
00253
00254 }
00255 if (fact->npivots >= nrow) {
00256 goto L1050;
00257 }
00258 lstart = nnetas - nnentl + 1;
00259 }
00260
00261
00262 irtcod = c_ekkfpvt(fact,
00263 rlink, clink,
00264 nsingp, xrejctp, &ipivot, &jpivot);
00265 if (irtcod != 0) {
00266
00267 goto L1050;
00268 }
00269
00270 c_ekkprpv(fact, rlink, clink,
00271 *xrejctp, ipivot, jpivot);
00272
00273 epivco = hincol[jpivot];
00274 ++fact->xnetal;
00275 mcstrt[fact->xnetal] = lstart - 1;
00276 hpivco[fact->xnetal] = ipivot;
00277 epivro = hinrow[ipivot];
00278 epivr1 = epivro - 1;
00279 kipis = mrstrt[ipivot];
00280 pivot = dluval[kipis];
00281 dpivx = 1. / pivot;
00282 kipie = kipis + epivr1;
00283 ++kipis;
00284 #ifndef C_EKKCMFY
00285 {
00286 double size = nrow - fact->npivots;
00287 if (size > GO_DENSE && (nnentu - fact->nuspike) * GO_DENSE_RATIO > size * size) {
00288
00289 if (*nsingp == 0) {
00290 ifdens = 1;
00291 }
00292 }
00293 }
00294 #endif
00295
00296
00297
00298 for (k = kipis; k <= kipie; ++k) {
00299 irow = hcoli[k];
00300 dvalpv[k - kipis + 1] = dluval[k];
00301 maction[irow] = static_cast<MACTION_T>(k - kipis + 1);
00302 }
00303
00304
00305 kcpiv = mcstrt[jpivot] - 1;
00306 for (nzpivj = 1; nzpivj <= epivco; ++nzpivj) {
00307 ++kcpiv;
00308 npr = hrowi[kcpiv];
00309 hrowi[kcpiv] = 0;
00310
00311 --hincol[jpivot];
00312
00313 ++mcstrt[jpivot];
00314
00315
00316 --hinrow[npr];
00317 enpr = hinrow[npr];
00318 knprs = mrstrt[npr];
00319 knpre = knprs + enpr;
00320
00321
00322 knpr = knprs;
00323 while (1) {
00324 UNROLL_LOOP_BODY4({
00325 if (jpivot == hcoli[knpr]) {
00326 break;
00327 }
00328 knpr++;
00329 });
00330 }
00331
00332 multip = -dluval[knpr] * dpivx;
00333
00334
00335 dluval[knpr] = dluval[knpre];
00336 hcoli[knpr] = hcoli[knpre];
00337 --knpre;
00338
00339 #if 1
00340
00341 kfill = epivr1 - (knpre - knprs + 1);
00342 nres = ((knpre - knprs + 1) & 1) + knprs;
00343 cancel = false;
00344 d1 = 1e33;
00345 j1 = hcoli[nres];
00346
00347 if (nres != knprs) {
00348 j = hcoli[knprs];
00349 if (maction[j] == 0) {
00350 ++kfill;
00351 } else {
00352 jj = maction[j];
00353 maction[j] = static_cast<MACTION_T>(-maction[j]);
00354 dluval[knprs] += multip * dvalpv[jj];
00355 d1 = fabs(dluval[knprs]);
00356 }
00357 }
00358 j2 = hcoli[nres + 1];
00359 jj1 = maction[j1];
00360 for (kr = nres; kr < knpre; kr += 2) {
00361 jj2 = maction[j2];
00362 if ( (jj1 == 0)) {
00363 ++kfill;
00364 } else {
00365 maction[j1] = static_cast<MACTION_T>(-maction[j1]);
00366 dluval[kr] += multip * dvalpv[jj1];
00367 cancel = cancel || ! (fact->zeroTolerance < d1);
00368 d1 = fabs(dluval[kr]);
00369 }
00370 j1 = hcoli[kr + 2];
00371 if ( (jj2 == 0)) {
00372 ++kfill;
00373 } else {
00374 maction[j2] = static_cast<MACTION_T>(-maction[j2]);
00375 dluval[kr + 1] += multip * dvalpv[jj2];
00376 cancel = cancel || ! (fact->zeroTolerance < d1);
00377 d1 = fabs(dluval[kr + 1]);
00378 }
00379 jj1 = maction[j1];
00380 j2 = hcoli[kr + 3];
00381 }
00382 cancel = cancel || ! (fact->zeroTolerance < d1);
00383 #else
00384
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399 kfill = epivr1 - (knpre - knprs + 1);
00400 cancel = false;
00401
00402 for (kr = knprs; kr <= knpre; kr++) {
00403 j1 = hcoli[kr];
00404 jj1 = maction[j1];
00405 if ( (jj1 == 0)) {
00406
00407 ++kfill;
00408 } else {
00409
00410 maction[j1] = -maction[j1];
00411 dluval[kr] += multip * dvalpv[jj1];
00412 d1 = fabs(dluval[kr]);
00413 cancel = cancel || ! (fact->zeroTolerance < d1);
00414 }
00415 }
00416 #endif
00417 kstart = knpre;
00418 fill = kfill;
00419
00420 if (cancel) {
00421
00422 kstart = knprs - 1;
00423 for (kr = knprs; kr <= knpre; ++kr) {
00424 j = hcoli[kr];
00425 if (fabs(dluval[kr]) > fact->zeroTolerance) {
00426 ++kstart;
00427 dluval[kstart] = dluval[kr];
00428 hcoli[kstart] = j;
00429 } else {
00430
00431 --nnentu;
00432 --hincol[j];
00433 --enpr;
00434 kcs = mcstrt[j];
00435 kce = kcs + hincol[j];
00436 for (kk = kcs; kk <= kce; ++kk) {
00437 if (hrowi[kk] == npr) {
00438 hrowi[kk] = hrowi[kce];
00439 hrowi[kce] = 0;
00440 break;
00441 }
00442 }
00443
00444 }
00445 }
00446 knpre = kstart;
00447 }
00448
00449 if (fill == 0) {
00450 for (k = kipis; k <= kipie; ++k) {
00451 maction[hcoli[k]] = static_cast<MACTION_T>(-maction[hcoli[k]]);
00452 }
00453 }
00454 else {
00455 naft = mwork[npr].suc;
00456 kqq = mrstrt[naft] - knpre - 1;
00457
00458 if (fill > kqq) {
00459
00460
00461 nznpr = enpr + fill;
00462 if (! (xnewro + nznpr + 1 < lstart)) {
00463 if (! (nnentu + nznpr + 1 < lstart)) {
00464 irtcod = -5;
00465 goto L1050;
00466 }
00467
00468
00469
00470
00471
00472 {
00473 int iput = c_ekkrwcs(fact,dluval, hcoli, mrstrt, hinrow, mwork, nfirst);
00474 kmxeta += xnewro - iput ;
00475 xnewro = iput - 1;
00476 ++ncompactions;
00477 }
00478
00479 kipis = mrstrt[ipivot] + 1;
00480 kipie = kipis + epivr1 - 1;
00481 knprs = mrstrt[npr];
00482 }
00483
00484
00485
00486
00487 knpre = knprs + enpr - 1;
00488
00489
00490
00491
00492
00493
00494 if (npr != nlast) {
00495 npre = mwork[npr].pre;
00496 if (npr == nfirst) {
00497 nfirst = naft;
00498 }
00499
00500 mwork[naft].pre = npre;
00501 mwork[npre].suc = naft;
00502
00503 mwork[nfirst].pre = npr;
00504 mwork[nlast].suc = npr;
00505 mwork[npr].pre = nlast;
00506 mwork[npr].suc = nfirst;
00507 nlast = npr;
00508 kstart = xnewro;
00509 mrstrt[npr] = kstart + 1;
00510 nmove = knpre - knprs + 1;
00511 ibase = kstart + 1 - knprs;
00512 for (kr = knprs; kr <= knpre; ++kr) {
00513 dluval[ibase + kr] = dluval[kr];
00514 hcoli[ibase + kr] = hcoli[kr];
00515 }
00516 kstart += nmove;
00517 } else {
00518 kstart = knpre;
00519 }
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532 if (iadd32 != 0) {
00533 xnewro += iadd32;
00534 } else {
00535 if (kstart + (nrow << 1) + 100 < lstart) {
00536 ileft = ((nrow - fact->npivots + 32) & -32);
00537 if (kstart + ileft * ileft + 32 < lstart) {
00538 iadd32 = ileft;
00539 xnewro = CoinMax(kstart,xnewro);
00540 xnewro = (xnewro & -32) + ileft;
00541 } else {
00542 xnewro = ((kstart + 31) & -32);
00543 }
00544 } else {
00545 xnewro = kstart;
00546 }
00547 }
00548
00549 hinrow[npr] = enpr;
00550 } else if (! (nnentu + kqq + 2 < lstart)) {
00551 irtcod = -5;
00552 goto L1050;
00553 }
00554
00555 for (kr = kipis; kr <= kipie; ++kr) {
00556 j = hcoli[kr];
00557 jj = maction[j];
00558 if (jj >0) {
00559 elemnt = multip * dvalpv[jj];
00560 if (fabs(elemnt) > fact->zeroTolerance) {
00561 ++kstart;
00562 dluval[kstart] = elemnt;
00563
00564
00565 hcoli[kstart] = j;
00566 ++nnentu;
00567 nz = hincol[j];
00568 kcs = mcstrt[j];
00569 kce = kcs + nz - 1;
00570 if (kce == xnewco) {
00571 if (xnewco + 1 >= lstart) {
00572 if (xnewco + nz + 1 >= lstart) {
00573
00574 if (nnentu + nz + 1 < lstart) {
00575 xnewco = c_ekkclco(fact,hrowi, mcstrt, hincol, xnewco);
00576 ++ncompactions;
00577
00578 kcpiv = mcstrt[jpivot] - 1;
00579 kcs = mcstrt[j];
00580
00581 nz = hincol[j];
00582 kce = kcs + nz - 1;
00583 } else {
00584 irtcod = -5;
00585 goto L1050;
00586 }
00587 }
00588
00589 mcstrt[j] = xnewco + 1;
00590 ibase = mcstrt[j] - kcs;
00591 for (kk = kcs; kk <= kce; ++kk) {
00592 hrowi[ibase + kk] = hrowi[kk];
00593 hrowi[kk] = 0;
00594 }
00595 kce = xnewco + kce - kcs + 1;
00596 xnewco = kce + 1;
00597 } else {
00598 ++xnewco;
00599 }
00600 } else if (hrowi[kce + 1] != 0) {
00601
00602 if (xnewco + nz + 1 >= lstart) {
00603
00604 if (nnentu + nz + 1 < lstart) {
00605 xnewco = c_ekkclco(fact,hrowi, mcstrt, hincol, xnewco);
00606 ++ncompactions;
00607
00608 kcpiv = mcstrt[jpivot] - 1;
00609 kcs = mcstrt[j];
00610
00611 nz = hincol[j];
00612 kce = kcs + nz - 1;
00613 } else {
00614 irtcod = -5;
00615 goto L1050;
00616 }
00617 }
00618
00619 mcstrt[j] = xnewco + 1;
00620 ibase = mcstrt[j] - kcs;
00621 for (kk = kcs; kk <= kce; ++kk) {
00622 hrowi[ibase + kk] = hrowi[kk];
00623 hrowi[kk] = 0;
00624 }
00625 kce = xnewco + kce - kcs + 1;
00626 xnewco = kce + 1;
00627 }
00628
00629 hrowi[kce + 1] = npr;
00630 hincol[j] = nz + 1;
00631 }
00632 } else {
00633 maction[j] = static_cast<MACTION_T>(-maction[j]);
00634 }
00635 }
00636 if (fill > kqq) {
00637 xnewro = kstart;
00638 }
00639 }
00640 hinrow[npr] = kstart - mrstrt[npr] + 1;
00641
00642 if (! (xnewco + 1 < lstart)) {
00643 xnewco = c_ekkclco(fact,hrowi, mcstrt, hincol, xnewco);
00644 ++ncompactions;
00645
00646 kcpiv = mcstrt[jpivot] - 1;
00647 }
00648 if (! (xnewro + 1 < lstart)) {
00649 int iput = c_ekkrwcs(fact,dluval, hcoli, mrstrt, hinrow, mwork, nfirst);
00650 kmxeta += xnewro - iput ;
00651 xnewro = iput - 1;
00652 ++ncompactions;
00653
00654 kipis = mrstrt[ipivot] + 1;
00655 kipie = kipis + epivr1 - 1;
00656 }
00657
00658 ++nnentl;
00659 --nnentu;
00660 --lstart;
00661 dluval[lstart] = multip;
00662
00663 hrowi[lstart] = SHIFT_INDEX(npr);
00664 #define INLINE_AFPV 3
00665
00666
00667
00668 #if INLINE_AFPV
00669 {
00670 int j;
00671 int nel, krs;
00672 int koff;
00673 int * index;
00674 double * els;
00675 nel = hinrow[npr];
00676 krs = mrstrt[npr];
00677 index=&hcoli[krs];
00678 els=&dluval[krs];
00679 #if INLINE_AFPV<3
00680 #if INLINE_AFPV==1
00681 double maxaij = 0.0;
00682 koff = 0;
00683 j=0;
00684 while (j<nel) {
00685 double d = fabs(els[j]);
00686 if (maxaij < d) {
00687 maxaij = d;
00688 koff=j;
00689 }
00690 j++;
00691 }
00692 #else
00693 assert (nel);
00694 koff=0;
00695 double maxaij=fabs(els[0]);
00696 for (j=1;j<nel;j++) {
00697 double d = fabs(els[j]);
00698 if (maxaij < d) {
00699 maxaij = d;
00700 koff=j;
00701 }
00702 }
00703 #endif
00704 #else
00705 double maxaij = 0.0;
00706 koff = 0;
00707 j=0;
00708 if ((nel&1)!=0) {
00709 maxaij=fabs(els[0]);
00710 j=1;
00711 }
00712
00713 while (j<nel) {
00714 UNROLL_LOOP_BODY2({
00715 double d = fabs(els[j]);
00716 if (maxaij < d) {
00717 maxaij = d;
00718 koff=j;
00719 }
00720 j++;
00721 });
00722 }
00723 #endif
00724 SWAP(int, index[koff], index[0]);
00725 SWAP(double, els[koff], els[0]);
00726 }
00727 #endif
00728
00729 {
00730 int nzi = hinrow[npr];
00731 if (nzi > 0) {
00732 C_EKK_ADD_LINK(hpivro, nzi, rlink, npr);
00733 }
00734 }
00735 }
00736
00737
00738 #if INLINE_AFPV==0
00739 int nn = mcstrt[fact->xnetal] - lstart + 1;
00740 c_ekkafpv(hrowi+lstart, hcoli, dluval, mrstrt, hinrow, nn);
00741 #endif
00742
00743
00744 for (k = kipis; k <= kipie; ++k) {
00745 maction[hcoli[k]] = 0;
00746 }
00747
00748 if (*xrejctp > 0) {
00749 for (k = kipis; k <= kipie; ++k) {
00750 int j = hcoli[k];
00751 int nzj = hincol[j];
00752 if (! (nzj <= 0) &&
00753 ! ((clink[j].pre > nrow && nzj != 1))) {
00754 C_EKK_ADD_LINK(hpivco, nzj, clink, j);
00755 }
00756 }
00757 } else {
00758 for (k = kipis; k <= kipie; ++k) {
00759 int j = hcoli[k];
00760 int nzj = hincol[j];
00761 if (! (nzj <= 0)) {
00762 C_EKK_ADD_LINK(hpivco, nzj, clink, j);
00763 }
00764 }
00765 }
00766 fact->nuspike += hinrow[ipivot];
00767
00768
00769 #ifndef C_EKKCMFY
00770 if (ifdens != 0) {
00771 int ndense = nrow - fact->npivots;
00772 if (! (xnewro + ndense * ndense >= lstart)) {
00773
00774
00775 c_ekkizero( nrow, reinterpret_cast<int *> (maction+1));
00776 iput = 0;
00777 for (i = 1; i <= nrow; ++i) {
00778 if (clink[i].pre >= 0) {
00779 ++iput;
00780 maction[i] = static_cast<short int>(iput);
00781 }
00782 }
00783
00784 nspare = 0;
00785 for (i = 1; i <= nrow; ++i) {
00786 if (rlink[i].pre >= 0) {
00787 nspare = nspare + ndense - hinrow[i];
00788 }
00789 }
00790 if (iput != nrow - fact->npivots) {
00791
00792 c_ekkizero( nrow, reinterpret_cast<int *> (maction+1));
00793 } else {
00794
00795 int iput = c_ekkrwcs(fact,dluval, hcoli, mrstrt, hinrow, mwork, nfirst);
00796 kmxeta += xnewro - iput ;
00797 xnewro = iput - 1;
00798 ++ncompactions;
00799
00800 --ncompactions;
00801 if (xnewro + nspare + ndense * ndense >= lstart) {
00802 c_ekkizero( nrow, reinterpret_cast<int *> (maction+1));
00803 }
00804 else {
00805 xnewro += nspare;
00806 c_ekkrwct(fact,dluval, hcoli, mrstrt, hinrow, mwork,
00807 rlink, maction, dvalpv,
00808 nlast, xnewro);
00809 kmxeta += xnewro ;
00810 if (nnentu + nnentl > nrow * 5 &&
00811 (ndense*ndense)>(nnentu+nnentl)>>2 &&
00812 !if_sparse_update) {
00813 fact->ndenuc = ndense;
00814 }
00815 irtcod = c_ekkcmfd(fact,
00816 (reinterpret_cast<int*>(dvalpv)+1),
00817 rlink, clink,
00818 (reinterpret_cast<int*>(maction+1))+1,
00819 nnetas,
00820 &nnentl, &nnentu,
00821 nsingp);
00822
00823
00824 goto L1050;
00825 }
00826 }
00827 } else {
00828
00829
00830 if (1) {
00831
00832 if (!noRoomForDense) {
00833 int etasize =CoinMax(4*fact->nnentu+(nnetas-fact->nnentl)+1000,fact->eta_size);
00834 noRoomForDense=ndense;
00835 fact->eta_size=CoinMin(static_cast<int>(1.2*fact->eta_size),etasize);
00836 if (fact->maxNNetas>0&&fact->eta_size>
00837 fact->maxNNetas) {
00838 fact->eta_size=fact->maxNNetas;
00839 }
00840 }
00841 }
00842 }
00843 }
00844 #endif
00845 }
00846
00847 L1050:
00848 {
00849 int iput = c_ekkrwcs(fact,dluval, hcoli, mrstrt, hinrow, mwork, nfirst);
00850 kmxeta += xnewro - iput;
00851 xnewro = iput - 1;
00852 ++ncompactions;
00853 }
00854
00855 nnentu = xnewro;
00856
00857 mwork[nrow+1].pre = nfirst;
00858 mwork[nrow+1].suc = nlast;
00859
00860 fact->nnentl = nnentl;
00861 fact->nnentu = nnentu;
00862 fact->kmxeta = kmxeta;
00863 *xnewrop = xnewro;
00864 *ncompactionsp = ncompactions;
00865
00866 return (irtcod);
00867 }
00868 #endif
00869