pyoptinterface 0.1.0__cp38-cp38-win_amd64.whl

pyoptinterface/__init__.py

@@ -0,0 +1,63 @@
+from pyoptinterface._src.core_ext import (
+    VariableIndex,
+    ConstraintIndex,
+    ExprBuilder,
+    VariableDomain,
+    ConstraintSense,
+    ConstraintType,
+    SOSType,
+    ObjectiveSense,
+    ScalarAffineFunction,
+    ScalarQuadraticFunction,
+)
+
+from pyoptinterface._src.attributes import (
+    VariableAttribute,
+    ModelAttribute,
+    TerminationStatusCode,
+    ResultStatusCode,
+    ConstraintAttribute,
+)
+
+from pyoptinterface._src.tupledict import (
+    tupledict,
+    make_tupledict,
+)
+
+from pyoptinterface._src.aml import make_nd_variable, quicksum, quicksum_
+
+# Alias of ConstraintSense
+Eq = ConstraintSense.Equal
+"""Alias of `ConstraintSense.Equal` for equality constraints.
+"""
+Leq = ConstraintSense.LessEqual
+"""Alias of `ConstraintSense.LessEqual` for less-than-or-equal-to constraints.
+"""
+Geq = ConstraintSense.GreaterEqual
+"""Alias of `ConstraintSense.GreaterEqual` for greater-than-or-equal-to constraints.
+"""
+
+__all__ = [
+    "VariableIndex",
+    "ConstraintIndex",
+    "ExprBuilder",
+    "VariableDomain",
+    "ConstraintSense",
+    "ConstraintType",
+    "SOSType",
+    "ObjectiveSense",
+    "ScalarAffineFunction",
+    "ScalarQuadraticFunction",
+    "VariableAttribute",
+    "ModelAttribute",
+    "TerminationStatusCode",
+    "ResultStatusCode",
+    "ConstraintAttribute",
+    "tupledict",
+    "make_tupledict",
+    "make_nd_variable",
+    "quicksum",
+    "Eq",
+    "Leq",
+    "Geq",
+]

pyoptinterface/_src/aml.py

@@ -0,0 +1,86 @@
+from .core_ext import ExprBuilder
+from .tupledict import make_tupledict
+
+from collections.abc import Collection
+
+
+def make_nd_variable(
+    model,
+    *coords: Collection,
+    domain=None,
+    lb=None,
+    ub=None,
+    name=None,
+):
+    kw_args = dict()
+    if domain is not None:
+        kw_args["domain"] = domain
+    if lb is not None:
+        kw_args["lb"] = lb
+    if ub is not None:
+        kw_args["ub"] = ub
+
+    def f(*args):
+        if name is not None:
+            suffix = str(args)
+            kw_args["name"] = f"{name}{suffix}"
+        return model.add_variable(**kw_args)
+
+    td = make_tupledict(*coords, rule=f)
+    return td
+
+
+# def make_nd_variable_batch(
+#     model,
+#     *coords: Collection,
+#     domain=None,
+#     lb=None,
+#     ub=None,
+#     name=None,
+# ):
+#     assert model.supports_batch_add_variables()
+#
+#     kw_args = dict()
+#     if domain is not None:
+#         kw_args["domain"] = domain
+#     if lb is not None:
+#         kw_args["lb"] = lb
+#     if ub is not None:
+#         kw_args["ub"] = ub
+#
+#     N = math.prod(len(c) for c in coords)
+#
+#     start_vi = model.add_variables(N, **kw_args)
+#     start_index = start_vi.index
+#
+#     kvs = []
+#     assert len(coords) > 0
+#     for i, coord in enumerate(product(*coords)):
+#         coord = tuple(flatten_tuple(coord))
+#         value = VariableIndex(start_index + i)
+#         if len(coord) == 1:
+#             coord = coord[0]
+#         if value is not None:
+#             kvs.append((coord, value))
+#
+#         suffix = str(coord)
+#         if name is not None:
+#             model.set_variable_name(value, f"{name}{suffix}")
+#     return tupledict(kvs)
+
+
+def quicksum_(expr: ExprBuilder, terms, f=None):
+    if isinstance(terms, dict):
+        iter = terms.values()
+    else:
+        iter = terms
+    if f:
+        iter = map(f, iter)
+    for v in iter:
+        expr += v
+
+
+def quicksum(terms, f=None):
+    expr = ExprBuilder()
+    quicksum_(expr, terms, f)
+    return expr

pyoptinterface/_src/attributes.py

