jijmodeling 0.13.2__cp39-cp39-win_amd64.whl → 1.11.0__cp39-cp39-win_amd64.whl

jijmodeling/match/expand.py

@@ -1,84 +0,0 @@
-import typing as tp
-
-import jijmodeling as jm
-
-from jijmodeling.match.replace import replace_if
-
-
-def expand_add(expr: jm.Expression) -> jm.Expression:
-    """
-    recursively replace the jm.Expression following the rules below:
-    $$
-    a  (c + d) \\rightarrow a  c + a  d
-    $$
-    $$
-    (c + d)  a \\rightarrow c a + d a
-    $$
-    $$
-    \sum_{...}^{...}(a + b) \\rightarrow \sum_{...}^{...}(a) + \sum_{...}^{...}(b)
-    c * \sum_{...}^{...}(a) \\rightarrow \sum_{...}^{...}(c * a)
-    \sum_{...}^{...}(a) * c \\rightarrow \sum_{...}^{...}(a * c)
-    $$
-    Args:
-        expr (jm.Expression): target expression
-
-    Returns:
-        jm.Expression: expanded expression
-    """
-
-    # extract & replace
-    def pattern_expand_add(expr: jm.Expression) -> tp.Optional[jm.Expression]:
-        """pattern 1
-        a * (c + d) -> a * c + a * d
-        (c + d) * a -> c * a + d * a
-        \sum_{...}^{...}(a + b) -> \sum_{...}^{...}(a) + \sum_{...}^{...}(b)
-        c * \sum_{...}^{...}(a) -> \sum_{...}^{...}(c * a)
-        \sum_{...}^{...}(a) * c -> \sum_{...}^{...}(a * c)
-        """
-        if isinstance(expr, jm.expression.expression.Mul):
-            if isinstance(expr.right, jm.expression.expression.Add):
-                a = expr.left
-                c = expr.right.left
-                d = expr.right.right
-                return a * c + a * d
-
-            elif isinstance(expr.left, jm.expression.expression.Add):
-                a = expr.right
-                c = expr.left.left
-                d = expr.left.right
-                return c * a + d * a
-            elif isinstance(expr.right, jm.expression.sum.SumOperator):
-                c = expr.left
-                sum_expr = expr.right
-                return jm.expression.sum.SumOperator(
-                    sum_expr.sum_index, c * sum_expr.operand, sum_expr.condition
-                )
-            elif isinstance(expr.left, jm.expression.sum.SumOperator):
-                c = expr.right
-                sum_expr = expr.left
-                return jm.expression.sum.SumOperator(
-                    sum_expr.sum_index, sum_expr.operand * c, sum_expr.condition
-                )
-
-        if isinstance(expr, jm.expression.sum.SumOperator):
-            if isinstance(expr.operand, jm.expression.expression.Add):
-                operand_left = expr.operand.left
-                operand_right = expr.operand.right
-                return jm.expression.sum.SumOperator(
-                    expr.sum_index, operand_left, expr.condition
-                ) + jm.expression.sum.SumOperator(
-                    expr.sum_index, operand_right, expr.condition
-                )
-
-        return None
-
-    replaced_expr = expr
-
-    # repeat until no more replacement
-    while True:
-        new_replaced_expr = replace_if(replaced_expr, pattern_expand_add)
-        if jm.expr_same(replaced_expr, new_replaced_expr, check_id=False):
-            break
-        replaced_expr = new_replaced_expr
-
-    return replaced_expr

jijmodeling/match/expr_same.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-from jijmodeling.expression.condition import Condition
-from jijmodeling.expression.expression import Expression
-from jijmodeling.expression.variables.variable import Range
-from jijmodeling.match.is_same_expr import ExpressionType, is_same_cond, is_same_expr
-
-
-def expr_same(
-    target: Union[ExpressionType, Condition],
-    pattern: Union[ExpressionType, Condition],
-    check_id: bool = True,
-) -> bool:
-    """
-    Check if two expressions are the same.
-    Args:
-        target (Union[ExpressionType, Condition]): target expression
-        pattern (Union[ExpressionType, Condition]): pattern expression
-        check_id (bool): check if the uuid is the same, default is True
-    Returns:
-        bool: True if the expressions are the same
-    """
-    if isinstance(target, (Expression, Range)) and isinstance(
-        pattern, (Expression, Range)
-    ):
-        return is_same_expr(target, pattern, check_id)
-    elif isinstance(target, Condition) and isinstance(pattern, Condition):
-        return is_same_cond(target, pattern, check_id)
-    else:
-        return False

jijmodeling/match/is_same_expr.py

@@ -1,306 +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
-    if type(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)
-    elif type(target) is ArrayShape and type(pattern) is ArrayShape:
-        return is_same_arrayshape(target, pattern, check_id)
-    # Case: No match
-    else:
-        raise TypeError(
-            f"{target.__class__.__name__} is not supported in `is_same_expr`."
-        )
-
-
-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_arrayshape(target: ArrayShape, pattern: ArrayShape, check_id: bool) -> bool:
-    # Compare the following attributes:
-    # - array
-    # - dim
-    if is_same_expr(target.array, pattern.array, check_id):
-        return False
-    elif target.dimension != pattern.dimension:
-        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