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

jijmodeling/match/is_same_expr.py

@@ -1,288 +0,0 @@
-from __future__ import annotations
-
-from typing import Tuple, Union
-
-from jijmodeling.expression.condition import (
-    CompareCondition,
-    Condition,
-    ConditionOperator,
-    NoneCondition,
-)
-from jijmodeling.expression.expression import BinaryOperator, Expression, Number
-from jijmodeling.expression.mathfunc import UnaryOperator
-from jijmodeling.expression.sum import ReductionOperator
-from jijmodeling.expression.type_annotations import ShapeElementType
-from jijmodeling.expression.variables.deci_vars import Binary, Integer
-from jijmodeling.expression.variables.jagged_array import JaggedArray
-from jijmodeling.expression.variables.placeholders import ArrayShape, Placeholder
-from jijmodeling.expression.variables.variable import Element, Range, Subscripts
-
-ExpressionType = Union[Expression, Range]
-ShapeType = Tuple[ShapeElementType, ...]
-
-
-def is_same_expr(
-    target: ExpressionType, pattern: ExpressionType, check_id: bool = True
-) -> bool:
-    # Check if the IDs are the same
-    if check_id == True and target.uuid != pattern.uuid:
-        return False
-
-    # Check if the type of `target` is a subclass of the type of `pattern`
-    if not isinstance(target, type(pattern)):
-        return False
-
-    # Case: Number
-    if type(target) is Number and type(pattern) is Number:
-        return is_same_number(target, pattern)
-    # Case: Placeholder
-    elif type(target) is Placeholder and type(pattern) is Placeholder:
-        return is_same_placeholder(target, pattern, check_id)
-    # Case: JaggedArray
-    elif type(target) is JaggedArray and type(pattern) is JaggedArray:
-        return is_same_jagged_array(target, pattern)
-    # Case: ArrayShape
-    elif type(target) is ArrayShape and type(pattern) is ArrayShape:
-        return is_same_array_shape(target, pattern, check_id)
-    # Case: Range
-    elif type(target) is Range and type(pattern) is Range:
-        return is_same_range(target, pattern, check_id)
-    # Case: Element
-    elif type(target) is Element and type(pattern) is Element:
-        return is_same_element(target, pattern, check_id)
-    # Case: Subscripts
-    elif type(target) is Subscripts and type(pattern) is Subscripts:
-        return is_same_subscripts(target, pattern, check_id)
-    # Case: Binary
-    elif type(target) is Binary and type(pattern) is Binary:
-        return is_same_binary(target, pattern, check_id)
-    # Case: Integer
-    elif type(target) is Integer and type(pattern) is Integer:
-        return is_same_integer(target, pattern, check_id)
-    # Case: UnaryOperator
-    elif isinstance(target, UnaryOperator) and isinstance(pattern, UnaryOperator):
-        return is_same_unary_op(target, pattern, check_id)
-    # Case: BinaryOperator
-    elif isinstance(target, BinaryOperator) and isinstance(pattern, BinaryOperator):
-        return is_same_binary_op(target, pattern, check_id)
-    # Case: ReductionOperator
-    elif isinstance(target, ReductionOperator) and isinstance(
-        pattern, ReductionOperator
-    ):
-        return is_same_reduction_op(target, pattern, check_id)
-    # Case: No match
-    else:
-        raise TypeError(f"{target.__class__.__name__} is not supported.")
-
-
-def is_same_cond(target: Condition, pattern: Condition, check_id) -> bool:
-    # Check if the IDs are the same
-    if check_id == True and target.uuid != pattern.uuid:
-        return False
-
-    # Check if the type of `target` is a subclass of the type of `pattern`
-    if not isinstance(target, type(pattern)):
-        return False
-
-    # Case: NonCondition
-    if type(target) is NoneCondition and type(pattern) is NoneCondition:
-        return True
-    # Case: CompareCondition
-    elif isinstance(target, CompareCondition) and isinstance(pattern, CompareCondition):
-        return is_same_comparison_op(target, pattern, check_id)
-    # Case: ConditionOperator
-    elif isinstance(target, ConditionOperator) and isinstance(
-        pattern, ConditionOperator
-    ):
-        return is_same_logical_op(target, pattern, check_id)
-    # Case: No match
-    else:
-        raise TypeError(f"{target.__class__.__name__} is not supported.")
-
-
-def is_same_number(target: Number, pattern: Number) -> bool:
-    # Compare the following attributes:
-    # - value
-    # - dtype
-    if target.value != pattern.value:
-        return False
-    elif target.dtype != pattern.dtype:
-        return False
-    else:
-        return True
-
-
-def is_same_shape(target: ShapeType, pattern: ShapeType, check_id: bool) -> bool:
-    if len(target) != len(pattern):
-        return False
-
-    for target_shape_elt, pattern_shape_elt in zip(target, pattern):
-        # Check if the type of the element of `target` is different from the type of the element of `pattern`
-        if type(target_shape_elt) is not type(pattern_shape_elt):
-            return False
-        # Case: the types of the elements of `target` and `pattern` are not equal to `ArrayShape`
-        elif (
-            type(target_shape_elt) is not ArrayShape
-            and type(pattern_shape_elt) is not ArrayShape
-        ):
-            if not is_same_expr(target_shape_elt, pattern_shape_elt, check_id=check_id):
-                return False
-        # Case: the types of the elements of `target` and `pattern` are equal to `ArrayShape`
-        elif check_id == True and target_shape_elt.uuid != pattern_shape_elt.uuid:
-            return False
-    return True
-
-
-def is_same_placeholder(
-    target: Placeholder, pattern: Placeholder, check_id: bool
-) -> bool:
-    # Compare the following attributes:
-    # - label
-    # - dim
-    # - shape
-    if target.label != pattern.label:
-        return False
-    elif target.dim != pattern.dim:
-        return False
-    else:
-        return is_same_shape(target.shape, pattern.shape, check_id)
-
-
-def is_same_jagged_array(target: JaggedArray, pattern: JaggedArray) -> bool:
-    # Compare the following attributes:
-    # - label
-    # - dim
-    if target.label != pattern.label:
-        return False
-    elif target.dim != pattern.dim:
-        return False
-    else:
-        return True
-
-
-def is_same_array_shape(
-    target: ArrayShape, pattern: ArrayShape, check_id: bool
-) -> bool:
-    # Compare the following attributes:
-    # - dimension
-    # - array
-    if target.dimension != pattern.dimension:
-        return False
-    else:
-        return is_same_expr(target.array, pattern.array, check_id=check_id)
-
-
-def is_same_range(target: Range, pattern: Range, check_id: bool) -> bool:
-    # Compare the following attributes:
-    # - start
-    # - last
-    return is_same_expr(target.start, pattern.start, check_id) and is_same_expr(
-        target.last, pattern.last, check_id
-    )
-
-
-def is_same_element(target: Element, pattern: Element, check_id: bool) -> bool:
-    # Comare the following attributes:
-    # - label
-    # - parent
-    if target.label != pattern.label:
-        return False
-    else:
-        return is_same_expr(target.parent, pattern.parent, check_id)
-
-
-def is_same_subscripts(target: Subscripts, pattern: Subscripts, check_id: bool) -> bool:
-    # Comare the following attributes:
-    # - variable
-    # - subscripts
-    if not is_same_expr(target.variable, pattern.variable, check_id):
-        return False
-    elif len(target.subscripts) != len(pattern.subscripts):
-        return False
-    else:
-        for target_subs, pattern_subs in zip(target.subscripts, pattern.subscripts):
-            if not is_same_expr(target_subs, pattern_subs, check_id):
-                return False
-        return True
-
-
-def is_same_binary(target: Binary, pattern: Binary, check_id: bool) -> bool:
-    # Compare the following attributes:
-    # - label
-    # - shape
-    if target.label != pattern.label:
-        return False
-    else:
-        return is_same_shape(target.shape, pattern.shape, check_id)
-
-
-def is_same_integer(target: Integer, pattern: Integer, check_id: bool) -> bool:
-    # Compare the following attributes:
-    # - label
-    # - lower
-    # - upper
-    # - shape
-    if target.label != pattern.label:
-        return False
-    elif not is_same_expr(target.lower, pattern.lower, check_id):
-        return False
-    elif not is_same_expr(target.upper, pattern.upper, check_id):
-        return False
-    else:
-        return is_same_shape(target.shape, pattern.shape, check_id)
-
-
-def is_same_unary_op(
-    target: UnaryOperator, pattern: UnaryOperator, check_id: bool
-) -> bool:
-    # Compare the following attribute:
-    # - operand
-    return is_same_expr(target.operand, pattern.operand, check_id)
-
-
-def is_same_binary_op(
-    target: BinaryOperator, pattern: BinaryOperator, check_id: bool
-) -> bool:
-    # Compare the following attributes:
-    # - left
-    # - right
-    return is_same_expr(target.left, pattern.left, check_id) and is_same_expr(
-        target.right, pattern.right, check_id
-    )
-
-
-def is_same_reduction_op(
-    target: ReductionOperator, pattern: ReductionOperator, check_id: bool
-) -> bool:
-    # Compare the following attributes:
-    # - sum_index
-    # - condition
-    # - operand
-    if not is_same_element(target.sum_index, pattern.sum_index, check_id):
-        return False
-    elif not is_same_cond(target.condition, pattern.condition, check_id):
-        return False
-    else:
-        return is_same_expr(target.operand, pattern.operand, check_id)
-
-
-def is_same_comparison_op(
-    target: CompareCondition, pattern: CompareCondition, check_id: bool
-) -> bool:
-    # Compare the following attributes:
-    # - left
-    # - right
-    return is_same_expr(target.left, pattern.left, check_id) and is_same_expr(
-        target.right, pattern.right, check_id
-    )
-
-
-def is_same_logical_op(
-    target: ConditionOperator, pattern: ConditionOperator, check_id: bool
-) -> bool:
-    # Compare the following attributes:
-    # - left
-    # - right
-    return is_same_cond(target.left, pattern.left, check_id) and is_same_cond(
-        target.right, pattern.right, check_id
-    )

