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.
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 <
> hennebry@web.cs.ndsu.nodak.edu> 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.