Originally posted by: Rym

When I run my model I obtain the correct result but that obtained by the engine is diffrent from my objective function

 

Exmaple:

dvar boolean lumda[V][P];
dexpr int O = sum( i in V, j in P) lumda[i][j];
dvar float R[P][D] in 0..1;
/*dvar float cpuc[P] in 0..1;
dvar float ramc[P] in 0..1;
dvar float diskc[P] in 0..1;*/
//dexpr float R[j in P][d in D]=(d==1)?cpuc[j]:(d==2)?ramc[j]:(diskc[j]);
dexpr float minx[j in P] = minl(R[j][1],(minl(R[j][2],R[j][3]))); 
dexpr int mini[j in P]=(minx[j]==R[j][1])*(1)+((minx[j]==R[j][2])&&(abs(minx[j]-R[j][1])>=epsilon))*(2)+((minx[j]==R[j][3])&&(abs(minx[j]-R[j][1])>=epsilon)&&(abs(minx[j]-R[j][2])>=epsilon))*(3);
dexpr float RW = sum (j in P,l in D) sum(minij in 1..3) (minij==mini[j])*(R[j][l]-R[j][minij]);
minimize RW;

 

The result in script journal : 

// solution (optimal) with objective -1.1
lumda=  [[0 1]
         [0 1]
         [0 1]
         [1 0]
         [1 0]]
R = [[0.4 0.4 0.6]
         [0 0 0.35]]
minx=  [0.4 0]
mini=  [1 1]
RW=0.55

 

Ps: the formula of objective function is the following : 

M   D

∑   ∑  (Rjl −Rjk), l ̸= k;

j=1 l=1

 

Thanks

#DecisionOptimization
#OPLusingCPLEXOptimizer

Hi,

can you try with

float epsilon=0.001;

?

regards

#DecisionOptimization
#OPLusingCPLEXOptimizer

Originally posted by: Rym

not working 

 

vms= ["xl" "xl" "l" "m" "xl" "xl" "l" "l" "xl" "m"]
 [8 8 4 2 8 8 4 4 8 2]
 [16 16 8 4 16 16 8 8 16 4]
 [250 250 150 100 250 250 150 150 250 100]
 [20 20]
 [40 40]
 [1000 1000]
// solution (integer optimal, tolerance) with objective 0
lumda=  [[0 0]
         [0 0]
         [0 0]
         [0 0]
         [0 0]
         [0 0]
         [0 0]
         [0 0]
         [0 0]
         [0 0]]
R = [[1 1 1]
         [1 1 1]]
minx=  [1 1]
mini=  [1 1]
RW=0
VMs= 0
PMs= 0

 The result is zero

#DecisionOptimization
#OPLusingCPLEXOptimizer

Hi,

range V=1..2;

 range P=1..2;

range D=1..3;

 

float epsilon=0.001;

float r[P][D]=[[0.4, 0.4, 0.6],
 [0, 0 ,0.35]] ;

 

 

 float minx2[j in P] = minl(r[j][1],(minl(r[j][2],r[j][3])));
 int mini2[j in P]=(minx2[j]==r[j][1])*(1)+((minx2[j]==r[j][2])&&(abs(minx2[j]-r[j][1])>=epsilon))*(2)+((minx2[j]==r[j][3])&&(abs(minx2[j]-r[j][1])>=epsilon)&&(abs(minx2[j]-r[j][2])>=epsilon))*(3);

 

dvar float R[P][D]; // in 0..1;

dexpr float minx[j in P] = minl(r[j][1],(minl(R[j][2],R[j][3])));
dexpr int mini[j in P]=(minx[j]==R[j][1])*(1)+((minx[j]==R[j][2])&&(abs(minx[j]-R[j][1])>=epsilon))*(2)+((minx[j]==R[j][3])&&(abs(minx[j]-R[j][1])>=epsilon)&&(abs(minx[j]-R[j][2])>=epsilon))*(3);

 

dexpr float RW = sum (j in P,l in D) sum(minij in 1..3) (minij==mini[j])*(R[j][l]-R[j][minij]);
minimize RW;

subject to
{
forall(p in P,d in D) ct:R[p][d]==r[p][d];
}

float RW2 = sum (j in P,l in D) sum(minij in 1..3) (minij==mini2[j])*(r[j][l]-r[j][minij]);
execute
{
writeln(minx);
writeln(minx2);

writeln(RW);
writeln(RW2);
}

gives

 

[0.4 0]
 [0.4 0]
0.55
0.55

Can you post your .mod and .dat so that other users can try what you did ?

regards

#DecisionOptimization
#OPLusingCPLEXOptimizer

Originally posted by: Rym

no solution with epsilon=0.001;

 

 

int mySeed;
execute{
        var now = new Date();
        mySeed = Opl.srand(Math.round(now.getTime()/1000));
}  

