Related
I need help with this homework. i just can't find the error. please help me
A company produces five different types of beer and wants to maximise the possible contribution margin by optimising the production quantities. The contribution margin that can be achieved by the different types of beer is shown in the following table:
Variety DB per litre
A 1,9 €
B 1,9 €
C 1,8 €
D 1,4 €
E 1,8 €
The table below shows both the filling time (AD) and the raw material consumption (RV) for one litre of the respective beer varieties:
Variety AD RV1 RV2 RV3
A 2 1,3 1,65 1
B 1,45 1,8 1 1
C 1,2 1,55 1,3 1,4
D 1 1,2 2,1 1,5
E 1,75 1 1 1,55
The filling of the different varieties takes place on the same equipment. Theoretically, a daily bottling quantity of 4000 l of beer type A is possible while maintaining the time capacity, if no other type is produced. The daily supply of raw materials 1, 2 and 3 is as follows:
Raw material units
1 7400
2 7100
3 5900
The maximum daily demand for the products is constant and only differs between the different varieties. The maximum demand for each variety is shown in the table below:
Variety max. demand
A 2100 l
B 950 l
C 1100 l
D 1500 l
E 1550 l
Since the beer types B and C as well as the types A and D each address the same target group, a maximum of 1400 l of B and C or 2700 l of A and D should be produced in total in order to reduce the entrepreneurial risk due to a drop in sales.
Task: Describe the production problem using a linear optimisation model and determine the optimal daily production quantities of the individual beer types.
!pip install pulp
import pulp
solver_list = pulp.listSolvers(onlyAvailable=True)
print(solver_list)
lp_problem = pulp.LpProblem("LPProblem", pulp.LpMaximize)
x1 = pulp.LpVariable('x1', lowBound=0, cat='Continuous')
x2 = pulp.LpVariable('x2', lowBound=0, cat='Continuous')
x3 = pulp.LpVariable('x3', lowBound=0, cat='Continuous')
x4 = pulp.LpVariable('x4', lowBound=0, cat='Continuous')
x5 = pulp.LpVariable('x5', lowBound=0, cat='Continuous')
lp_problem += 1,9 * x1 + 1,9 * x2 + 1,8 * x3 + 1,4 * x4 + 1,8 * x5, "Z"
lp_problem += 2 * x1 <= 4000
lp_problem += 1,3 * x1 + 1,8 * x2 + 1,55 * x3 + 1,2 * x4 + 1 * x5 <= 7400
lp_problem += 1,65 * x1 + 1 * x2 + 1,3 * x3 + 2,1 * x4 + 1 * x5 <= 7100
lp_problem += 1 * x1 + 1 * x2 + 1,4 * x3 + 1,5 * x4 + 1,55 * x5 <= 5900
lp_problem += x1 <= 2100
lp_problem += x2 <= 950
lp_problem += x3 <= 1100
lp_problem += x4 <= 1500
lp_problem += x5 <= 1550
lp_problem += x1 + x4 <= 2700
lp_problem += x2 + x3 <= 1400
print(lp_problem)
lp_problem.solve()
print("Status:", pulp.LpStatus[lp_problem.status])
for variable in lp_problem.variables():
print("{} = {}".format(variable.name, variable.varValue))
print("Deckungsbeitrag =",pulp.value(lp_problem.objective))
Error Message:
i'm writing a simple function in prolog (beginer). Function calculates a specific type of quadratic equation (but this is not important, calculations are correct).
liniowa(A, B, R, W) :-
Delta is 4*A*A*R - 4*B*B + 4*R,
( Delta < 0
-> false
; ( Delta == 0
-> X is -B/(2*A),
Y is A*X + B,
W = punkt(X, Y)
; X1 is (-B + sqrt(Delta)) / (2*A),
Y1 is A*X1 + B,
X2 is (-B - sqrt(Delta)) / (2*A),
Y2 is A*X2 + B,
writeln(X1), writeln(Y1), writeln(X2), writeln(Y2),
W = punkt(X1, Y1) ; W = punkt(X2, Y2)
)
).
When i run this function, i receive warnings:
Singleton variable in branch: X2
Singleton variable in branch: Y2
In the result i receive strange things. In writeln(X2), writeln(Y2) everything is ok, but then there is sth strange in punkt(X2, Y2):
1.4142135623730951
1.4142135623730951
-1.4142135623730951
-1.4142135623730951
W = punkt(1.4142135623730951, 1.4142135623730951)
W = punkt(_1344, _1346)
What's happening? How should I make it?
The syntax of ->/2 is horrendous at the best of times. That no official better syntax has been developed in 30 years is a sad statement, but of what? I won't say anything more about this.
It is best to separate out the program parts into separate predicates.
(A further refinement could be to separate out the case "Delta == 0" into a dedicated delta_positive(A,B,W), thus avoiding having to make a decision on delta_positive/4 and thus cutting and guarding.
liniowa(A, B, R, W) :-
Delta is 4*A*A*R - 4*B*B + 4*R,
( Delta < 0 -> false ; delta_positive(Delta,A,B,W) ).
delta_positive(0,A,B,W) :-
!, % commit to this clause
X is -B/(2*A),
Y is A*X + B,
W = punkt(X,Y).
delta_positive(Delta,A,B,W) :-
Delta \== 0, % superfluous, but makes things clear
!, % commit is also superfluous
X1 is (-B + sqrt(Delta)) / (2*A),
Y1 is A*X1 + B,
X2 is (-B - sqrt(Delta)) / (2*A),
Y2 is A*X2 + B,
format("X1=~q, Y1=~q, Y2=~q, Y2=~q\n",[X1,Y1,X2,Y2]),
(W = punkt(X1, Y1) ; W = punkt(X2, Y2)).
This immediately shows that parantheses are missing around the expression:
(W = punkt(X1, Y1) ; W = punkt(X2, Y2)).
I tried solving it:-
liniowa(A, B, R, W) :-
Delta is 4*A*A*R - 4*B*B + 4*R,
( Delta < 0
-> false
; ( Delta == 0
-> X is -B/(2*A),
Y is A*X + B,
W = punkt(X, Y)
; X1 is (-B + sqrt(Delta)) / (2*A),
Y1 is A*X1 + B,
X2 is (-B - sqrt(Delta)) / (2*A),
Y2 is A*X2 + B,
writeln(X1), writeln(Y1), writeln(X2), writeln(Y2),
W = punkt(X1, Y1) ); X2 is (-B - sqrt(Delta)) / (2*A),
Y2 is A*X2 + B, W = punkt(X2, Y2)
).
?-liniowa(2, 3, 4, W).
0.9083123951776999
4.8166247903554
-2.4083123951777
-1.8166247903553998
W = punkt(0.9083123951776999, 4.8166247903554)
W = punkt(-2.4083123951777, -1.8166247903553998)
I believe that in your code the calculation is being done in the previous step, that's why it is unable to pick it in the last case.
I am using version 2.9.9 of cbc in ubuntu 17.10 docker image. My test.lp file has following content:
Maximize
obj: x1 + 2 x2 + 3 x3 + x4
Subject To
c1: - x1 + x2 + x3 + 10 x4 <= 20
c2: x1 - 3 x2 + x3 <= 30
c3: x2 - 3.5 x4 = 0
Bounds
0 <= x1 <= 40
2 <= x4 <= 3
General
x4
Semis
x1 x2 x3
When trying with semis section i get error "terminate called after throwing an instance of 'CoinError?' Aborted"
on mac i get: libc++abi.dylib: terminating with uncaught exception of type CoinError? Abort trap: 6
However if I comment out Semis it works fine. I was hoping that Semis are supported. Am I doing something wrong?
My command is : cbc -presolve on -import test.lp solve solu out.txt
On further analysis i found out when in cbc prompt i type "import test.lp" it fails and shows same error is
The CBC MPS file reader seems not to accept SC bounds either. I think CBC actually supports semi-continuous variables (I tested with a small GAMS model) but it seems difficult to pass it on in an LP or MPS file. As a work around, I would suggest to use binary variables to model semi-continuous behavior:
b * L ≤ x ≤ b * U
b in {0,1}
Consider {<1,2>, <1,3>, <1,7>, <0,4>} as the set of tuples of a relation R. Now consider that R is represented (via its membership function) by a BDD. That is, The BDD representing R depends on variables {x1,x2, y1, y2, y3} where {x1, x2} are used to represent the first element of every tuple and {y1, y2, y3} are used to represent the second element.
Now, consider the problem of finding the set of tuples that have unique values in its first element. For the relation above that set would be {<0,4>}. All the other elements are discarded as they are more than one value having 1 in the first component.
As a second example consider the relation with set of tuples {<1,2>, <1,3>, <1,7>, <2,3>, <2,5>, <0,4>}. In such a case the expected result is still {<0,4>} as 2 appears more than once as first element.
The problem can be also seen as abstracting away the variables {y1,y2,y3} such that only unique values for {x1,x2} remain. With this result, the expected relation can be reconstructed by computing the conjunction of the resulting BDD with the input one.
In summary, the the question is: which are the BDD operations that have to be performed on The representation of R to obtain the BDD with only the unique tuples.
Notice that this is a genralization of this question
EDIT 1:
The following code reflects the implementation I have so far. However, I am wondering if it is possible to get a more efficient version. For simplicity I intentionally omit the handling of the computed table (crucial to get better time complexity). Additionally, I use &, | and ! to denote the conjunction, disjunction and complement operations on BDDs.
BDD uniqueAbstract(BDD f, BDD cube) {
if ((f.IsZero() || f.IsOne()) && !cube.IsOne())
return zero();
BDD T = high(f);
BDD E = low(f);
if(level(f) == level(c)) { // current var is abstracted
BDD uniqueThen = uniqueAbstract(T, high(c));
BDD existElse = existAbstract(E, high(c));
BDD existThen = existAbstract(T, high(c));
BDD uniqueElse = uniqueAbstract(E, high(c));
return (uniqueThen & !existElse) | (uniqueElse & !existThen)
} else {
BDD uniqueThen = uniqueAbstract(T,c);
BDD uniqueElse = uniqueAbstract(E,c);
return ite(top(f), uniqueThen, uniqueElse);
}
}
EDIT2: After trying three different implementations there are still some performance issues. Let me describe the three of them.
A C implementation of my approach, let me call it the reference implementation4.
The implementation proposed by user meolic in the accepted answer3.
A hybrid approach between the two and available2.
The goal of this update is to analyze a bit the results from using the three approaches. As time measures seem misleading at this time to judge them, I decided to evaluate the implementations on a different set of measures.
Recursive calls
Cache hits
Abstract simple. Number of times the function call was solved without requiring existential abstraction.
Abstract complex: Number of times the function call was solved requiring existential abstraction.
Exist abstract: Number of calls to the existential abstraction.
The results for implementation 1: (21123 ms):
Unique abstraction statistics:
Recursive calls: 1728549.000000
Cache hits: 638745.000000
Non abstract: 67207.000000
Abstract simple: 0.000000
Abstract complex: 0.000000
Exist abstract: 1593430.000000
Results for implementation 2: (run time: 54727 ms)
Unique abstraction statistics:
Recursive calls: 191585.000000
Cache hits: 26494.000000
Abstract simple: 59788.000000
Abstract complex: 12011.000000
Exist abstract: 24022.000000
Results for implementation 3: (run time: 20215 ms)
Unique abstraction statistics:
Recursive calls: 268044.000000
Cache hits: 30668.000000
Abstract simple: 78115.000000
Abstract complex: 46473.000000
Exist abstract: 92946.000000
EDIT 3: The following results were obtained after implementing every logical operation in terms of ITE5.
uniqueAbstractRecRef (21831 ms)
Unique abstraction statistics:
Total calls: 1723239
Optimized calls: 0
Total exist abstract calls: 30955618
Unique abstract calls to exist abstract: 2385915
Total ite calls: 3574555
Out of the total time, uniqueAbstractRecRef takes 4001 ms (12.4%)
uniqueAbstractSERec (56761 ms)
Unique abstraction statistics:
Total calls: 193627
Optimized calls: 60632
Total exist abstract calls: 16475806
Unique abstract calls to exist abstract: 24304
Total ite calls: 1271844
Out of the total time, uniqueAbstractSERec takes 33918 ms (51.5%)
uniqueAbstractRec (20587 ms)
Unique abstraction statistics:
Total calls: 270205
Optimized calls: 78486
Total exist abstract calls: 13186348
Unique abstract calls to exist abstract: 93060
Total ite calls: 1256872
Out of the total time, uniqueAbstractRec takes 3354 ms (10.6%)
There exist simple and efficient solution if variables are ordered in such a way that x1 and x2 are at the top of BDD.
Consider BDD for second example.
You can traverse (in breadth-first order) first two layers of it to get four sub-BDDs. One for each possible combination of x1,x2. Three of those sub-BDDs a rooted at y1 and fourth is empty (constant False).
Now you can count number of elements in each sub-BDD (Algorithm C from Knuth's Volume 4 Fascicle 1, Bitwise Tricks & Techniques; Binary Decision Diagrams).
If number of elements in sub-BDD is greater than 1 then drop it (shortcut from parent node directly to False), otherwise leave it as it is.
It is possible to run this algorithm in single pass by memoizing partial results while counting elements.
Here is my implementation. I have studied author's proposed solution and it seems to me that it is the best if not the only simple BDD-based solution for arbitrary ordering. However, there may be some improvements if the algorithm is implemented in my way- PLEASE CHECK. I am using my own wrapper over BDD package but you should not have any troubles to understand it.
EDITED: I have simplified the solution, function Bdd_GetVariableChar() is not used anymore.
/* TESTING SOLUTION FOR QUESTION ON STACK OVERFLOW */
/* bdd_termFalse,bdd_termTrue: Boolean constants */
/* Bdd_isTerminal(f): check if f is Boolean constant */
/* Bdd_Low(f),Bdd_High(f): 'else' and 'then' subfunction */
/* Bdd_Top(f): literal function representing topvar of f */
/* Bdd_IsSmaller(f,g): check if topvar of f is above topvar of g */
/* existentialAbstraction(f,cube): \exist v.f for all v in cube */
Bdd_Edge specialAbstraction(Bdd_Edge f, Bdd_Edge cube) {
if (Bdd_isTerminal(cube)) return f;
if (Bdd_isTerminal(f)) return bdd_termFalse;
if (Bdd_IsSmaller(f,cube)) {
Bdd_Edge E,T;
E = specialAbstraction(Bdd_Low(f),cube);
T = specialAbstraction(Bdd_High(f),cube);
return Bdd_ITE(Bdd_Top(f),T,E);
} else if (Bdd_IsSmaller(cube,f)) {
return bdd_termFalse;
} else {
Bdd_Edge E,T;
cube = Bdd_High(cube);
E = Bdd_Low(f);
T = Bdd_High(f);
if (Bdd_isEqv(E,bdd_termFalse)) {
return specialAbstraction(T,cube);
} else if (Bdd_isEqv(T,bdd_termFalse)) {
return specialAbstraction(E,cube);
} else {
Bdd_Edge EX,TX,R;
EX = existentialAbstraction(E,cube);
TX = existentialAbstraction(T,cube);
if (Bdd_isEqv(EX,TX)) return bdd_termFalse;
R = Bdd_ITE(Bdd_ITE(EX,bdd_termFalse,T),
bdd_termTrue,
Bdd_ITE(TX,bdd_termFalse,E));
return specialAbstraction(R,cube);
}
}
}
And, yes, if variable ordering is fixed with x above y, the algorithm can really be much more efficient - you can remove all the calculations from the most complex 'else' block and just return 0.
Here are some testing runs:
CUBE (JUST IN CASE YOU ARE NOT FAMILIAR WITH BDD ALGORITHMS)
+ y1 y2 y3 y4 y5
ORIGINAL (ORDERED WITH X ABOVE Y)
+ *x1 *x2 x3 *x4 x5 y1 *y2 y3 y4 y5
+ *x1 x2 *x3 *x4 *x5 y1 y2 *y3 y4 y5
+ *x1 x2 *x3 *x4 x5 *y1 y2 *y3 y4 y5
+ *x1 x2 *x3 x4 *x5 y1 *y2 y3 *y4 *y5
+ *x1 x2 x3 *x4 x5 *y1 *y2 *y3 *y4 y5
+ *x1 x2 x3 *x4 x5 *y1 y2 y3 *y4 *y5
+ x1 *x2 *x3 *x4 *x5 y1 y2 y3 y4 *y5
+ x1 x2 *x3 x4 x5 *y1 *y2 *y4 *y5
+ x1 x2 x3 *x4 *x5 *y1 *y2 *y3 y4 *y5
ABSTRACTION
+ *x1 *x2 x3 *x4 x5
+ *x1 x2 *x3 *x4
+ *x1 x2 *x3 x4 *x5
+ x1 *x2 *x3 *x4 *x5
+ x1 x2 x3 *x4 *x5
ORIGINAL (ORDERED WITH Y ABOVE X)
+ *y1 *y2 *y3 *y4 *y5 x1 x2 *x3 x4 x5
+ *y1 *y2 *y3 *y4 y5 *x1 x2 x3 *x4 x5
+ *y1 *y2 *y3 y4 *y5 x1 x2 x3 *x4 *x5
+ *y1 *y2 y3 *y4 *y5 x1 x2 *x3 x4 x5
+ *y1 y2 *y3 y4 y5 *x1 x2 *x3 *x4 x5
+ *y1 y2 y3 *y4 *y5 *x1 x2 x3 *x4 x5
+ y1 *y2 y3 *y4 *y5 *x1 x2 *x3 x4 *x5
+ y1 *y2 y3 y4 y5 *x1 *x2 x3 *x4 x5
+ y1 y2 *y3 y4 y5 *x1 x2 *x3 *x4 *x5
+ y1 y2 y3 y4 *y5 x1 *x2 *x3 *x4 *x5
ABSTRACTION
+ *x1 *x2 x3 *x4 x5
+ *x1 x2 *x3 *x4
+ *x1 x2 *x3 x4 *x5
+ x1 *x2 *x3 *x4 *x5
+ x1 x2 x3 *x4 *x5
ORIGINAL (MIXED ORDER)
+ *x1 *x2 y1 *y2 y3 y4 y5 x3 *x4 x5
+ *x1 x2 *y1 *y2 *y3 *y4 y5 x3 *x4 x5
+ *x1 x2 *y1 y2 *y3 y4 y5 *x3 *x4 x5
+ *x1 x2 *y1 y2 y3 *y4 *y5 x3 *x4 x5
+ *x1 x2 y1 *y2 y3 *y4 *y5 *x3 x4 *x5
+ *x1 x2 y1 y2 *y3 y4 y5 *x3 *x4 *x5
+ x1 *x2 y1 y2 y3 y4 *y5 *x3 *x4 *x5
+ x1 x2 *y1 *y2 *y3 *y4 *y5 *x3 x4 x5
+ x1 x2 *y1 *y2 *y3 y4 *y5 x3 *x4 *x5
+ x1 x2 *y1 *y2 y3 *y4 *y5 *x3 x4 x5
ABSTRACTION
+ *x1 *x2 x3 *x4 x5
+ *x1 x2 *x3 *x4
+ *x1 x2 *x3 x4 *x5
+ x1 *x2 *x3 *x4 *x5
+ x1 x2 x3 *x4 *x5
One approach involves directly translating the definition of uniqueness:
R(x,y) and forall z . ~R(x,z) or y = z
An implementation may look like this:
def inspect(function, name, nvars):
sys.stdout.write(name) # avoid print's trailing space or newline
function.summary(nvars) # minterm count needs number of variables
function.printCover()
import sys
from cudd import Cudd
m = Cudd()
nx = 2
ny = 3
x = [m.bddVar() for i in range(nx)]
y = [m.bddVar() for i in range(ny)]
R = (~x[0] & x[1] & (~y[0] & y[1] | y[1] & y[2]) |
x[0] & ~x[1] & (y[0] ^ y[1]) & y[2] |
~x[0] & ~x[1] & y[0] & ~y[1] & ~y[2])
# This approach is independent of variable order. We are free to enable
# reordering or call it explicitly.
m.reduceHeap()
inspect(R, 'R', nx+ny)
# Create auxiliary variables and selector function.
z = [m.bddVar() for i in range(ny)]
zcube = reduce(lambda a, b: a & b, z)
P = ~m.xeqy(y,z)
# A pair is in L iff:
# - it is in R
# - there is no other pair in R with the same x and different y
L = R & ~(R.swapVariables(y,z).andAbstract(P,zcube))
inspect(L, 'L', nx+ny)
Result of running that code:
R: 10 nodes 1 leaves 6 minterms
01-11 1
10101 1
10011 1
00100 1
0101- 1
L: 6 nodes 1 leaves 1 minterms
00100--- 1
The first two variables encode the first element of the pair; the next three variables encode the second element of the pair; the last three variables are the auxiliary variables.
The code applies DeMorgan's to the formula above to make use of andAbstract.
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 10 years ago.
Improve this question
Suppose, I have an differential equation like this one:
mu1 u1[x] - u1''[x] - 10 u1[x] == 0
where mu1 is the eigenvalue and u1 is the eigenfuntion. Now, How can i calculate the eigenvalue mu1 numerically??? Can anyone help me out with this problem??
I'm assuming you want to solve something like
u1''[x] + 10 u1[x] == mu1 u1[x]
with boundary conditions
u1[x0] == 0; u1[x1] == 0; u1'[x0] =!= 0
for some x0 < x1. One way to do that is to first solve the differential equation plus the boundary conditions at x0, e.g.
sol = DSolve[{mu1 u1[x] - u1''[x] - 10 u1[x] == 0, u1[x0] == 0, u1'[x0] == 1}, u1, x][[1]]
which gives as output
{u1 -> Function[{x}, -((E^(-Sqrt[-10 + mu1] x - Sqrt[-10 + mu1] x0)
(-E^(2 Sqrt[-10 + mu1] x) + E^(2 Sqrt[-10 + mu1] x0)))/(2 Sqrt[-10 + mu1]))]}
We can then use this solution to find mu1 such that the boundary condition at x1 is satisfied:
sol1 = Solve[{u1[x1] == 0 /. sol[[1]], x1 > x0}, mu1, MaxExtraConditions -> All]
From which we find
{{mu1 -> ConditionalExpression[(10 x0^2 - 20 x0 x1 + 10 x1^2 - 4 \[Pi]^2 C[1]^2)/(
x0^2 - 2 x0 x1 + x1^2),
x0 \[Element] Reals && C[1] \[Element] Integers && C[1] >= 1 && x1 > x0]},
{mu1 -> ConditionalExpression[(-\[Pi]^2 + 10 x0^2 - 20 x0 x1 + 10 x1^2 -
4 \[Pi]^2 C[1] - 4 \[Pi]^2 C[1]^2)/(x0^2 - 2 x0 x1 + x1^2),
x0 \[Element] Reals && C[1] \[Element] Integers && C[1] >= 0 && x1 > x0]}}