pyoptinterface 0.3.0__cp312-abi3-win_amd64.whl

pyoptinterface/__init__.py

@@ -0,0 +1,68 @@
+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.
+"""
+In = ConstraintSense.Within
+"""Alias of `ConstraintSense.Within` for range constraints.
+"""
+
+__all__ = [
+    "VariableIndex",
+    "ConstraintIndex",
+    "ExprBuilder",
+    "VariableDomain",
+    "ConstraintSense",
+    "ConstraintType",
+    "SOSType",
+    "ObjectiveSense",
+    "ScalarAffineFunction",
+    "ScalarQuadraticFunction",
+    "VariableAttribute",
+    "ModelAttribute",
+    "TerminationStatusCode",
+    "ResultStatusCode",
+    "ConstraintAttribute",
+    "tupledict",
+    "make_tupledict",
+    "make_nd_variable",
+    "quicksum",
+    "quicksum_",
+    "Eq",
+    "Leq",
+    "Geq",
+    "In",
+]

pyoptinterface/_src/aml.py

@@ -0,0 +1,83 @@
+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, start=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
+    if start is not None:
+        kw_args["start"] = start
+
+    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/codegen_c.py

@@ -0,0 +1,301 @@
+from .cppad_interface_ext import (
+    graph_op,
+)
+from .cpp_graph_iter import cpp_graph_iterator
+
+from typing import IO
+
+op2name = {
+    graph_op.abs: "fabs",
+    graph_op.acos: "acos",
+    graph_op.asin: "asin",
+    graph_op.atan: "atan",
+    graph_op.cos: "cos",
+    graph_op.exp: "exp",
+    graph_op.log: "log",
+    graph_op.pow: "pow",
+    graph_op.sign: "sign",
+    graph_op.sin: "sin",
+    graph_op.sqrt: "sqrt",
+    graph_op.tan: "tan",
+    graph_op.add: "+",
+    graph_op.sub: "-",
+    graph_op.mul: "*",
+    graph_op.div: "/",
+    graph_op.azmul: "*",
+    graph_op.neg: "-",
+}
+
+compare_ops = set([graph_op.cexp_eq, graph_op.cexp_le, graph_op.cexp_lt])
+
+compare_ops_string = {
+    graph_op.cexp_eq: "==",
+    graph_op.cexp_le: "<=",
+    graph_op.cexp_lt: "<",
+}
+
+
+def generate_csrc_prelude(io: IO[str]):
+    io.write(
+        """// includes
+#include <stddef.h>
+
+// typedefs
+typedef double float_point_t;
+
+// declare mathematical functions
+#define UNARY(f) extern float_point_t f(float_point_t x)
+#define BINARY(f) extern float_point_t f(float_point_t x, float_point_t y)
+
+// unary functions
+UNARY(fabs);
+UNARY(acos);
+UNARY(asin);
+UNARY(atan);
+UNARY(cos);
+UNARY(exp);
+UNARY(log);
+UNARY(sin);
+UNARY(sqrt);
+UNARY(tan);
+
+// binary functions
+BINARY(pow);
+
+// externals
+// azmul
+float_point_t azmul(float_point_t x, float_point_t y)
+{
+    if( x == 0.0 ) return 0.0;
+    return x * y;
+}
+
+// sign
+float_point_t sign(float_point_t x)
+{	
+    if( x > 0.0 ) return 1.0;
+    if( x == 0.0 ) return 0.0;
+    return -1.0;
+}
+"""
+    )
+
+
+def generate_csrc_from_graph(
+    io: IO[str],
+    graph_obj,
+    name: str,
+    np: int = 0,
+    hessian_lagrange: bool = False,
+    nw: int = 0,
+    indirect_x: bool = False,
+    indirect_p: bool = False,
+    indirect_w: bool = False,
+    indirect_y: bool = False,
+    add_y: bool = False,
+):
+    n_dynamic_ind = graph_obj.n_dynamic_ind
+    n_variable_ind = graph_obj.n_variable_ind
+    n_constant = graph_obj.n_constant
+    n_dependent = graph_obj.n_dependent
+
+    # Simple case
+    # 0 -> dummy
+    # [1, 1 + np) -> *p
+    # [1 + np, 1 + n_dynamic_ind + n_variable_ind) -> *x
+    # [1 + n_dynamic_ind + n_variable_ind, 1 + n_dynamic_ind + n_variable_ind + n_constant) -> c[...]
+    # [1 + n_dynamic_ind + n_variable_ind + n_constant, ...) -> v[...]
+
+    # Hessian lagragian case
+    # 0 -> dummy
+    # [1, 1 + np) -> *p
+    # [1 + np, 1 + np + nw) -> *w
+    # [1 + np + nw, 1 + n_dynamic_ind + n_variable_ind) -> *x
+    # [1 + n_dynamic_ind + n_variable_ind, 1 + n_dynamic_ind + n_variable_ind + n_constant) -> c[...]
+    # [1 + n_dynamic_ind + n_variable_ind + n_constant, ...) -> v[...]
+
+    n_node = 0
+    for graph_iter in cpp_graph_iterator(graph_obj):
+        n_node += graph_iter.n_result
+
+    has_parameter = np > 0
+
+    function_args_signature = ["const float_point_t* x"]
+    if has_parameter:
+        function_args_signature.append("const float_point_t* p")
+    if hessian_lagrange:
+        function_args_signature.append("const float_point_t* w")
+    function_args_signature.append("float_point_t* y")
+    if indirect_x:
+        function_args_signature.append("const size_t* xi")
+    if has_parameter and indirect_p:
+        function_args_signature.append("const size_t* pi")
+    if hessian_lagrange and indirect_w:
+        function_args_signature.append("const size_t* wi")
+    if indirect_y:
+        function_args_signature.append("const size_t* yi")
+
+    function_args = ", ".join(function_args_signature)
+
+    function_prototype = f"""
+void {name}(
+    {function_args}
+)
+"""
+    io.write(function_prototype)
+
+    if not hessian_lagrange:
+        nx = n_dynamic_ind + n_variable_ind - np
+    else:
+        nx = n_dynamic_ind + n_variable_ind - np - nw
+    ny = n_dependent
+    io.write(
+        f"""{{
+    // begin function body
+
+    // size checks
+    // const size_t nx = {nx};
+    // const size_t np = {np};
+    // const size_t ny = {ny};
+"""
+    )
+    if hessian_lagrange:
+        io.write(f"    // const size_t nw = {nw};\n")
+
+    io.write(
+        f"""
+    // declare variables
+    float_point_t v[{n_node}];
+    """
+    )
+
+    nc = n_constant
+    cs = (graph_obj.constant_vec_get(i) for i in range(nc))
+    cs_str = ", ".join(f"{c}" for c in cs)
+    io.write(
+        f"""
+    // constants
+    // set c[i] for i = 0, ..., nc-1
+    // nc = {nc}
+    static const float_point_t c[{nc}] = {{
+        {cs_str}
+    }};
+"""
+    )
+
+    n_result_node = n_node
+    io.write(
+        f"""
+    // result nodes
+    // set v[i] for i = 0, ..., n_result_node-1
+    // n_result_node = {n_result_node}
+"""
+    )
+
+    def get_node_name(node: int) -> str:
+        if node < 1:
+            raise ValueError(f"Invalid node: {node}")
+        if node < 1 + np:
+            index = node - 1
+            if indirect_p:
+                return f"p[pi[{index}]]"
+            else:
+                return f"p[{index}]"
+        elif node < 1 + n_dynamic_ind + n_variable_ind:
+            if hessian_lagrange:
+                if node < 1 + np + nw:
+                    index = node - 1 - np
+                    if indirect_w:
+                        return f"w[wi[{index}]]"
+                    else:
+                        return f"w[{index}]"
+                else:
+                    index = node - 1 - np - nw
+                    if indirect_x:
+                        return f"x[xi[{index}]]"
+                    else:
+                        return f"x[{index}]"
+            else:
+                index = node - 1 - np
+                if indirect_x:
+                    return f"x[xi[{index}]]"
+                else:
+                    return f"x[{index}]"
+        elif node < 1 + n_dynamic_ind + n_variable_ind + n_constant:
+            index = node - 1 - n_dynamic_ind - n_variable_ind
+            return f"c[{index}]"
+        else:
+            node = node - 1 - n_dynamic_ind - n_variable_ind - n_constant
+            assert node < n_node
+            return f"v[{node}]"
+
+    result_node = 0
+
+    infix_operators = set(["+", "-", "*", "/"])
+
+    for iter in cpp_graph_iterator(graph_obj):
+        op = iter.op
+        n_result = iter.n_result
+        args = iter.args
+
+        assert n_result == 1
+
+        n_arg = len(args)
+
+        op_name = op2name.get(op, None)
+        if op_name is not None:
+            if n_arg == 1:
+                arg1 = get_node_name(args[0])
+                io.write(f"    v[{result_node}] = {op_name}({arg1});\n")
+            elif n_arg == 2:
+                arg1 = get_node_name(args[0])
+                arg2 = get_node_name(args[1])
+                if op_name in infix_operators:
+                    io.write(f"    v[{result_node}] = {arg1} {op_name} {arg2};\n")
+                else:
+                    io.write(f"    v[{result_node}] = {op_name}({arg1}, {arg2});\n")
+            else:
+                message = f"Unknown n_arg: {n_arg} for op_enum: {op}\n"
+                raise ValueError(message)
+        elif op in compare_ops:
+            cmp_op = compare_ops_string[op]
+            assert n_arg == 4
+            predicate = get_node_name(args[0])
+            target = get_node_name(args[1])
+            then_value = get_node_name(args[2])
+            else_value = get_node_name(args[3])
+            io.write(
+                f"    v[{result_node}] = {predicate} {cmp_op} {target} ? {then_value} : {else_value};\n"
+            )
+        else:
+            message = f"Unknown name for op_enum: {op}\n"
+            debug_context = f"name: {name}\nfull graph:\n{str(graph_obj)}"
+            raise ValueError(message + debug_context)
+
+        result_node += n_result
+
+    io.write(
+        """
+    // dependent variables
+    // set y[i] for i = 0, ny-1
+"""
+    )
+
+    op = "="
+    if add_y:
+        op = "+="
+    for i in range(ny):
+        node = graph_obj.dependent_vec_get(i)
+        node_name = get_node_name(node)
+        if indirect_y:
+            assignment = f"    y[yi[{i}]] {op} {node_name};\n"
+        else:
+            assignment = f"    y[{i}] {op} {node_name};\n"
+        io.write(assignment)
+
+    io.write(
+        """
+    // end function body
+}
+"""
+    )