jijmodeling 0.10.18__cp310-cp310-win_amd64.whl → 1.11.0__cp310-cp310-win_amd64.whl

jijmodeling/problem/problem.py

@@ -1,166 +0,0 @@
-from __future__ import annotations
-
-import copy as _copy
-import enum as _enum
-import typing as tp
-
-import typeguard as _typeguard
-
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.constraint as _constraint
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.serializable as _serializable
-import jijmodeling.expression.utils as _utils
-
-
-class ProblemSense(_enum.Enum):
-    MINIMUM = "MINIMUM"
-    MAXIMUM = "MAXIMUM"
-
-
-class Problem(metaclass=_serializable.Serializable):
-    """
-    Optimization problem.
-
-    Attributes:
-        name (str): name of problem.
-        model (Optional[Expression]): total optimization model.
-        constraints (Dict[str, Constraint]): constraint objects of problem.
-        penalties (Dict[str, Constraint]): penalty objects of problem.
-        cost (Expression): cost term of problem. Defaults zero.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        sense: tp.Union[ProblemSense, str] = ProblemSense.MINIMUM,
-        objective: _expression.Expression = _expression.Number(0),
-        constraints: tp.Dict[str, _constraint.Constraint] = {},
-        penalties: tp.Dict[str, _constraint.Penalty] = {},
-    ) -> None:
-        """
-        Initialize
-
-        Args:
-            problem_name (str): problem name
-            kind (ProblemKind): problem kind Minimum or Maximum
-            objective (Expression): objective
-            constraints (Dict[str, Constraint]): dict of constraints
-            penalties (Dict[str, Penalty]): dict of penalties
-        """
-        self._name = name
-        self._sense = ProblemSense(sense)
-        # deepcopy to avoid having the same reference
-        self._objective = _copy.deepcopy(objective)
-        self._constraints: tp.Dict[str, _constraint.Constraint] = _copy.deepcopy(
-            constraints
-        )
-        self._penalties: tp.Dict[str, _constraint.Penalty] = _copy.deepcopy(penalties)
-
-        _typeguard.check_type("self._name", self._name, str)
-        _typeguard.check_type("self._sense", self._sense, ProblemSense)
-        _typeguard.check_type(
-            "self._constraints", self._constraints, tp.Dict[str, _constraint.Constraint]
-        )
-        _typeguard.check_type(
-            "self._penalties", self._penalties, tp.Dict[str, _constraint.Penalty]
-        )
-
-    @property
-    def name(self) -> str:
-        return self._name
-
-    @property
-    def sense(self) -> ProblemSense:
-        return self._sense
-
-    @property
-    def objective(self) -> _expression.Expression:
-        return self._objective
-
-    @property
-    def constraints(self) -> tp.Dict[str, _constraint.Constraint]:
-        return self._constraints
-
-    @property
-    def penalties(self) -> tp.Dict[str, _constraint.Penalty]:
-        return self._penalties
-
-    def add(
-        self,
-        other: tp.Union[
-            _expression.Expression, _constraint.Constraint, _constraint.Penalty
-        ],
-    ):
-        """
-        Add expression, constraint or penalty to problem.
-
-        Args:
-            other (Expression): expression
-
-        Examples:
-            ```python
-            >>> import jijmodeling as jm
-            >>> d = jm.Placeholder("d", dim=1)
-            >>> n = d.shape[0]
-            >>> i = jm.Element("i", n)
-            >>> x = jm.Binary("x", shape=(n,))
-            >>> problem = jm.Problem("sample")
-            >>> problem.add(x[:])  # add cost
-            >>> problem.add(jm.Constraint("onehot", x[:] == 1)) # add constraint
-            >>> problem.add(jm.Penalty("penalty", x[0] + x[2])) # add penalty
-            >>> problem += x[:] # syntax sugar `+=`
-            >>> problem += jm.Constraint("onehot", jm.Sum(i, d[i]*x[i]) <= 3)
-            ```
-        """
-        if not isinstance(
-            other,
-            (
-                int,
-                float,
-                _expression.Expression,
-                _constraint.Constraint,
-                _constraint.Penalty,
-            ),
-        ):
-            raise TypeError(f"could not add {type(other)} to Problem.")
-        # extract constraints
-        if isinstance(other, _expression.Expression):
-            # check index dependencies
-            indices = _utils.expression_indices(other)
-            if len(indices) > 0:
-                raise _exceptions.ModelingError(
-                    "{} depends on {}. The dependence on subscripts needs to be eliminated.".format(
-                        other, indices
-                    )
-                )
-            self._objective += other
-        elif isinstance(other, _constraint.Constraint):
-            # TODO CHECK CONSTRAINT SUBSCRIPTION DEPENDENCES
-            self._constraints[other.label] = other
-        elif isinstance(other, _constraint.Penalty):
-            # check index dependencies
-            term = other.penalty_term
-            indices = _utils.expression_indices(term)
-            if len(indices) > len(other.forall):
-                raise _exceptions.ModelingError(
-                    "{} depends on {}. The dependence on subscripts needs to be eliminated.".format(
-                        term, indices
-                    )
-                )
-            self._penalties[other.label] = other
-
-    def __add__(
-        self,
-        other: tp.Union[
-            _expression.Expression, _constraint.Constraint, _constraint.Penalty
-        ],
-    ) -> Problem:
-        self.add(other)
-        return self
-
-    def _repr_latex_(self) -> str:
-        from jijmodeling.latex_repr.problem_latex_repr import problem_latex_repr
-
-        latex_repr = problem_latex_repr(self)
-        return r"$$\begin{alignat*}{4}" + latex_repr + r"\end{alignat*}$$"

jijmodeling/protobuf/__init__.py

@@ -1,8 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.protobuf.from_protobuf as from_protobuf
-import jijmodeling.protobuf.to_protobuf as to_protobuf
-
-__all__ = ["to_protobuf", "from_protobuf"]

jijmodeling/protobuf/from_protobuf/__init__.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.protobuf.from_protobuf.extract_attribute_value_from_header as extract_attribute_value_from_header
-import jijmodeling.protobuf.from_protobuf.from_protobuf as from_protobuf
-import jijmodeling.protobuf.from_protobuf.message_to_array_shape as message_to_array_shape
-import jijmodeling.protobuf.from_protobuf.message_to_binary_op as message_to_binary_op
-import jijmodeling.protobuf.from_protobuf.message_to_binary_var as message_to_binary_var
-import jijmodeling.protobuf.from_protobuf.message_to_constraint as message_to_constraint
-import jijmodeling.protobuf.from_protobuf.message_to_element as message_to_element
-import jijmodeling.protobuf.from_protobuf.message_to_expression as message_to_expression
-import jijmodeling.protobuf.from_protobuf.message_to_forall as message_to_forall
-import jijmodeling.protobuf.from_protobuf.message_to_integer_var as message_to_integer_var
-import jijmodeling.protobuf.from_protobuf.message_to_jagged_array as message_to_jagged_array
-import jijmodeling.protobuf.from_protobuf.message_to_number_lit as message_to_number_lit
-import jijmodeling.protobuf.from_protobuf.message_to_penalty as message_to_penalty
-import jijmodeling.protobuf.from_protobuf.message_to_placeholder as message_to_placeholder
-import jijmodeling.protobuf.from_protobuf.message_to_problem as message_to_problem
-import jijmodeling.protobuf.from_protobuf.message_to_reduction_op as message_to_reduction_op
-import jijmodeling.protobuf.from_protobuf.message_to_subscript_op as message_to_subscript_op
-import jijmodeling.protobuf.from_protobuf.message_to_unary_op as message_to_unary_op
-
-# from jijmodeling.protobuf.from_protobuf.from_protobuf import from_protobuf
-
-__all__ = [
-    "extract_attribute_value_from_header",
-    "from_protobuf",
-    "message_to_array_shape",
-    "message_to_binary_op",
-    "message_to_binary_var",
-    "message_to_constraint",
-    "message_to_element",
-    "message_to_expression",
-    "message_to_forall",
-    "message_to_integer_var",
-    "message_to_jagged_array",
-    "message_to_number_lit",
-    "message_to_penalty",
-    "message_to_placeholder",
-    "message_to_problem",
-    "message_to_reduction_op",
-    "message_to_subscript_op",
-    "message_to_unary_op",
-]

jijmodeling/protobuf/from_protobuf/extract_attribute_value_from_header.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-import jijmodeling_schema as pb
-
-
-def extract_attribute_value_from_header(
-    bytes: bytes,
-) -> Union[pb.Problem, pb.Expression]:
-    """
-    Extract the attribute value from a header messsage.
-
-    Args:
-        bytes (bytes): a bytes object that can be decoded in the `Header` message
-
-    Returns:
-        Union[pb.Problem, pb.Expression]: an instance object of either `Problem` message class or `Expression` message class
-    """
-    # Convert the bytes object into the `Header` message object.
-    header = pb.Header.FromString(bytes)
-
-    # Extract the attribute value from the header message.
-    attribute_value = pb.betterproto.which_one_of(header.value, "value")[1]
-
-    return attribute_value

jijmodeling/protobuf/from_protobuf/from_protobuf.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.expression import Expression
-from jijmodeling.problem.problem import Problem
-from jijmodeling.protobuf.from_protobuf.extract_attribute_value_from_header import (
-    extract_attribute_value_from_header,
-)
-from jijmodeling.protobuf.from_protobuf.message_to_expression import (
-    message_to_expression,
-)
-from jijmodeling.protobuf.from_protobuf.message_to_problem import message_to_problem
-
-
-def from_protobuf(bytes: bytes) -> Union[Problem, Expression]:
-    """
-    Convert a bytes object in protobuf to a JijModeling's object.
-
-    Args:
-        bytes (bytes): a bytes object in protobuf
-
-    Returns:
-        Expression: an expression
-    """
-    # Convert the bytes object into the message object.
-    attribute_value = extract_attribute_value_from_header(bytes)
-
-    if type(attribute_value) is pb.Problem:
-        return message_to_problem(attribute_value)
-    elif isinstance(attribute_value, pb.Expression):
-        return message_to_expression(attribute_value)
-    else:
-        raise RuntimeError(
-            f"cannot convert the bytes object into the instance object according to the class in JijModeling (bytes = {str(bytes)})"
-        )

jijmodeling/protobuf/from_protobuf/message_to_array_shape.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.variables.placeholders import ArrayShape
-
-
-def message_to_array_shape(
-    id: str, message: pb.ArrayShape, array: pb.Expression
-) -> ArrayShape:
-    """
-    Convert a message to a `ArrayShape` object.
-
-    Args:
-        id (str): the id of the `ArrayShape` object
-        message (pb.ArrayShape): the `ArrayShape` message
-        array (pb.Expression): the target array of the array shape
-
-    Returns:
-        ArrayShape: an `ArrayShape` object
-    """
-    # Set the number of axis.
-    axis = message.axis
-
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.from_protobuf.message_to_expression import (
-        message_to_expression,
-    )
-
-    # Set the target array of this array shape.
-    array = message_to_expression(array)
-
-    return ArrayShape(uuid=id, array=array, dimension=axis)

jijmodeling/protobuf/from_protobuf/message_to_binary_op.py

@@ -1,83 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.condition import (
-    AndOperator,
-    Condition,
-    Equal,
-    LessThan,
-    LessThanEqual,
-    NotEqual,
-    OrOperator,
-    XorOperator,
-)
-from jijmodeling.expression.expression import Add, BinaryOperator, Div, Mod, Mul, Power
-from jijmodeling.expression.variables.variable import Range
-
-
-def message_to_binary_op(
-    id: str, message: pb.BinaryOp, left: pb.Expression, right: pb.Expression
-) -> Union[BinaryOperator, Range, Condition]:
-    """
-    Convert a message to a `BinaryOperator` object.
-
-    Args:
-        id (str): the id of the `BinaryOperator` object
-        message (pb.BinaryOp): the `BinaryOp` message
-        operand (pb.Expression): the operand node that the `BinaryOp` message has
-
-    Raises:
-        TypeError: the error happens if the message cannot be converted to a `BinaryOperator` object
-
-    Returns:
-        BinaryOperator: a `BinaryOperator` object
-    """
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.from_protobuf.message_to_expression import (
-        message_to_expression,
-    )
-
-    # Convert the children to the `Expression` objects.
-    lhs = message_to_expression(left)
-    rhs = message_to_expression(right)
-
-    # BinaryOp
-    if message.kind == pb.BinaryOpKind.ADD:
-        return Add(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.MUL:
-        return Mul(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.DIV:
-        return Div(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.POW:
-        return Power(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.MOD:
-        return Mod(uuid=id, left=lhs, right=rhs)
-    # Range
-    elif message.kind == pb.BinaryOpKind.RANGE:
-        return Range(start=lhs, last=rhs, uuid=id)
-    # ComparisonOp
-    elif message.kind == pb.BinaryOpKind.EQ:
-        return Equal(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.NOT_EQ:
-        return NotEqual(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.LESS_THAN:
-        return LessThan(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.LESS_THAN_EQ:
-        return LessThanEqual(uuid=id, left=lhs, right=rhs)
-    # Logicalop
-    elif message.kind == pb.BinaryOpKind.AND:
-        return AndOperator(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.OR:
-        return OrOperator(uuid=id, left=lhs, right=rhs)
-    elif message.kind == pb.BinaryOpKind.XOR:
-        return XorOperator(uuid=id, left=lhs, right=rhs)
-    # Otherwise
-    else:
-        raise TypeError(
-            f"cannot convert the binary operator (actual = {message}) to an expression."
-        )

jijmodeling/protobuf/from_protobuf/message_to_binary_var.py

@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-from typing import List
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.variables.deci_vars import Binary
-
-
-def message_to_binary_var(
-    id: str, message: pb.BinaryVar, shape: List[pb.Expression]
-) -> Binary:
-    """
-    Convert a message to a `Binary` object.
-
-    Args:
-        id (str): the id of the `Binary` object
-        message (pb.BinaryVar): the `BinaryVar` message
-        shape (List[pb.Expression]): the shape of the `Binary` object
-
-    Raises:
-        ValueError: the error occurs if `dim` is not equal to length of the shape
-
-    Returns:
-        Binary: a `Binary` object
-    """
-    # Validate length of the shape.
-    if message.dim != len(shape):
-        raise ValueError("invalid length of the shape")
-
-    # Set the symbol.
-    symbol = message.symbol
-
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.from_protobuf.message_to_expression import (
-        message_to_expression,
-    )
-
-    # Set the shape.
-    shape_element_list = [
-        message_to_expression(shape_element) for shape_element in shape
-    ]
-
-    return Binary(label=symbol, shape=shape_element_list, uuid=id)

jijmodeling/protobuf/from_protobuf/message_to_constraint.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.constraint import Constraint
-from jijmodeling.protobuf.from_protobuf.message_to_expression import (
-    message_to_expression,
-)
-from jijmodeling.protobuf.from_protobuf.message_to_forall import message_to_forall
-
-
-def message_to_constraint(constraint: pb.Constraint) -> Constraint:
-    """
-    Convert a `Constraint` message into a `Constraint` object.
-
-    Args:
-        constraint (pb.Constraint): a `Constraint` message
-
-    Returns:
-        Constraint: a `Constraint` object
-    """
-    # Set the name of the constraint.
-    name = constraint.name
-
-    # Set the condition expression.
-    condition = message_to_expression(constraint.expression)
-
-    # Set the list of forall.
-    forall = [message_to_forall(forall) for forall in constraint.forall]
-
-    # Set the left_lower.
-    has_left_lower = (
-        pb.betterproto.which_one_of(constraint.left_lower.kind, "kind")[1] is not None
-    )
-    if has_left_lower:
-        left_lower = message_to_expression(constraint.left_lower)
-    else:
-        left_lower = None
-
-    return Constraint(
-        label=name,
-        condition=condition,
-        forall=forall,
-        left_lower=left_lower,
-        with_penalty=constraint.is_penalty,
-        with_multiplier=constraint.needs_multiplier,
-        auto_qubo=constraint.needs_square,
-    )

jijmodeling/protobuf/from_protobuf/message_to_element.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.variables.variable import Element
-
-
-def message_to_element(id: str, message: pb.Element, parent: pb.Expression) -> Element:
-    """
-    Convert a message to a `Element` object.
-
-    Args:
-        id (str): the id of the `Element` object
-        message (pb.Element): the `Element` message
-        parent (pb.Expression): the parent node that the `Element` message has
-
-    Returns:
-        Element: an `Element` object
-    """
-    # Set the symbol
-    symbol = message.symbol
-
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.from_protobuf.message_to_expression import (
-        message_to_expression,
-    )
-
-    return Element(label=symbol, parent=message_to_expression(parent), uuid=id)