30 {
printf(
"DIRECT xBug=%d Pmeth=%d Pmet2=%d Pmet3=%d\\\\\n",
57 else if (
n==5)
fprintf(
FTRACE,
"FOURIER-MOTZKIN on CONSTRAINED VARIABLES");
70 {
int i,j,i00; i00=1 ;
74 for (i=i00 ; i<=
MC ; i++ )
133 fprintf(
FTRACE,
" \\begin{array}{rrrrrrrrrrrrrrrrrrrrrrrrr}\n");
138 int fleche,carre,carre2; fleche=carre=carre2=0;
143 for ( j=1 ; j <=
NX ; j++)
144 {
int boite; boite=0;
179 int carre2,
int ip2,
int jp2,
int fleche,
int ifl)
186 fprintf(
FTRACE,
" \\begin{array}{rrrrrrrrrrrrrrrrrrrrrrrrr}\n");
187 for ( i=ia ; i <= ib ; i++)
205 for ( j=1 ; j <=
NX ; j++)
211 if ((((fleche && i==ifl) || (carre && i==ip)) && j==jp)
212 || (carre2 && i==ip2 && j==jp2))
242 {
igvoir3(XX,ia,ib,0,0,0,0,0,0,0,0);
255 for ( i=1 ; i <=
MX ; i++)
256 for ( j=1 ; j <=
NX ; j++)
288 else if(i2==0)
fprintf(
FTRACE,
" useless inequality $y_{%d}$\\\\",
G(i));
290 " redundant inequality $y_{%d}$ compared with $y_{%d}$\\\\\n",
G(i),
G(i2));
291 if(
VISU>=
ZVR4)
igvoir3(XX,1,
MX,0,0,0,0,0,0,1,i);
296 "* Polyedron proved empty by GCD test on ligne%3d gcd=%2d\\\\\n",i,gcd);
301 {
if (
VISU<zvx)
return;
302 fprintf(
FTRACE,
"Let us compute vector ($\\alpha_1, \\alpha_2, \\alpha_3$)\
303 such that $%d \\alpha_1+ %d \\alpha_2=\\alpha_3=gcd(%d,%d)$\\\\\n",
306 $\\alpha_1=%d$, $\\alpha_2=%d$, $\\alpha_3=%d$\\\\\n",u1,u2,u3);
308 $\\alpha_2$, $%d/\\alpha_3$, $%d/\\alpha_3$, \n",a2,a1);
331 int za,
int zb,
int old1,
int old2,
int new1,
int new2)
335 else fprintf(
FTRACE,
"After applying the Extended Euclid Algorithm \
336 to the coefficients of both variables,\n");
357 {
int vi ;
float vfp,
epss;
epss=0.00001;
358 if (vf<0) vfp= -vf ;
else vfp= vf ;
360 if (vfp-vi<
epss)
return(1) ;
return(0) ;
363 {
Value borne;
float vf2;
364 if (
integrite(vf)) vf2=vf-0.5;
else vf2=vf;
365 if (vf2<0) borne=vf2;
else borne=vf2+1;
387 for (j=1 ; j<=
NX ; j++)
RR->a[ir][j]=
AK(ii,j);
398 {
RR->d[0]=0;
if (mini==1)
RR->e[0]=1 ;
else
401 for (j=1 ; j<=
NX ; j++)
RR->a[0][j]=0;
403 if (mini<0)
RR->e[0]= -1 ;
404 RR->state=0;
if (
MSR>=7)
for (j=1 ; j<=
NX ; j++)
RR->iname[j]=
B(j);
407 {
if (!r) {
fprintf(
FTRACE,
" REEL-PHASE %d:%13.6f \n",ph,
RR->x[0]);
return; }
415 {
int rsr,rd=0;
float rrd =0,rrp;
424 {
if (rd!=rsr)
fprintf(
FTRACE,
"DIVERGENCE DUAL:%d PRIMAL:%d\n",rd,rsr);
426 "REEL DUAL:%13.6f PRIMAL:%13.6f ECART:%13.6f\n",rrd,rrp,rrd-rrp);
449 if (XX==YY)
return(1);
if (XX->
state<0)
return(2); YY->
state=XX->
state;
467 for (i=1; i<= XX->
mx; i++) {
468 for (j=1; j<= XX->
nx; j++)
473 for (j=1; j<= XX->
nx; j++)
487 {
return((v>
NP && v<=
NV) || v<0);
527 for (j=1; j<=
NX; j++)
534 {
int i,j; XX->
cu=0; XX->
lu=0;
535 for (i=
IC1 ; i<=
MX ; i++)
if (
G(i)==iv) {XX->
lu=i;
return(-i);}
536 for (j=1 ; j<=
NX ; j++)
if (
B(j)==iv)
return(XX->
cu=j);
570 fprintf(stderr,
"\nDNDNDN JANUS WARNING, multiplication overflow");
616 Value pv,p2,p3,pd,pp,dn_tmp;
641 {
for (i=ipiv1; i<=ipiv2; i++)
651 for (j=1; j<=
NX; j++)
660 for (i=ipiv1; i<=ipiv2; i++)
665 for (j=1; j<=
NX; j++)
674 for (j=1; j<=
NX; j++)
679 {
for (i=ipiv1; i<=ipiv2; i++)
688 for (j=1 ; j<=
NX ; j++)
698 for (j=1 ; j<=
NX ; j++)
724 for (j=1; j<=
NX; j++)
754 "constrained feature of column %2d is specified by an inequality:\n",jx);
775 for (i=1 ; i<=
MX ; i++)
784 dn_tmp=
B(j1);
B(j1)=
B(j2) ;
B(j2)=dn_tmp;
785 for (i=1 ; i<=
MX ; i++)
794 v=
G(i1) ;
G(i1)=
G(i2) ;
G(i2)=v ;
796 for (j=1 ; j<=
NX ; j++)
822 for (i=
MX; i>=
IC1; i--)
830 for (i=1 ; i<
IC1 ; i++)
838 {
fprintf(
FTRACE,
"fourier-Motzkin 0 : variable $x_{%d}$ - inequalities:",
840 for (i=
MX ; i>=1 ; i--)
844 for (i=
MX ; i>=
IC1 ; i--)
853 {
for (jk=
NX ; jk>=1 ; jk--)
858 {
for (jk=
NX ; jk>=1 ; jk--)
879 {
for (i=
MX ; i>=
IC1 ; i--)
883 for (i=
MX ; i>=
IC1 ; i--)
895 {
int ip1=0,ip2=0,im1=0,im2=0,i,jk;
896 Value sk,rp1,rp2=0,rm1,rm2=0,dp1,dp2,dm1,dm2,ap1,ap2,am1,am2;
900 for (i=
MX ; i>=
IC1 ; i--)
919 "Fourier-Motzkin 2-2 variable $x_{%d}$ inequalities +: $y_{%d}$ $y_{%d}$ inequalities -: $y_{%d}$ $y_{%d}$\\\\\n",
B(j),
G(ip1),
G(ip2),
G(im1),
G(im2));
931 for (jk=
NX ; jk>=1 ; jk--) {
983 {
Value v1,v2,v3,t1,t2,t3,q;
996 if(
VISU>=zvx)
vzextgcd(XX, a1, a2, *pu1, *pu2, *pu3,zvx);
1003 for (j=j1 ; j<=j2 ; j++)
if (
value_abs(
AK(ik,j)))
return(j);
1005 for (j=j1 ; j>=j2 ; j--)
if (
value_abs(
AK(ik,j)))
return(j);}
1017 for (j=j1 ; j<=j2 ; j++)
1024 int iz,old1,old2,new1,new2;
1025 Value za,zb, u1,u2,u3;
1027 if (ja==jb)
XBUG(7);
1030 if (
VISU>=
ZVU1+2)
igvoir3(XX,1,
MX,1,i1,ja,1,i1,jb,1,i1);
1031 else if (
VISU>=
ZVU1+1)
igvoir3(XX,i1,i1,1,i1,ja,1,i1,jb,1,i1);
1035 for (iz=
MX ; iz>=1 ; iz--) {
1046 B(ja)=new1;
B(jb)=new2;
1047 if (
VISU)
vzunimod(XX,u1,u2,u3,za,zb, old1,old2,new1,new2);
1053 "Equation $e_{%d}$ does not include a unitary coefficient.\\\\\n",
G(i1));
1062 if (
VISU>=
ZVEV+1)
fprintf(
FTRACE,
"Now, a unitary coefficient is available for a gaussian elimination:\n");
1063 *pj1=jn1;
return(0);
1066 {
int vj=0,jn1=0,jn2=0;
1068 jn1=
jnsegment(XX,i1,jj,
NX);
if (jn1<0)
return(jn1);
1110 for (j2=1 ; j2<=
NX ; j2++) {
1136 {
coupe(XX,i1,i1,abpivot); ix=i1;
1144 if (
VISU>=
ZVCP1)
igvoir3(XX,1,
MX,1,i1,j1,1,ix,j1,1,i1);
1147 { ix=i1;
if (
VISU>=
ZVCP1)
igvoir3(XX,1,
MX,1,i1,j1,0,0,0,0,0);
1157 else if ((r=
ipivotage(XX,ix,j1)))
return(r);
1186 for (j=j1 ; j<=j2 ; j++)
1219 if (
VISU)
vzgcd(XX,i,0,viz);
return(-1);
1227 if (
VISU)
vzgcd(XX,i,gcd,viz);
return(-1);}
1242 {
int i,j,i1=0,j1,boul2,nn,nvn;
1245 {
fprintf(
FTRACE,
"{*} STEP DUAL ALL.I. ,NX=%3d,MX=%3d,t=%4d,CHOIXPIV=%d ",
1253 for (i=
IC1 ; i<=
MX ; i++)
1256 for (j=1 ; j<=
NX ; j++)
1265 for (tu=1 ; tu<=XX->
nturb ; tu++)
1277 {
int comptj,compp; compp=0;
1278 for (j=1 ; j<=
NX ; j++)
if (
AK(i1,j)<0)
1280 for (i=
IC1; i<=
MX; i++)
if (
DK(i) < 0)
1281 if (
AK(i,j)<0) ++comptj;
1282 if (comptj>compp) { compp=comptj; j1=j; }
1287 {
int comptj,compp; compp=0;
1290 for (i=
IC1 ; i<=
MX ; i++)
1292 if (comptj>compp) { compp=comptj; j1=j; }
1304 "surrogate inequality from %d inequalities\n",nn);
1305 mx1=
MX ;
if ((r=
newcut(XX)))
return(r);
1308 for (i=
IC1 ; i<=mx1 ; i++)
1326 if (boul2)
return(
VRVID); i1=
MX;
1333 {
if (r)
fprintf(
FTRACE,
"sortie dynam Dual constraints: OUI\\\\\n");
1334 else fprintf(
FTRACE,
"sortie dynam Dual constraints: non\\\\\n");
1340 if ((r=
build0(XX,i1,1,&j1)))
return(r);
1345 {
int tu; tu=XX->
nturb;
1365 {
int r,i,j,i1=0,j1=0,i3=0,bool1,lastit;
1366 float c1,c2,alpha=0,zeta ;
1376 {
fprintf(
FTRACE,
"IMIZATION function line %d (current value: ",i2);
1381 {
for (j=
NX ; j>
NTP ; j--)
1383 {
for (i=
IC1 ; i<=
MX ; i++)
1391 for (j=
NX ; j>=1 ; j--)
1394 for (i=
IC1 ; i<=
MX ; i++)
1398 if (
CHOIXPRIM<=1) selection=(bool1||zeta<alpha);
1399 else selection=(bool1 || ((zeta>=1.0)&&(zeta<alpha))
1400 || ((zeta<1.0)&&(zeta>alpha))
1401 || ((zeta<1.0)&&(alpha>=1.0)) );
1407 if (
CHOIXPRIM==1)
if (alpha<1.0) alpha=0;
1413 if (bool1)
return(
VRFIN);
1416 if (stopcout==9)
return(stopcout);
1423 if (stopcout && stopcout!=9)
1425 for (i=i2+1; i<
IC1 ; i++)
1433 {
int j ;
if (is==
id)
return;
1438 {
if (is==
id)
return;
1452 {
int icf,iopt,r,i,j,exicou;
1460 for (i=icf+1; i<
IC1; i++)
1483 {
if (!iopt)
XBUG(24);
1528 if (!nonfixe) ++
NEGAL;
return(0);
1553 if (ineq==0) ++
NEGAL;
1560 if (!(r=
presence(XX,v)))
XBUG(82);
if (r>0) c=r;
else l= -r;
1568 {
int j;
for (j=1; j<=
RR->nb; j++)
if (
RR->iname[
RR->b[j]]==iv)
return(j);
1573 {
int j ;
RR->d[id]=
RR->d[is] ;
1574 for (j=1 ; j<=
RR->n ; j++)
RR->a[
id][j] =
RR->a[is][j] ;
1579 RR->d[ir]= -
RR->d[ir] ;
1580 for (j=1 ; j<=
RR->n ; j++)
RR->a[ir][j] = -
RR->a[ir][j] ;
1584 for (i=1 ; i<=
RR->m ; i++)
if (
RR->g[i]==varia)
return(-i);
1585 for (i=1 ; i<=
RR->n ; i++)
if (
RR->b[i]==varia)
return(i);
1590 RR->d[0]=0;
if (mini==1)
RR->e[0]=1 ;
else RR->e[0]= -1 ;
1591 for (j=1 ; j<=
RR->nvar ; j++)
RR->a[0][j]=0;
1596 if (kost== 0) {
if (rvar<=RR->
n) ir= rvar;
else ir=
RR->n-rvar; }
1600 if (mini==1)
RR->e[0]=1 ;
1604 RR->inf[0]=
RR->inf[-ir]; *(
RR->pconor)=*(
RR->pconor+
RR->g[-ir]);
1606 RR->inf[0]=0; *(
RR->pconor)=*(
RR->pconor+
RR->b[ir]);
1608 RR->cost= kost;
return(ir);
1627 {
return((v<=NV && v>0));
1630 {
return(v>
NV+1 && v<
NV+
MC);
1641 {
int i,j,iv;
if (
MSR<6)
return(0);
1655 for (j=1 ; j<=
RR->nvar ; j++)
1664 for (i=1; i<=
RR->mcontr; i++)
1687 float rrv;
int r;
Value dn_tmp;
1696 if ((r=
phase2(XX,
RR,rvar,1)))
return(r);
1713 if (MSR<6 || XX->ilbound[iv])
1715 if ((r=
phase2(XX,
RR,rvar,-1)))
return(r);
1733 if (*first||rrv<XX->rrbest) { XX->
rrbest=rrv; XX->
vbest=iv; *first=0;}
1774 XX->
state=1;
return(0);
1779 for (iv=1; iv<=
NUMAX ; iv++)
1839 {
int iv,ns;
Value bl; ns=0;
1840 for (iv=1; iv<=
NUMAX; iv++)
1863 int r,up; *compb=1; XX->
bloquer=0; up=1;
1870 else if (
PCOMP==2) up=0;
1873 if (
MSR>=8&&
RR->state==0&&
RR->vc){
1897 if (
NV>10) tete=
NV-
NX;
else tete=10-
NX;
1914 if (
NV>10) tete =
NV -
NX;
else tete = 10 -
NX;
1926 if (
MSR>=8&&
RR->state==0) {
1952 if ((r=
recup(
UU,VV)))
return(r);
1958 RR->namev=ivb;
RR->vc =
hb(
RR,ivb);
1970 if (compb)
if ((r=
majb(XX,
UU,
RR))) {
1971 if (r!=99)
XBUG(96);
2021 int r,step,dispo;
float rsr;
2023 struct problem AYY,AZZ,AVV,AWW,*pty,*ptv,*ptw;
2086 int ca,v,uni; ++XX->
dyit; uni=0;
2088 {
printf(
"dynamic visualization\n");
2092 printf(
"passage dynamic iter no=%d ----------------\n",XX->
dyit);
2093 if (nd==1)
printf(
"dual dual dual dual dual dual iteration\n");
2095 printf(
"query: "); ca= getchar();
2099 if (ca==117) { uni=1;
printf(
"unimodular change "); }
2100 else if (ca==118) {
printf(
"visu= "); scanf(
"%2d",&v);
VISU=v;}
2108 else if (ca==100)
DYN=0;
2110 {
printf(
"System state will be vizualized\n");
2111 XX->
ftrace=fopen(
"/tmp/jtrace.tex",
"a") ;
2116 else if (ca!=10)
printf(
"commande %d?\n",ca);
2118 printf(
"another query: ");
2122 XX->
ftrace=fopen(
"/tmp/jtrace.tex",
"a") ;
2166 nlibre =0; prevnx = 0; stfou = 0;
2191 for (jojo=
NX; jojo>=1; jojo--)
2194 }
else if (
VISU>=
ZVEV+1)
fprintf(
FTRACE,
"Equation $e_{%d}$ includes a unitary coefficient.\\\\\n",
G(ik));
2195 if (
VISU>=
ZVEV+1)
igvoir3(XX,1,
MX,1,ik,jk,0,0,0,0,0);
2205 for (i=
IC1 ; i<=
MX ; i++)
2211 for (j=
NX ; j>=1 ; j--)
2214 int tplus,tmoins;
Value k; tplus= tmoins= 0 ;
2215 for (i=
MX ; i>=
IC1 ; i--)
2217 if (tplus==0||tmoins==0) {
2227 while (stfou==0 || (
NX<prevnx && nlibre)) {
2229 prevnx =
NX; nlibre=0 ; stfou++;
2230 {
for (j=
NX ; j>=1 ; j--)
2232 int tplus,tmoins,ip1=0,im1=0,tp2,tm2,i1;
Value sk,dkmin;
2233 tplus= tmoins= tp2= tm2=0 ; i1= -100000 ;
2235 for (i=
MX ; i>=
IC1 ; i--)
2254 if (i1 < 0) { nlibre++ ; continue ; }
2258 if (tplus==0||tmoins==0) {
fourier0(XX,j);
continue; }
2260 if (tp2==0||tm2==0) {
2261 if (tplus==1&&tp2==0) {
fourier1(XX,1,j,ip1);
continue;}
2262 else if (tmoins==1 && tm2==0 ) {
fourier1(XX, -1,j,im1);
continue; }
2263 else if (
PFOURIER>2 && tmoins==2 && tplus==2 ) {
fourier22(XX,j) ; continue ; }}}
2279 if (!nlibre)
NTP=
NX;
2286 for (jj=1 ; jj<=
NX ; jj++)
2295 for (i=
MX ; i>=
IC1 ; i--)
2301 if (
build1(XX,idk,jj) <0) {
2302 int absent ; absent=1;
2304 for (i=
MX ; i>=
IC1 ; i--)
2319 }
else if (
VARC==3) {
2322 for (i=
MX ; i>=1 ; i--) {
2330 for (j=
NX ; j>=1 ; j--)
2341 for (j=
NX ; j>=1 ; j--)
2343 int tplus,tmoins;
Value k;
2345 for (i=
MX ; i>=
IC1 ; i--)
2356 int i,u,i1,i2,exmx; exmx=
MX;
2358 for (i=
MX ; i>=
IC1 ; i--)
2363 for (i=
MX ; i>=
IC1 ; i--)
2365 for (i1=
MX ; i1>=
IC1+1 ; i1--)
2366 for (i2=i1-1 ; i2>=
IC1 ; i2--)
2390 fprintf(
FTRACE,
"Primal %d variables precr=%d comp=%d msr=%d dico=%d met3=%d met2=%d meth=%d - varc=%d choixpiv=%d crit=%d m8=%d\\\\\n",
NX,
PRECR,
PCOMP,
MSR,
PDICO,
PMET3,
PMET2,
PMETH,
VARC,
CHOIXPIV,
CRITERMAX,
REDON);
2408 int i,j,i1,i2,ifi,ni,ii2,mf,ncou,Ei;
2410 for (j=1 ; j<=
NV ; j++)
B(j)=j ;
2411 for (i=1 ; i<=
MC ; i++) {
2413 if ((
abs(Ei)==2)||(Ei==3)) {
2415 if ((
abs(Ei) ==2)&&(++ncou>1)) {
2422 if (Ei!=1 && Ei!= -1) {
2430 ii2=0;ifi=0;i1=mf;i2=mf+ni;
IC1=mf+1; ii2=
IC1-1+ni;
2432 for (i=1 ; i<=
MC ; i++) {
2433 int i3; i3=(
abs(Ei=
E(i))==2)? mf :(Ei==3)? ++ifi :(Ei) ? ++i1 :++i2;
2449 %d inequalities %d equalities\\\\\n",
NX,mf,ni,
MC-ni-mf);
2460 struct problem AVV;
struct rproblem ARR;
int suit1,suit2,su3,su,r,stopc;
2465 su3=suite/100; su=suite-100*su3; suit2=su/10; suit1=suite-10*suit2;
2468 if ((r=
init_janus(II,XX,suit1)))
return(r); stopc=0;
if (su3) stopc=9;
#define value_increment(ref)
#define value_mone_p(val)
#define int_to_value(i)
end LINEAR_VALUE_IS_INT
#define value_minus(v1, v2)
#define value_decrement(ref)
#define value_oppose(ref)
#define value_notzero_p(val)
#define value_uminus(val)
unary operators on values
#define value_notone_p(val)
#define value_direct_multiply(v1, v2)
#define value_assign(ref, val)
assigments
#define value_zero_p(val)
#define VALUE_TO_FLOAT(val)
#define value_addto(ref, val)
#define value_eq(v1, v2)
bool operators on values
#define value_division(ref, val)
#define value_plus(v1, v2)
binary operators on values
#define value_substract(ref, val)
#define value_div(v1, v2)
#define value_posz_p(val)
void fprint_Value(FILE *, Value)
#define A(i, j)
comp_matrice.c
#define ZVR1
redundant inequalities
#define VRESULT
................
#define AK(A, B)
...............
#define NSTEP
...............
#define ZVB
...............
#define ZVU1
Extended Euclid Algorithm
#define ZVI1
define ZVG3 3
#define ZVEV
define ZVU2 4
#define ZVCP1
define ZVC2 4
#define ZVG2
define ZVE4 4
#define MC
...............
#define FTRACE
=========================================================================
#define ZVA1
initial problem
#define ZVNPC
Non-negative variables
#define ZVVF
Variables status
#define MAXCOLONNES
(-) choix du pivot (simplexe primal)
#define VRFIN
.....................
static int failure(Pproblem XX, Pproblem UU, Pproblem VV, struct rproblem *RR)
static void fourier0(Pproblem XX, int j)
static int upperbound(Pproblem XX, struct rproblem *RR, int iv, int rvar, float epss)
static int cutbounds(Pproblem XX,struct rproblem *RR,int iv, int rvar,float epss)
static int init_janus(Pinitpb II, Pproblem XX, int suit1)
static int failuresp(Pproblem XX, struct rproblem *RR, int *compb)
static void integertoreal(Pproblem XX, struct rproblem *RR, int mini)
static void ajouter(Pproblem XX, Value sk, int ip1, int i)
fin fourier0
static void columntoline(Pproblem XX, int js, int id)
static int integrite(float vf)
=======================================================================
static int fluidline(Pproblem XX, int i)
static Value inequaldivision(Pproblem XX, int i)
static void integerrealline(Pproblem XX, struct rproblem *RR, int ii, int ir)
fprintf(FTRACE,"variable flottante=%14.7f dessus=%d dessous=%d\\\\\n", vf,dessus(vf),...
static void wvoir(Pproblem XX)
tatic void wvoir(Pproblem XX)
static int iprimal(Pproblem XX, int minimum, int i2, int stopcout)
static void voirfreq(Pproblem XX) /*****\/
static int phase2(Pproblem XX, struct rproblem *RR, int rvar, int mini)
static float localnewrsimplex(Pproblem XX, struct rproblem *RR, int min)
static void remettre(Pproblem XX, int in)
static void addedbound(Pproblem XX, int iv, Value borne)
static void vzemptycol(Pproblem XX, int j)
static void stepvoir(Pproblem XX) /**** acces pour mise au point janus *\/
static int satisfait(Pproblem XX)
static void celimination(Pproblem XX, int j1)
=========================================================================
static void vzredundant(Pproblem XX, int i, int i2)
static void symbold(Pproblem XX, int v)
static void copyline(Pproblem XX, int is, int id)
static void inhibit(Pproblem XX, int in)
========================= PROCEDURES FOR FAST ===========================
static int presence(Pproblem XX, int iv)
static int recherche(struct rproblem *RR, int varia)
static int findandmod(Pproblem XX, int v, Value k, int ineq)
static int ipivotage(Pproblem XX, int i1, int j1)
static int newcut(Pproblem XX)
static int majlowbounds(Pproblem XX, struct rproblem *RR, int ope)
static void etatfonctions(Pproblem XX)
static int gcdtest(Pproblem XX, int i, int *pj1, Value *ppivot, int viz)
=======================================================================
static int jsegment(Pproblem XX, int ik, int j1, int j2, Value p)
static int cutiteration(Pproblem XX, int i1, int j1, int turb)
static int pseudocopie(Pproblem XX, Pproblem YY, int condition)
static int dualentier(Pproblem XX)
=======================================================================
static void vzstep(Pproblem XX, int n)
static int makecolumnfree(Pproblem XX, int jx)
=========================================================================
static Value dessus(float vf)
static void permutec(Pproblem XX, int j1, int j2)
static int changing2(Pproblem XX, int i1, int ja, int jb)
static int cutline(Pproblem XX, int i)
static void vzextgcd(Pproblem XX, int a1, int a2, int u1, int u2, int u3, int zvx)
static int preparephase2(Pproblem XX, struct rproblem *RR, int rvar, int mini, int kost)
int isolve(Pinitpb II, Pproblem XX, int suite)
static int recup(Pproblem XX, Pproblem VV)
MMM4.
static Value correctm(Pproblem XX, Value k1, Value k2)
static int eclater(Pproblem XX, Pproblem UU, Pproblem VV, struct rproblem *RR)
static int jnsegment(Pproblem XX, int ik, int j1, int j2)
static void vidr(struct rproblem *RR)
static void vzcut(Pproblem XX, int i, int divisor, int i2)
static void symboldn(Pproblem XX,int v) /***************************\/
static void copyrline(struct rproblem *RR, int is, int id)
static int fast(Pproblem XX, Pproblem ZZ)
static void vznowstep(Pproblem XX)
static Value pgcd2in(Value z1, Value z2)
=======================================================================
static int inevariable(Pproblem XX, int v)
static int possible(Pproblem XX, int j)
=======================================================================
static void vzunimod(Pproblem XX, Value u1, Value u2, int u3, int za, int zb, int old1, int old2, int new1, int new2)
static void retirer(Pproblem XX, int i1)
static int ipivotage2(Pproblem XX, int i1, int j1, int ipiv1, int ipiv2, int vtu)
========================================================================
static void retirerineq(Pproblem XX, int i1)
static void badretirerineq(Pproblem XX,int i1) /***********************\/
static void permutel(Pproblem XX, int i1, int i2)
static void vzphase(Pproblem XX, int n)
static int choose(Pproblem XX, struct rproblem *RR)
static void igvoir3(Pproblem XX, int ia, int ib, int carre, int ip, int jp, int carre2, int ip2, int jp2, int fleche, int ifl)
static int modifyconstr(Pproblem XX, int jfixe, int ifixe, Value k, int ineq)
static Value pgcdsegment(Pproblem XX, int ik, int j1, int j2)
static void boundline(Pproblem XX, int io, Value bou)
static void igvoir(Pproblem XX, int ia, int ib)
fin igvoir3
static Value extgcd(Pproblem XX, Value a1, Value a2, Value *pu1, Value *pu2, Value *pu3, int zvx)
tatic int extgcd(Pproblem XX,int a1,int a2,int *pu1,int *pu2,int *pu3, int zvx) { int v1,...
static void anonymouscopyline(Pproblem XX, int is, int id)
fin iprimal ================================================
static int newfreevariable(Pproblem XX)
static void anonymctol(Pproblem XX, int js, int id)
========================== fin fast ===================================
static int reducedpb(Pproblem XX, Pproblem VV, struct rproblem *RR)
static int remise(Pproblem XX, int icf)
static Value dessous(float vf)
static void symbol(Pproblem XX, int v)
N note: if use janus.c then not static DN.
static int lowbound(Pproblem XX, struct rproblem *RR, int iv, int rvar, int *first, float epss)
static int iprimalplus(Pproblem XX, struct rproblem *RR, int minimum, int i2, int stopcout)
static int vzlast(Pproblem XX)
=======================================================================
static int freevariable(Pproblem XX, int v)
static int costvariable(Pproblem XX) /**************************\/
static int janus_egalite(Pproblem XX, int i)
=========================================================================
static int build1(Pproblem XX, int i1, int jj)
static int majb(Pproblem XX, Pproblem UU, struct rproblem *RR)
static void w1voir(Pproblem XX, int ix)
fin igvoir
static void vzgcd(Pproblem XX, int i, int gcd, int viz)
static int hb(struct rproblem *RR, int iv)
==================================================================
static int phase1(Pproblem XX, struct rproblem *RR)
static int reduction(Pproblem XX, struct rproblem *RR)
static int majuu(Pproblem XX, Pproblem UU, struct rproblem *RR)
static int redundant(Pproblem XX, int i1, int i2)
static void coupe(Pproblem XX, int i1, int i2, Value abpivot)
static int splitpb(Pproblem XX, Pproblem VV, struct rproblem *RR, int jfixe, int ifixe, Value k, int ineq)
static void fourier1(Pproblem XX, int pn, int j, int ip1)
integer fourier elimination criterion and:
static void razfreq(Pproblem XX)
fin dualentier
static void listehb(Pproblem XX, struct rproblem *RR)
static int freecolumn(Pproblem XX, int j)
static int cutcolumn(Pproblem XX,int j) /*****************************\/
static int copystructure(Pproblem XX, Pproblem YY)
tatic int copystructure(Pproblem XX,Pproblem YY)
static int fluidvariable(Pproblem XX, int v)
static int emptylhs(Pproblem XX, int i)
static int xdeb(Pproblem XX, int nu)
static void messrsimplex(Pproblem XX, struct rproblem *RR, int r, int ph)
static int build0(Pproblem XX, int i1, int jj, int *pj1)
static int xbug(Pproblem XX, int nu)
=========================================================================
static int addnonbasicbound(Pproblem XX, int jnb, Value nbb, int nonfixe)
static int is2(Pproblem XX, Pproblem VV, struct rproblem *RR)
=======================================================================
static void vid(Pproblem XX)
static void copybound(Pproblem XX, Pproblem YY)
static Value pgcd2(Value z1, Value z2)
fin fourier22
static Value pgcdseg(Pproblem XX, int ik, int j1, int j2)
static void term(Pproblem XX, int s, Value k, int x)
static void ucformula(Pproblem XX, Value u1, Value u2, int v, int new1, int new2)
static void voirbornes(Pproblem XX)
static int fastplus(Pproblem XX, Pproblem VV, struct rproblem *RR)
static void emptycolelim(Pproblem XX, int j1)
static Value cfloor(Value v1, Value v2)
=======================================================================
static Value boundssum(Pproblem XX)
static int corrects(Pproblem XX, Value k1, Value k2)
static Value dn_multiply(Value v1, Value v2)
========================================================================
static float localrsimplex(Pproblem XX, int min)
static void oppositeline(Pproblem XX, int io)
static int cutvariable(Pproblem XX, int v)
static int computebounds(Pproblem XX, struct rproblem *RR, int up)
static int dealtvariable(Pproblem XX, int v)
static void razcut(Pproblem XX)
static void razcoutr(struct rproblem *RR, int mini)
static int ajout(Pproblem XX)
static void rinverse(struct rproblem *RR, int ir)
static int useless(Pproblem XX, int i)
static void vznewstep(Pproblem XX, int n)
int dynam(Pproblem XX, int nd)
=======================================================================
static void fourier22(Pproblem XX, int j)
fin fourier1
void tableau_janus(Pinitpb II, Pproblem XX)
struct _newgen_struct_range_ * range
int realsimplex(Prproblem RR)
void elimination(Prproblem RR, int j1)
fin norm()
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
void pivot(frac *X, frac A, frac B, frac C, frac D, bool ofl_ctrl)
#define G(j, a, b)
maybe most of them should be functions?
static int line
FLEX_SCANNER.
=========================================================================
int remove
in any case non negative variables
int nvpos
nombre de fonctions et contraintes originales
int frequency[AKCOLONNES+1+AKLIGNES]
Value ilbound[AKCOLONNES+1+AKLIGNES]
float rbound[AKCOLONNES+1+AKLIGNES]
int dyn
numero "file system" pour "trace"
Value ibound[AKCOLONNES+1+AKLIGNES]
int ntrac2
niveau "trace" (execution accompagnee de commentaires) 0: aucune impression >= 1: volume d'informatio...
Value ak[AKLIGNES][AKCOLONNES]
float rlbound[AKCOLONNES+1+AKLIGNES]
int meth
redundant inequalities are removed
int choixprim
(0-1) choix du pivot (simplexe dual) 0 plus petit pivot 1 plus grand pivot
int varc
(3) elimination FOURIER-MOTZKIN 0: elimination non appliquee 1: cas triviaux ( >= 2: lorsque le nombr...
int utilb[AKCOLONNES+1+AKLIGNES]
int nvar
column in case of infinite vale of function
FILE * ftrace
nombre de variables originales contraintes (rangees en tete).
int mcontr
nombre de variables originales
int forcer
(0-1) introduction variables contraintes 0 "strategie simplexe" 1 pivot unitaire sinon "strategie sim...
int negal
nature contraintes 0 egalite 1 inequation <= -1 inequation >= 2 fonction a minimiser -2 fonction a ma...
Value tturb[30][AKCOLONNES]
int met2
(0-1) methode finale de resolution
float a[RMAXLIGNES+2][RMAXCOLONNES+1]
seconds membres
float x[RMAXLIGNES+RMAXCOLONNES+2]
void solution(Tableau *tp, int nvar, int nparm, Entier D)