Convex Optimization Examples

These examples show the Java modeling patterns for LP and QP problems. They assume the Java module has been compiled as described in Java Quickstart Guide and that the application can load libcuopt_jni.

Simple Linear Programming

The high-level API uses fluent expressions and explicit comparison methods.

SimpleLp.java

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
import com.nvidia.cuopt.mathematicaloptimization.*;

public class SimpleLp {
  public static void main(String[] args) throws Exception {
    try (Problem problem = new Problem("simple-lp")) {
      Variable x = problem.addVariable(
          0.0, Double.POSITIVE_INFINITY, 1.0,
          VariableType.CONTINUOUS, "x");
      Variable y = problem.addVariable(
          0.0, Double.POSITIVE_INFINITY, 1.0,
          VariableType.CONTINUOUS, "y");

      problem.addConstraint(
          LinearExpression.of(x).plus(y).ge(10.0), "demand");
      problem.setObjective(
          LinearExpression.of(x).plus(y), ObjectiveSense.MINIMIZE);

      try (SolverSettings settings = new SolverSettings()
               .setSetting(CuOptConstants.CUOPT_METHOD, SolverMethod.PDLP.nativeValue());
           Solution solution = problem.solve(settings)) {
        System.out.println("Status: " + solution.getTerminationStatus());
        System.out.println("x = " + x.getValue());
        System.out.println("y = " + y.getValue());
        System.out.println("Objective = " + solution.getPrimalObjective());
      }
    }
  }
}

Example Response:

Status: OPTIMAL
x = 0.0
y = 10.0
Objective = 10.0

Problem.solve populates the Variable and Constraint objects after the solve. The solution object remains available for detailed native results and statistics.

Simple Quadratic Programming

Quadratic objectives combine quadratic, linear, and constant terms:

SimpleQp.java

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
import com.nvidia.cuopt.mathematicaloptimization.*;

public class SimpleQp {
  public static void main(String[] args) throws Exception {
    try (Problem problem = new Problem("simple-qp")) {
      Variable x = problem.addVariable(0.0, 10.0, 0.0, VariableType.CONTINUOUS, "x");
      Variable y = problem.addVariable(0.0, 10.0, 0.0, VariableType.CONTINUOUS, "y");

      QuadraticExpression objective = QuadraticExpression
          .of(x, x, 1.0)
          .plus(y, y, 1.0)
          .plus(LinearExpression.of(x).times(-1.0))
          .plus(LinearExpression.of(y).times(-1.0));

      problem.addConstraint(
          LinearExpression.of(x).plus(y).eq(1.0), "sum");
      problem.setObjective(objective, ObjectiveSense.MINIMIZE);

      try (Solution solution = problem.solve()) {
        System.out.println("x = " + x.getValue());
        System.out.println("y = " + y.getValue());
        System.out.println("Objective = " + solution.getPrimalObjective());
      }
    }
  }
}

Example Response:

x = 0.5
y = 0.5
Objective = -0.5

For QP solutions, getDualObjective is available when the solver returns it, and variable and constraint values are read from the model through Variable.getValue, Variable.getReducedCost, and Constraint.getDualValue.

Quadratic Constraints

Quadratic constraints can be added directly to a Problem. As of this writing, cuOptCreateProblem requires at least one linear constraint row, so a purely quadratically-constrained model needs a (possibly non-binding) linear constraint too:

QuadraticConstraint.java

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
import com.nvidia.cuopt.mathematicaloptimization.*;

public class QuadraticConstraint {
  public static void main(String[] args) throws Exception {
    try (Problem problem = new Problem("quadratic-constraint")) {
      Variable x = problem.addVariable(0.0, 10.0, 1.0, VariableType.CONTINUOUS, "x");
      Variable y = problem.addVariable(0.0, 10.0, 1.0, VariableType.CONTINUOUS, "y");

      // cuOptCreateProblem currently requires at least one linear constraint row.
      problem.addConstraint(LinearExpression.of(x).plus(y).le(15.0), "budget");

      QuadraticExpression radius = QuadraticExpression
          .of(x, x, 1.0)
          .plus(y, y, 1.0);
      problem.addConstraint(radius.le(4.0), "radius");
      problem.setObjective(
          LinearExpression.of(x).plus(y), ObjectiveSense.MAXIMIZE);

      try (Solution solution = problem.solve()) {
        System.out.println(solution.getTerminationStatus());
      }
    }
  }
}

Only LE and GE quadratic constraints are supported; QuadraticExpression does not expose an eq method.

Reading and Writing MPS/QPS

Problem exposes both extension-dispatch and direct MPS entry points:

MpsRoundtrip.java and sample.mps

/*
 * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
import com.nvidia.cuopt.mathematicaloptimization.*;

public class MpsRoundtrip {
  public static void main(String[] args) throws Exception {
    try (Problem problem = Problem.read("sample.mps")) {
      System.out.println("Variables: " + problem.getNumVariables());
      problem.write("roundtrip.mps");
    }
  }
}

Example Response:

Variables: 2

Fixed-format parsing is also available:

try (Problem fixed = Problem.read("fixed-format.mps", true)) {
  // Use fixed-format parsing explicitly.
}

Parsing failures are reported as CuOptException with the cuOpt status code available from getStatusCode.