def find_transform(x, y, limit, threshold=1e-7):
"""
find a integer solution to ax + b - cxy - dy = 0
this will give us the mobius transform: T(x) = y
:param x: numeric constant to check
:param y: numeric manipulation of constant
:param limit: range to look at
:param threshold: optimal solution threshold.
:return MobiusTransform in case of success or None.
"""
x1 = x
x2 = dec(1.0)
x3 = -x * y
x4 = -y
solver = Solver('mobius', Solver.CBC_MIXED_INTEGER_PROGRAMMING)
a = solver.IntVar(-limit, limit, 'a')
b = solver.IntVar(-limit, limit, 'b')
c = solver.IntVar(-limit, limit, 'c')
d = solver.IntVar(-limit, limit, 'd')
f = solver.NumVar(0, 1, 'f')
solver.Add(f == (a * x1 + b * x2 + c * x3 + d * x4))
solver.Add(a * x1 + b >=
1) # don't except trivial solutions and remove some redundancy
solver.Minimize(f)
status = solver.Solve()
if status == Solver.OPTIMAL:
if abs(solver.Objective().Value()) <= threshold:
res_a, res_b, res_c, res_d = int(a.solution_value()), int(b.solution_value()),\
int(c.solution_value()), int(d.solution_value())
ret = MobiusTransform(
np.array([[res_a, res_b], [res_c, res_d]], dtype=object))
ret.normalize()
return ret
else:
return None
def main():
# Create the linear solver with the GLOP backend.
solver = Solver('simple_lp_program', Solver.GLOP_LINEAR_PROGRAMMING)
# Create the variables x and y.
x = solver.NumVar(0, 1, 'x')
y = solver.NumVar(0, 2, 'y')
print('Number of variables =', solver.NumVariables())
# Create a linear constraint, 0 <= x + y <= 2.
ct = solver.Constraint(0, 2, 'ct')
ct.SetCoefficient(x, 1)
ct.SetCoefficient(y, 1)
print('Number of constraints =', solver.NumConstraints())
# Create the objective function, 3 * x + y.
objective = solver.Objective()
objective.SetCoefficient(x, 3)
objective.SetCoefficient(y, 1)
objective.SetMaximization()
solver.Solve()
print('Solution:')
print('Objective value =', objective.Value())
print('x =', x.solution_value())
print('y =', y.solution_value())
def _solve_optimization(self, solver: pywraplp.Solver) -> None:
# The MIP solver is usually fast (milliseconds). If we hit a weird problem,
# accept a suboptimal solution after 10 seconds.
solver.SetTimeLimit(10000)
status = solver.Solve()
if status == pywraplp.Solver.INFEASIBLE:
raise Exception("Infeasible problem")
elif status == pywraplp.Solver.NOT_SOLVED:
raise Exception("Problem unsolved")
def _solve_optimization(self, solver: pywraplp.Solver) -> bool:
# The MIP solver is usually fast (milliseconds). If we hit a weird problem,
# accept a suboptimal solution after 10 seconds.
solver.SetTimeLimit(10000)
status = solver.Solve()
if status == pywraplp.Solver.INFEASIBLE:
logger.warning("Optimization problem is infeasible")
return False
elif status == pywraplp.Solver.NOT_SOLVED:
logger.warning("Optimization problem could not be solved in time")
return False
return True