float epsilon=0.001;
int v = 2;
range V = 1..v;
int p=2;
int d=3;
range P = 1..p;
range D = 1..d;
int cpui[V];
int rami[V];
int diski[V];
int cpuj[P];
int ramj[P];
int diskj[P];
int VMmin=1;
int VMmax=4;
int cpum=20;
int ramm=40;
int diskm=1000;
string S[VMmin..VMmax]=["s","m","l","xl"];
int VM[i in V]=1+(rand() % (VMmax - VMmin+ 1));
string vms[i in V]=S[VM[i]];

execute VMS
{
var ofilevms = new IloOplOutputFile("resvmss.txt");
 writeln("vms=",vms);
for (var i in vms)
{ ofilevms.write("'",vms[i],"',");

if(vms[i]=="s")

  {
   cpui[i]=1;
   rami[i]=2;
   diski[i]=50;

   }
   
 else if(vms[i]=="m")
 {
   cpui[i]=2;
   rami[i]=4;
   diski[i]=100;
 
    
    }
    
  else if(vms[i]=="l")
  
  { cpui[i]=4;
   rami[i]=8;
   diski[i]=150;

 }   
   else
   
  {
   cpui[i]=8;

   rami[i]=16;
   diski[i]=250 ;

   
   } 
   
   
}
writeln(cpui);
writeln(rami);
writeln(diski);

};

execute PMS
{
 

for (var i in P)
{ 

   cpuj[i]=20;
   ramj[i]=40;
   diskj[i]=1000;
   
   }

   

writeln(cpuj);
writeln(ramj);
writeln(diskj);

};
 

 

//the model/problem definition

dvar boolean lumda[V][P];
dexpr int O = sum( i in V, j in P) lumda[i][j];
dvar float R[P][D];
dexpr float minx[j in P] = minl(R[j][1],(minl(R[j][2],R[j][3]))); 
dexpr int mini[j in P]=(minx[j]==R[j][1])*(1)+((minx[j]==R[j][2])&&(abs(minx[j]-R[j][1])>=epsilon))*(2)+((minx[j]==R[j][3])&&(abs(minx[j]-R[j][1])>=epsilon)&&(abs(minx[j]-R[j][2])>=epsilon))*(3);

dexpr float RW = sum (j in P,l in D) sum(minij in 1..3) (minij==mini[j])*(R[j][l]-R[j][minij]);

minimize RW;

//constraint

subject to{ 

//une machine virtuelle est hébergée par au plus une seule pm
  limit:
   forall( i in V)
     sum( j in P ) lumda[i][j] <= 1;
    
//la somme des vms hebergèes ne depasse pas le nombre de demandes satisfaites
        
forall(j in P)
  { res:
R[j][1]==(cpum-(sum(i in V) lumda[i][j]*cpui[i]))/cpum;
R[j][2]==(ramm-(sum(i in V) lumda[i][j]*rami[i]))/ramm;
R[j][3]==(diskm-(sum(i in V) lumda[i][j]*diski[i]))/diskm;

}

   
//la quantité de cpu consommée par les vms ne depasse pas la quantité de cpu de la pm j
   cpur:
      forall( j in P)
       sum( i in V) cpui[i]*lumda[i][j] <= cpuj[j];
        

//la quantité de ram consommée par les vms ne depasse pas la quantité de ram de la pm j
    ramr:
     forall( j in P)
       sum( i in V) rami[i]*lumda[i][j] <= ramj[j];

//la quantité de disk consommée par les vms ne depasse pas la quantité de disk de la pm 

    diskr: 
     forall( j in P)
       sum( i in V) diski[i]*lumda[i][j] <= diskj[j];
       
    //remplissage des ressources restante

}

{int} countPM={j | i in V,j in P:lumda[i][j]==1 };
int pm= card(countPM);

execute
{

writeln("lumda= ",lumda);
writeln("R =",R);
writeln("minx= ",minx);
writeln("mini= ",mini);
writeln("RW=",RW);
writeln("VMs= ",O);
writeln("PMs= ",pm);

}

#DecisionOptimization
#OPLusingCPLEXOptimizer

Originally posted by: Rym

The result of engine done a negatif or positif result ?

#DecisionOptimization
#OPLusingCPLEXOptimizer

Hi,

in CPLEX 12.7 I get

// solution (integer optimal, tolerance) with objective 0
lumda=  [[0 0]
         [0 0]]
R = [[1 1 1]
         [1 1 1]]
minx=  [1 1]
mini=  [1 1]
RW=0
VMs= 0
PMs= 0

regards

#DecisionOptimization
#OPLusingCPLEXOptimizer

Originally posted by: Rym

Thanks but it's no a good result

 

 

the good result should be like the following

lumda=  [[0 1]
         [0 1]
         [0 1]
         [1 0]
         [1 0]]
R = [[0.4 0.4 0.6]
         [0 0 0.35]]
minx=  [0.4 0]
mini=  [1 1]
RW=0.55

 

