Minimize constraint function

Specific Domains Optimization (Mathematical)
1

Hello,
im struggling to get one of the julia optimization packages (optim, NLopt, Jump etc…) to work to minimize a constrained function.

In particular, im interested to find the minimum distance between a point and a conic section. Here is a python code using scipy.minimize that works.

  from scipy.optimize import minimize  
  def distance_to_conic(point, a, b, c, d, e, f):

  x0, y0 = point

  def objective(xy):
      x, y = xy
      return (x - x0)**2 + (y - y0)**2

  def constraint(xy):
      x, y = xy
      return a*x**2 + b*x*y + c*y**2 + d*x + e*y + f

  initial_guess = np.array([x0, y0])

  cons = {'type': 'eq', 'fun': constraint}

  result = minimize(objective, initial_guess, constraints=cons)


  closest_point = result.x
  min_distance = np.sqrt(objective(closest_point))
  return min_distance, closest_point

However, the python implementation is rather slow, so i want to speed things up in julia. Has anyone proper easy to follow documentation or examples for a similar problem in julia? I kinda lost in the package documentations …

2

Hi there!
If I’m not mistaken this is a quadratically constrained quadratic program. This kind of problem is rather well-suited to JuMP, see e.g. the tutorial

Are you sure that your constraint is an equality and not an inequality?

3

Why do you say this? It seems to be the distance to a conic so the constraint enforces this.

4

The JuMP example would be something like:

using JuMP, Ipopt
function distance_to_conic(point, a, b, c, d, e, f)
    x0, y0 = point
    model = Model(Ipopt.Optimizer)
    set_silent(model)
    @variable(model, x, start = x0)
    @variable(model, y, start = y0)
    @objective(model, Min, (x - x0)^2 + (y - y0)^2)
    @constraint(model, a * x^2 + b * x * y + c * y^2 + d * x + e * y + f == 0)
    optimize!(model)
    @assert is_solved_and_feasible(model)
    closest_point = value(x), value(y)
    min_distance = sqrt(objective_value(model))
    return min_distance, closest_point
end

I didn’t test this, so there might be a typo, etc, but it should point you in the right direction.

1 Like
5

Because I’m not used to solving constrained programming problems which are not convex I guess ^^

1 Like
6

Here is a solution with the solver IPOPT, but where the problem is modeled entirely with Julia functions:

pkg> add NLPModelsIpopt, ADNLPModels
julia> using ADNLPModels, NLPModelsIpopt
julia> function distance_to_conic(point, a, b, c, d, e, f)
           x0, y0 = point
           obj(x) = (x[1] - x0)^2 + (x[2] - y0)^2
           lvar = [-Inf, -Inf]  # lower bounds on variables
           uvar = [Inf, Inf]  # upper bounds on variables
           con(x) = [a * x[1]^2 + b * x[1] * x[2] + c * x[2]^2 + d * x[1] + e * x[2] + f]
           lcon = [0.0]  # constraint left-hand side
           ucon = [0.0]  # constraint right-hand side
           model = ADNLPModel(obj, [0.0, 0.0], lvar, uvar, con, lcon, ucon)
           stats = ipopt(model)
           return stats.solution, sqrt(stats.objective)
       end
3 Likes