@@ -0,0 +1,129 @@
+from enum import Enum, auto
+from .core_ext import VariableDomain, ObjectiveSense
+
+
+class VariableAttribute(Enum):
+    Value = auto()
+    LowerBound = auto()
+    UpperBound = auto()
+    Domain = auto()
+    PrimalStart = auto()
+    Name = auto()
+
+
+var_attr_type_map = {
+    VariableAttribute.Value: float,
+    VariableAttribute.LowerBound: float,
+    VariableAttribute.UpperBound: float,
+    VariableAttribute.PrimalStart: float,
+    VariableAttribute.Domain: VariableDomain,
+    VariableAttribute.Name: str,
+}
+
+
+class ModelAttribute(Enum):
+    # ModelLike API
+    # NumberOfConstraints = auto()
+    # NumberOfVariables = auto()
+    Name = auto()
+    ObjectiveSense = auto()
+
+    # AbstractOptimizer API
+    DualStatus = auto()
+    PrimalStatus = auto()
+    RawStatusString = auto()
+    TerminationStatus = auto()
+    BarrierIterations = auto()
+    DualObjectiveValue = auto()
+    NodeCount = auto()
+    NumberOfThreads = auto()
+    ObjectiveBound = auto()
+    ObjectiveValue = auto()
+    RelativeGap = auto()
+    Silent = auto()
+    SimplexIterations = auto()
+    SolverName = auto()
+    SolverVersion = auto()
+    SolveTimeSec = auto()
+    TimeLimitSec = auto()
+    # ObjectiveLimit = auto()
+
+
+class ResultStatusCode(Enum):
+    NO_SOLUTION = auto()
+    FEASIBLE_POINT = auto()
+    NEARLY_FEASIBLE_POINT = auto()
+    INFEASIBLE_POINT = auto()
+    INFEASIBILITY_CERTIFICATE = auto()
+    NEARLY_INFEASIBILITY_CERTIFICATE = auto()
+    REDUCTION_CERTIFICATE = auto()
+    NEARLY_REDUCTION_CERTIFICATE = auto()
+    UNKNOWN_RESULT_STATUS = auto()
+    OTHER_RESULT_STATUS = auto()
+
+
+class TerminationStatusCode(Enum):
+    OPTIMIZE_NOT_CALLED = auto()
+    OPTIMAL = auto()
+    INFEASIBLE = auto()
+    DUAL_INFEASIBLE = auto()
+    LOCALLY_SOLVED = auto()
+    LOCALLY_INFEASIBLE = auto()
+    INFEASIBLE_OR_UNBOUNDED = auto()
+    ALMOST_OPTIMAL = auto()
+    ALMOST_INFEASIBLE = auto()
+    ALMOST_DUAL_INFEASIBLE = auto()
+    ALMOST_LOCALLY_SOLVED = auto()
+    ITERATION_LIMIT = auto()
+    TIME_LIMIT = auto()
+    NODE_LIMIT = auto()
+    SOLUTION_LIMIT = auto()
+    MEMORY_LIMIT = auto()
+    OBJECTIVE_LIMIT = auto()
+    NORM_LIMIT = auto()
+    OTHER_LIMIT = auto()
+    SLOW_PROGRESS = auto()
+    NUMERICAL_ERROR = auto()
+    INVALID_MODEL = auto()
+    INVALID_OPTION = auto()
+    INTERRUPTED = auto()
+    OTHER_ERROR = auto()
+
+
+model_attr_type_map = {
+    ModelAttribute.Name: str,
+    ModelAttribute.ObjectiveSense: ObjectiveSense,
+    ModelAttribute.DualStatus: ResultStatusCode,
+    ModelAttribute.PrimalStatus: ResultStatusCode,
+    ModelAttribute.RawStatusString: str,
+    ModelAttribute.TerminationStatus: TerminationStatusCode,
+    ModelAttribute.BarrierIterations: int,
+    ModelAttribute.DualObjectiveValue: float,
+    ModelAttribute.NodeCount: int,
+    ModelAttribute.NumberOfThreads: int,
+    ModelAttribute.ObjectiveBound: float,
+    ModelAttribute.ObjectiveValue: float,
+    ModelAttribute.RelativeGap: float,
+    ModelAttribute.Silent: bool,
+    ModelAttribute.SimplexIterations: int,
+    ModelAttribute.SolverName: str,
+    ModelAttribute.SolverVersion: str,
+    ModelAttribute.SolveTimeSec: float,
+    ModelAttribute.TimeLimitSec: float,
+}
+
+
+class ConstraintAttribute(Enum):
+    Name = auto()
+    # PrimalStart = auto()
+    # DualStart = auto()
+    Primal = auto()
+    Dual = auto()
+    # BasisStatus = auto()
+
+
+constraint_attr_type_map = {
+    ConstraintAttribute.Name: str,
+    ConstraintAttribute.Primal: float,
+    ConstraintAttribute.Dual: float,
+}

pyoptinterface/_src/constraint_bridge.py

@@ -0,0 +1,29 @@
+from .core_ext import ScalarQuadraticFunction, ConstraintSense
+
+
+def bridge_soc_quadratic_constraint(model, cone_variables, name=""):
+    """
+    Convert a second order cone constraint to a quadratic constraint.
+    x[0] >= sqrt(x[1]^2 + ... + x[n]^2)
+    to
+    x[0]^2 - x[1]^2 - ... - x[n]^2 >= 0
+    """
+    N = len(cone_variables)
+    if N < 2:
+        raise ValueError(
+            "Second order cone constraint must have at least two variables"
+        )
+
+    expr = ScalarQuadraticFunction()
+    expr.reserve_quadratic(N)
+
+    x0 = cone_variables[0]
+    expr.add_quadratic_term(x0, x0, 1.0)
+
+    for i in range(1, N):
+        xi = cone_variables[i]
+        expr.add_quadratic_term(xi, xi, -1.0)
+
+    con = model.add_quadratic_constraint(expr, ConstraintSense.GreaterEqual, 0.0, name)
+
+    return con