#DecisionOptimization
#OPLusingCPLEXOptimizer

Then you could write

float r[P][D]=[[0.4, 0.4, 0.6],
 [0, 0 ,0.35]] ;

and then

forall(p in P,d in D) R[p][d]==r[p][d];

in the subject to block.

And then you ll get some relaxations that will explain why this solution is not feasible.

If you add some labels in

forall(j in P)
  { res:
R[j][1]==(cpum-(sum(i in V) lumda[i][j]*cpui[i]))/cpum;
res2:R[j][2]==(ramm-(sum(i in V) lumda[i][j]*rami[i]))/ramm;
res3:R[j][3]==(diskm-(sum(i in V) lumda[i][j]*diski[i]))/diskm;

}

then you will get some relaxations and conflicts

 

#DecisionOptimization
#OPLusingCPLEXOptimizer

Originally posted by: Rym

not working but i think that the engine has not yet understanding the objectif function:

 

it's calculating :for this example

R = [[0.4 0.4 0.6]
         [0 0 0.35]]

 

 

RW= //the first line of R//((0.4-.0.4)+(0.4-0.6)+(0.4-0.4)+(0.4-0.6))+//the second line for R// ((0-0.35)+(0-0)+(0-0)(0-0.35)= -1.1

 

 

 

 

#DecisionOptimization
#OPLusingCPLEXOptimizer

Hi,

with

 

    range V=1..2;

     range P=1..2;

    range D=1..3;

     

    float epsilon=0.0001;

    float r[P][D]=[[0.4, 0.4, 0.6],
     [0, 0 ,0.35]] ;

     

     

     float minx2[j in P] = minl(r[j][1],(minl(r[j][2],r[j][3])));
     int mini2[j in P]=(minx2[j]==r[j][1])*(1)+((minx2[j]==r[j][2])&&(abs(minx2[j]-r[j][1])>=epsilon))*(2)+((minx2[j]==r[j][3])&&(abs(minx2[j]-r[j][1])>=epsilon)&&(abs(minx2[j]-r[j][2])>=epsilon))*(3);

     

    dvar float R[P][D]; // in 0..1;

    dexpr float minx[j in P] = minl(r[j][1],(minl(R[j][2],R[j][3])));
    //dexpr int mini[j in P]=(minx[j]==R[j][1])*(1)+((minx[j]==R[j][2])&&(abs(minx[j]-R[j][1])>=epsilon))*(2)+((minx[j]==R[j][3])&&(abs(minx[j]-R[j][1])>=epsilon)&&(abs(minx[j]-R[j][2])>=epsilon))*(3);
    dvar int mini[j in P];
     

    dexpr float RW = sum (j in P,l in D) sum(minij in 1..3) (minij==mini[j])*(R[j][l]-R[j][minij]);
    minimize RW;

    subject to
    {
    
    forall(j in P) (mini[j]==1)==(minx[j]==R[j][1]);
    forall(j in P) (mini[j]==2)==((minx[j]==R[j][2]) && !(minx[j]==R[j][1]));
    forall(j in P) (mini[j]==3)==((minx[j]==R[j][3]) && !(minx[j]==R[j][1]) && !(minx[j]==R[j][2]));
    
        
    
    forall(p in P,d in D) ct:R[p][d]==r[p][d];
    }

    float RW2 = sum (j in P,l in D) sum(minij in 1..3) (minij==mini2[j])*(r[j][l]-r[j][minij]);
    execute
    {
    writeln(minx);
    writeln(minx2);

    writeln(RW);
    writeln(RW2);
    }

you get rid of the discrepancy:

// solution (optimal) with objective 0.55
 [0.4 0]
 [0.4 0]
0.55
0.55

regards

#DecisionOptimization
#OPLusingCPLEXOptimizer

Originally posted by: Rym

what did you think about  this response ?

 

 

 

I think your problem comes from the fact that you are using the truth value of the expression minij==mini[j] and multiply this with a variable. This results in a quadratic objective (product of two variables) which is not convex. I think you can replace

dexpr float RW = sum (j in P,l in D) sum(minij in 1..3) (minij==mini[j])*(R[j][l]-R[j][minij]);

by this construct

dvar float replace[1..3][P][D];
dexpr float RW = sum (j in P,l in D) sum(minij in 1..3) replace[minij][j][l];

and these additional constraints

  forall(j in P,l in D) {
    forall (minij in 1..3) {
      mini[j] == minij => replace[minij][j][l] == (R[j][l]-R[j][minij]);
      mini[j] <= minij - 1 => replace[minij][j][l] == 0;
      mini[j] >= minij + 1 => replace[minij][j][l] == 0;        
    }
  }

I am not sure I got everything right but you should get the idea: don't use the truth value of mini[j]==minij in the expression, instead explicitly force some auxiliary variable in case mini[j]==minij.

#DecisionOptimization
#OPLusingCPLEXOptimizer