Minimizing Multiple Functions

Question

I'm trying to write a script that will minimize a given set of functions. The homework problem I've been given lists a set of dietary information, and I'm supposed to build the optimal salad based on those parameters.

What I can't figure out is how to use the data returned by the Minimize function. The documentation for the Minimize function doesn't specify anything about it.

cost[tomatoe_, lettuce_, spinach_, carrot_, sunflower_, tofu_, chickpea_, oil_] := 1*tomatoe + .75*lettuce +
        .5*spinach + .5*carrot + .45*sunflower + 2.15*tofu + .95*chickpea + 2*oil

energy[tomatoe_, lettuce_, spinach_, carrot_, sunflower_, tofu_, chickpea_, oil_] := 21*tomatoe + 16*lettuce +
        40*spinach + 41*carrot + 585*sunflower + 120*tofu + 164*chickpea + 884*oil

protein[tomatoe_, lettuce_, spinach_, carrot_, sunflower_, tofu_, chickpea_, oil_] := .85*tomatoe + 1.62*lettuce +
        2.86*spinach + 0.93*carrot + 23.4*sunflower + 16.00*tofu + 9.0*chickpea + 0*oil

fat[tomatoe_, lettuce_, spinach_, carrot_, sunflower_, tofu_, chickpea_, oil_] := 0.33*tomatoe + 0.20*lettuce +
        0.39*spinach + 0.24*carrot + 48.7*sunflower + 5*tofu + 2.6*chickpea + 100.00*oil

carbs[tomatoe_, lettuce_, spinach_, carrot_, sunflower_, tofu_, chickpea_, oil_] := 4.64*tomatoe + 2.37*lettuce +
        3.63*spinach + 9.58*carrot + 15.00*sunflower + 3.00*tofu + 27.0*chickpea + 0*oil

sodium[tomatoe_, lettuce_, spinach_, carrot_, sunflower_, tofu_, chickpea_, oil_] := 9.00*tomatoe + 28.00*lettuce +
        65.00*spinach + 69.00*carrot + 3.80*sunflower + 120.00*tofu + 78.00*chickpea + 0*oil

data = Minimize[{energy[tomatoe,lettuce,spinach,carrot,sunflower,tofu,chickpea,oil],
        tomatoe >= 0
        && lettuce >= 0
        && spinach >= 0
        && carrot >= 0
        && sunflower >= 0
        && tofu >= 0
        && chickpea >= 0
        && oil >= 0
        && protein[tomatoe,lettuce,spinach,carrot,sunflower,tofu,chickpea,oil] >= 15
        && 2 <= fat[tomatoe,lettuce,spinach,carrot,sunflower,tofu,chickpea,oil] <= 8
        && sodium[tomatoe,lettuce,spinach,carrot,sunflower,tofu,chickpea,oil] <= 200
        && carbs[tomatoe,lettuce,spinach,carrot,sunflower,tofu,chickpea,oil] >= 4
        && ((lettuce + spinach)/(tomatoe+lettuce+spinach+carrot+sunflower+tofu+chickpea+oil)) >= .40
        },
        {tomatoe,lettuce,spinach,carrot,sunflower,tofu,chickpea,oil}
]

Print[cost[data["tomato"], data["lettuce"], data["spinach"], data["carrot"], data["sunflower"], data["tofu"], data["chickpea"], data["oil"]]]

Export["out.csv", data, "csv"]

Answer 1

Just use the following instead of your print statement:

Print[cost[tomatoe, lettuce, spinach, carrot, sunflower, tofu, chickpea, oil] /. data[[2]] ]

(* Out: 2.32728 *)

The Minimize function returns the following data structure:

{114.754, {tomatoe -> 1.72651*10^-8, lettuce -> 0.58548, spinach -> 3.53893*10^-8, carrot -> 8.48321*10^-9, sunflower -> 9.69807*10^-10, tofu -> 0.87822, chickpea -> 3.3596*10^-9, oil -> 4.43666*10^-10}}

The first value in the list is the value of the function you minimized at the minimum. The second part is a list of the variable values at that minimum, provided as a replacement list. data[[2]] extracts that replacement list. With that, lettuce /. data[[2]] gives you for instance the value of the lettuce variable.

---

By the way, if all you need is to show the value, you don't need Print. The expression

cost[tomatoe, lettuce, spinach, carrot, sunflower, tofu, chickpea, oil] /. data[[2]]

will be evaluated to its value and that value will be returned. You may still need Print, however, if you intend to put this code e.g. inside a Module, or a function, etc. where it is not the last evaluated expression.

Answer 2

data returns:

{114.754, {tomatoe -> 1.72651*10^-8, lettuce -> 0.58548, 
           spinach -> 3.53893*10^-8, carrot -> 8.48321*10^-9, 
           sunflower -> 9.69807*10^-10, tofu -> 0.87822,
           chickpea -> 3.3596*10^-9, oil -> 4.43666*10^-10}}

Where 114.754 is the minimum total energy with the constraints you have given. And the values (quantities, I guess) of each individual food are listed as replacement rules.

In other words, Minimize returns the minimized value, as well as a list of rules to actually minimize whatever you were minimizing. Not a dataset or a function or anything like that. Just a list of rules.

You should note that data is not a function, but merely the output listed above.

In any case, you want the replacement rules without the total energy. The second (last) part of data. For example:

rules = Last[data];
tomatoe /. rules
(* 1.72651*10^-8 *)

cost[tomatoe, lettuce, spinach, carrot, sunflower, tofu, chickpea, oil] /. rules
(* 2.32728 *)

For bedtime reading:
1;

2.

Answer 3

The LinearProgramming[...] solution. Recall the canonical minimization form for linear programming:

\begin{align} \mathrm{minimize}\ \mathbf{c}^\mathrm{T}\mathbf{x} \ \mathrm{subj\ to:\\} \mathbf{Ax}\ge \mathbf{b} \mathrm{\ and \ } \mathbf{x\ge0} \end{align}

In the interest of keeping this answer simple and informative, we can throw out the nonlinear constraint on (lettuce + spinach)/(...rest...) >= 0.4 because it has a very small effect on the answer except to spread tiny quantities like 10^-8 around (this constraint is what made Minimize slow).

First we have to get the constraint matrix in its minimization form; whenever a $\le$ constraint appears we multiply the row and constraint by -1. In the case of the $2\le(\dots)\le8$ constraint we can ignore the 8 and just write this as $(\dots)\ge 2$ (we could add another constraint if we wanted but it makes little difference in this case). The matrix $\mathbf{A}$ (referred to as m in the LinearProgramming documentation), energy $\mathbf{c}$ and constraint vector $\mathbf{b}$ are now:

c = {21, 16, 40, 41, 585, 120, 164, 884}; (* energy objective*)
(* constraint matrix A, called m here*)
m = {{0.85, 1.62, 2.86, 0.93, 23.4, 16.0, 9.0, 0}, (*protein*)
     {0.33, 0.2, 0.39, 0.24, 48.7, 5, 2.6, 100}, (*fat*)
    -{9, 28, 65, 69, 3.8, 120, 78, 0}, (*sodium*)
     {4.64, 2.37, 3.63, 9.58, 15, 3, 27, 0}}; (*carbs*)
b = {15, 2, -200, 4}; (* constraint values *)
quantities = LinearProgramming[c, m, b];
bestEnergy = quantities.c;
Print["Cost: ", cost @@ quantities]
(* result 2.32155
  for quantities: 
  0.5747126436781611` lettuce
  0.8793103448275861` tofu *)

The result is lower by a tiny amount probably because we chucked out the nonlinear constraint.