jijmodeling/match/penalty_same.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling.expression.constraint as _constraint
-
-from jijmodeling.match.condition_same import condition_same
-from jijmodeling.match.expr_same import expr_same
-
-
-def penalty_same(
-    target: _constraint.Penalty, pattern: _constraint.Penalty, check_id: bool = True
-) -> bool:
-    # Is the same label?
-    if target.label != pattern.label:
-        return False
-    # Is the same `with_multiplier`?
-    if target.with_multiplier is not pattern.with_multiplier:
-        return False
-    # Is the same `forall`?
-    if len(target.forall) != len(pattern.forall):
-        return False
-    for target_forall, pattern_forall in zip(target.forall, pattern.forall):
-        target_element, target_condition = target_forall
-        pattern_element, pattern_condition = pattern_forall
-        is_same_forall = expr_same(
-            target_element, pattern_element, check_id
-        ) and condition_same(target_condition, pattern_condition, check_id)
-
-        if is_same_forall is False:
-            return False
-    # Is the same `penalty_term`?
-    return expr_same(target.penalty_term, pattern.penalty_term, check_id)

jijmodeling/match/problem_same.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from jijmodeling.match.constraint_same import constraint_same
-from jijmodeling.match.expr_same import expr_same
-from jijmodeling.match.penalty_same import penalty_same
-from jijmodeling.problem.problem import Problem
-
-
-def problem_same(target: Problem, pattern: Problem, check_id: bool = True) -> bool:
-    # Is the same `name`?
-    if target.name != pattern.name:
-        return False
-    # Is the same `sense`?
-    if target.sense != pattern.sense:
-        return False
-    # Is the same `objective`?
-    if expr_same(target.objective, pattern.objective, check_id) is False:
-        return False
-    # Is the same `constraints`?
-    if len(target.constraints.items()) != len(pattern.constraints.items()):
-        return False
-    for target_key, target_constraint in target.constraints.items():
-        if target_key not in pattern.constraints.keys():
-            return False
-        if (
-            constraint_same(
-                target_constraint, pattern.constraints[target_key], check_id
-            )
-            is False
-        ):
-            return False
-    # Is the same `penalty`?
-    if len(target.penalties.items()) != len(pattern.penalties.items()):
-        return False
-    for target_key, target_penalty in target.penalties.items():
-        if target_key not in pattern.penalties.keys():
-            return False
-        if (
-            penalty_same(target_penalty, pattern.penalties[target_key], check_id)
-            is False
-        ):
-            return False
-
-    return True

jijmodeling/problem/__init__.py

@@ -1,9 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.problem.problem as problem
-
-from jijmodeling.problem.problem import Problem, ProblemSense
-
-__all__ = ["problem", "ProblemSense", "Problem"]

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",
-]