# Python equivalent of the ComplexUserFunction.c example in # examples/nonlinear/c directory. # # Define objective and constraint as user functions that return # derivatives: # # Minimize myobj (y,z,v,w) # s.t. # ball (x,t) <= 730 # 1 <= x <= 2 # 2 <= y <= 3 # 3 <= z <= 4 # 4 <= v <= 5 # 5 <= w <= 6 # # where # # myobj (y,z,v,w) = y**2 + z - v + w**2 # ball (x,t) = x**2 + t**2 # # (C) 1983-2025 Fair Isaac Corporation import xpress as xp def myobj(y, z, v, w): """Return value of the objective function with the derivative w.r.t. all variables passed.""" return (y**2 + z - v + w**2, # value of the function 2*y, # derivative w.r.t. y 1, # derivative w.r.t. z -1, # derivative w.r.t. v 2*w) # derivative w.r.t. w def ball(x, t): """Return value of the left-hand side of the constraint with its derivatives.""" return (x**2 + t**2, 2*x, 2*t) def myobj_noderiv(y, z, v, w): """Return objective without derivatives.""" return y**2 + z - v + w**2 # Value of the function. def ball_noderiv(x, t): """Return left-hand side of constraint without derivatives.""" return x**2 + t**2 def solve_problem(incder): """Construct and solve the problem with or without derivatives. :param incder: True for including derivatives, False otherwise :return: """ p = xp.problem() x = p.addVariable(lb=1, ub=2) y = p.addVariable(lb=2, ub=3) z = p.addVariable(lb=3, ub=4) v = p.addVariable(lb=4, ub=5) w = p.addVariable(lb=5, ub=6) t = p.addVariable(lb=-xp.infinity) # Free variable. p.setObjective(t) if incder: p.addConstraint(t == xp.user(myobj, y, z, v, w, derivatives=True)) p.addConstraint(xp.user(ball, x, t, derivatives=True) <= 730) print('Solving problem using derivatives:') else: p.addConstraint(t == xp.user(myobj_noderiv, y, z, v, w)) p.addConstraint(xp.user(ball_noderiv, x, t) <= 730) print('Solving problem without using derivatives:') # With user functions the problem cannot be solved to # global optimality, so the control below is not necessary # but shown here for completeness. Setting nlpsolver to one # ensures the problem is solved by a local solver rather than the # global solver. p.controls.nlpsolver = xp.constants.NLPSOLVER_LOCAL p.optimize() print('Problem solved. Objective:', p.attributes.objval, '; solution:', p.getSolution()) if __name__ == '__main__': solve_problem(True) solve_problem(False)