Por favor no me envíen más correos, no pertenezco al grupo!!
El El vie, oct. 6, 2023 a la(s) 5:32 p.m., Leonardo Corato <[email protected]>
escribió:
> Thank you very much Michael,
> and sorry for missing the maling list and sending the email directly to
> you.
>
> I applied
> s.t. fred{b in 1..n, t in mouldTypes}: sum{i in I: mo[i]==t} x[i, b] <= 2 ;
> doesn't limit the types to max 2.
>
> To check whether s.t. fred worked properly, I added some printf statements
> between solve and data:
>
> solve;
>
>
> printf "Min number of bins used: %d \n", obj;
> for {j in J: sum{i in I} x[i,j] != 0} {
> printf "Bin %d # items: %d - Total weight: %d - Filling %% %d \n", j,
> sum{i in I} x[i,j], sum{i in I} w[i] * x[i,j], sum{i in I} w[i] * x[i,j] /
> cmax * 100 ;
> printf "Item Batch Alloy Mould\n";
> for {i in I: x[i,j]==1} {
> printf "%3d %s %d %s\n",i ,ba[i] ,al[i],mo[i];
> }
> printf "mold types: %d\n", card(setof{i in I: x[i,j]==1} mo[i] );
>
>
> }
>
>
> data;
>
>
> When run, I got:
>
> Min number of bins used: 4
> Bin 1 # items: 4 - Total weight: 254 - Filling % 85
> Item Batch Alloy Mould
> 1 H27587V 2502 P27795
> 2 H27587V 2502 P27795
> 9 H27587V 2502 P27532
> 10 H27587V 2502 P27532
> mold types: 2
> Bin 2 # items: 5 - Total weight: 288 - Filling % 96
> Item Batch Alloy Mould
> 5 H27587V 2502 P12396
> 6 H27587V 2502 P12396
> 11 H27587V 2502 P27532
> 12 H27587V 2502 P27532
> 15 H27587V 2502 P35495
> mold types: 3
> Bin 3 # items: 4 - Total weight: 290 - Filling % 97
> Item Batch Alloy Mould
> 3 H27587V 2502 P27795
> 4 H27587V 2502 P27795
> 13 H27587V 2502 P27532
> 14 H27587V 2502 P35495
> mold types: 3
> Bin 4 # items: 3 - Total weight: 204 - Filling % 68
> Item Batch Alloy Mould
> 7 H27587V 2502 P12396
> 8 H27587V 2502 P12396
> 16 H27587V 2502 P35495
> mold types: 2
> Model has been successfully processed
>
> As you can see in bin 2 and 3 there are 3 mold types, so sadly s.t. fred
> is not limiting to 2
> I also tried
> s.t. cardset{j in J}: card(setof{i in I: x[i,j] == 1} mo[i] ) <= 2;
> which is the same I used in printfs to check how many type of items are
> in every bin j, but it seems that this expression can't be used inside an
> s.t.
>
>
> Il giorno gio 5 ott 2023 alle ore 21:28 Michael Hennebry <
> [email protected]> ha scritto:
>
>> I'm assuming the your e-mail was intended for the list.
>> I'm quoting most of it because the list does not have it.
>>
>> In either case, forget about what I wrote.
>> GMPL is more powerful than I remembered.
>>
>> I think the desired constraint is
>> fred{b in 1..n, t in mouldTypes} sum{i in I: mo[i]==t} x[i, b] <= 2 ;
>> The above two lines are duplicated at an appropriate point.
>> I did not add anything else.
>>
>> On Thu, 5 Oct 2023, Leonardo Corato wrote:
>>
>> > Thanks Michael, I understand.
>> > But what it is not clear to me is once I have the type and numbers for
>> > type how to do it:
>> > let's say there's this *data1.csv* having:
>> >
>> > ITEM,WEIGHT,ALLOY,BATCH,MOULD
>> > 1,85,2502,H27587V,P27795
>> > 2,85,2502,H27587V,P27795
>> > 3,85,2502,H27587V,P27795
>> > 4,85,2502,H27587V,P27795
>> > 5,63,2502,H27587V,P12396
>> > 6,63,2502,H27587V,P12396
>> > 7,63,2502,H27587V,P12396
>> > 8,63,2502,H27587V,P12396
>> > 9,42,2502,H27587V,P27532
>> > 10,42,2502,H27587V,P27532
>> > 11,42,2502,H27587V,P27532
>> > 12,42,2502,H27587V,P27532
>> > 13,42,2502,H27587V,P27532
>> > 14,78,2502,H27587V,P35495
>> > 15,78,2502,H27587V,P35495
>> > 16,78,2502,H27587V,P35495
>> >
>> >
>> > where WEIGHT is the weight I'll use in the bpp example of Andrew
>> Makhorin,
>> > alloy and batch are descriptive and mould is the type.
>> >
>> > My code is:
>> > set I;
>> > param w{it in I}, > 0; # Weight of item i (w[i])
>> > param al{it in I}; # Alloy
>> > param ba{it in I} symbolic; # Batch
>> > param mo{it in I} symbolic; # Mould
>> > table tab_items IN "CSV" "data1.csv" :
>> > I <- [ITEM], w ~ WEIGHT, al ~ ALLOY, ba ~ BATCH, mo ~ MOULD;
>> >
>> > printf{it in I}: "%d %d %s %s \n", it,w[it],ba[it], mo[it];
>> >
>> > set mouldTypes := setof{it in I} mo[it];
>> > # Count the distinct molds
>> > param cmt := card(mouldTypes);
>> > #display mouldTypes;
>> > display cmt;
>> >
>> > #param itemCounts{ti in mouldTypes};
>> > param itemCounts{ti in mouldTypes} := sum{i in I: mo[i] = ti} 1;
>> >
>> > for {ti in mouldTypes} {
>> > printf "Mould Type: %s, Item Count: %d\n", ti, itemCounts[ti];
>> > }
>> >
>> > # total number of items
>> > param m := card(I),>0;
>> > printf "Number of items: %d \n", m;
>> >
>> > # Bin capacity
>> > param cmax, > 0;
>> >
>> > /* We need to estimate an upper bound of the number of bins sufficient
>> > to contain all items. The number of items m can be used, however, it
>> > is not a good idea. To obtain a more suitable estimation an easy
>> > heuristic is used: we put items into a bin while it is possible, and
>> > if the bin is full, we use another bin. The number of bins used in
>> > this way gives us a more appropriate estimation. */
>> >
>> > param z{i in I, j in 1..m} :=
>> > # z[i,j] = 1 if item i is in bin j, otherwise z[i,j] = 0
>> >
>> > if i = 1 and j = 1 then 1
>> > # put item 1 into bin 1
>> >
>> > else if exists{jj in 1..j-1} z[i,jj] then 0
>> > # if item i is already in some bin, do not put it into bin j
>> >
>> > else if sum{ii in 1..i-1} w[ii] * z[ii,j] + w[i] > cmax then 0
>> > # if item i does not fit into bin j, do not put it into bin j
>> >
>> > else 1;
>> > # otherwise put item i into bin j
>> >
>> > check{i in I}: sum{j in 1..m} z[i,j] = 1;
>> > # each item must be exactly in one bin
>> >
>> > check{j in 1..m}: sum{i in I} w[i] * z[i,j] <= cmax;
>> > # no bin must be overflowed
>> >
>> > param n := sum{j in 1..m} if exists{i in I} z[i,j] then 1;
>> > /* determine the number of bins used by the heuristic; obviously it is
>> > an upper bound of the optimal solution */
>> >
>> > set J := 1..n;
>> > # set of bins
>> >
>> > var x{i in I, j in J}, binary;
>> > # x[i,j] = 1 means item i is in bin j
>>
>> I think the desired constraint is
>> fred{b in 1..n, t in mouldTypes} sum{i in I: mo[i]==t} x[i, b] <= 2 ;
>>
>> > var used{j in J}, binary;
>> > # used[j] = 1 means bin j contains at least one item
>> >
>> > s.t. one{i in I}: sum{j in J} x[i,j] = 1;
>> > # each item must be exactly in one bin
>> >
>> > s.t. limMax{j in J}: sum{i in I} w[i] * x[i,j] <= cmax * used[j];
>> > # if bin j is used, it must not be overflowed: can't exceed cmax
>> >
>> > minimize obj: sum{j in J} used[j];
>> > # objective is to minimize the number of bins used
>> >
>> > solve;
>> >
>> > data;
>> > param cmax := 300; # max weight
>> >
>> > end;
>> >
>> > So now I can see that I have 4 type of moulds,
>> > cmt = 4
>> > And each one ha n items:Mould Type: P27795, Item Count: 4
>> > Mould Type: P12396, Item Count: 4
>> > Mould Type: P27532, Item Count: 5
>> > Mould Type: P35495, Item Count: 3
>> > For a total of items:
>> > Number of items: 16
>> >
>> > So now I can say I have the params for type:
>> > ti, #typeitemCounts[ti] # number of items for
>> that
>> > type.
>> >
>> > Now, what it is not clear to me is: if I want max 2 types of n items for
>> > each bin how to achieve this goal.
>> >
>> > e.g in the same bin I can have 2 of P27795 and 2 of P12396 because the
>> > weight is : 85*2+63*2=296<300 and cardinality of #(P27795, P12396) is 2
>> > but I can't have 1 of P12396 and 1 of P12396 and 1 of P27532
>> because
>> > the weight is 85+63+42=190<300, fine, but the cardinality of #(P27795,
>> > P12396, ) is 3
>> >
>> > I tried adding a variable t[ti,j] like Makhorin did for z[i,j] , in
>> this
>> > case meaning 1 when there's a mould type ti in bin j ....but type must
>> be
>> > linked to i, because each item can be of just 1 mould type.
>> > So I tried with a t[ti,i], but in this case it is not bound to bin and
>> I
>> > need this.
>> > So I asked me if I just had to add ti as a third variable in z[i,j,ti]
>> but
>> > in this latter I would get that i can be of each type while each i is
>> just
>> > one type.
>> > Any tips?
>> >
>> > Il giorno mer 4 ott 2023 alle ore 20:08 Michael Hennebry <
>> > [email protected]> ha scritto:
>> >
>> >> On Sat, 30 Sep 2023, Leonardo Corato wrote:
>> >>
>> >>> param m := 6;
>> >>> param w := 1 50, 2 60, 3 30, 4 40, 5 40, 6 40;
>> >>> --> param t := 1 A, 2 B , 3 B, 4 C, 5 C, 6 C;
>> >>> param c := 100;
>> >>>
>> >>> end;
>> >>>
>> >>> I have to add a constraint so that the number of types for every bin
>> is
>> >>> limited to maximum 2.
>> >>>
>> >>> Each bin can contain a number of the same type of items (i.e. A) or
>> max 2
>> >>> different types (i.e. A and C).
>> >>> it is not regarding the number of items, of course, I can have
>> multiple
>> >>> items.
>
>
>>
>> --
>> Michael [email protected]
>> "Occasionally irrational explanations are required" -- Luke Roman
>>
>
