#
# Linear programming model for solving the available bandwidth on the system.
# @author: dhiguero
#

#set Elements := {'e1', 'e2', 'e3', 'e4', 'e5', 'e6'};
set Elements := {'e1', 'e2', 'e3', 'e4'};
set Type := {'A', 'B'};

param min_type_A := 1;
param min_type_B := 1;
param max_type_A := 2;
param max_type_B := 2;

param Ma := 90;
param Mb := 90;
param MaxBandwidth := 100;

param element_cost_per_type {t in Type};
param bandwidth_per_type {t in Type};

var min_bandwidth {source in Elements, dest in Elements}, binary;
var elementType {e in Elements, t in Type}, binary;
var bandwidth {e in Elements}, >= 0;
var bandwidth_ij {source in Elements, dest in Elements}, >= 0;

minimize total_element_cost: (sum{e in Elements, t in Type} elementType[e, t]);

###############################################################################
# 1.- Constraints regarding minimum number of elements of each type.
###############################################################################

s.t. oneTypePerElement{e in Elements} : sum{t in Type} elementType[e, t] <= 1;

s.t. checkMinTypeA: sum {e in Elements} elementType[e, 'A'] >= min_type_A;
s.t. checkMinTypeB: sum {e in Elements} elementType[e, 'B'] >= min_type_B;
s.t. checkMaxTypeA: sum {e in Elements} elementType[e, 'A'] <= max_type_A;
s.t. checkMaxTypeB: sum {e in Elements} elementType[e, 'B'] <= max_type_B;

###############################################################################
# 2.- Bandwidth availability between elements.
###############################################################################

s.t. available_bandwidth_on_elements {e in Elements}: bandwidth[e] == sum{t in Type} (elementType[e, t] * bandwidth_per_type[t]);

/* Restrictions suggested by Andrew Makhorin */
s.t. bandwidth_limit_by_source {source in Elements, dest in Elements} : bandwidth_ij[source, dest] <= bandwidth[source];
s.t. bandwidth_limit_by_target {source in Elements, dest in Elements} : bandwidth_ij[source, dest] <= bandwidth[dest];

/* Option suggested by Michael Hennebry */
s.t. eq1 {source in Elements, dest in Elements}: bandwidth_ij[source, dest] >= bandwidth[source] - (Ma*min_bandwidth[source, dest]);
s.t. eq2 {source in Elements, dest in Elements}: bandwidth_ij[source, dest] >= bandwidth[dest] - (Mb*(1-min_bandwidth[source, dest]));

/* Upper limit in c = min (a,b) -> c + c <= a + b */
s.t. eq3 {source in Elements, dest in Elements}: bandwidth_ij[source, dest] + bandwidth_ij[source, dest] <= bandwidth[source] + bandwidth[dest];

###############################################################################
/*
	Solve the problem and show the results.
*/
###############################################################################
solve;

printf "\nType Assignment\n";
printf "=======================================================================\n";
for {t in Type} {
	printf "\t%s", t;
}
printf "\n";
for { e in Elements} {
	printf "%s -", e;
	for{t in Type}{
		printf "\t%d", elementType[e, t];
	}
	printf "\n";
}
printf "---------------------------------\n";
printf "BW";
for { t in Type } {
	printf "\t%d", bandwidth_per_type[t]; 
}

printf "\n\nAvailable Bandwidth on each element\n";
printf "=======================================================================\n";
for {e in Elements}{
	printf "%s\t%d\n", e, bandwidth[e];
}

printf "\nAvailable Bandwidth between elements\n";
printf "=======================================================================\n";
for {e in Elements}{
	printf "\t%s", e;
}printf "\n";
for {source in Elements}{
	printf "%s", source;
	for {dest in Elements}{
		printf "\t%d", bandwidth_ij[source, dest];
	}
	printf "\n";
}printf "\n";

printf "\nDetailed result\n";
printf "=======================================================================\n";
printf "Number elements: %d\n", sum{e in Elements, t in Type} elementType[e, t];
printf "Elements cost: %d\n", (sum{e in Elements, t in Type} elementType[e, t] * element_cost_per_type[t]);

data;

param element_cost_per_type := A 15
				B 10;

param bandwidth_per_type := A 100
				B 50;

end;