jijmodeling 0.10.15__cp38-cp38-win_amd64.whl → 0.10.16__cp38-cp38-win_amd64.whl

jijmodeling/__init__.py

@@ -41,6 +41,7 @@ from jijmodeling.match.expr_same import expr_same
 from jijmodeling.match.is_same_expr import is_same_cond, is_same_expr
 from jijmodeling.match.penalty_same import penalty_same
 from jijmodeling.match.problem_same import problem_same
+from jijmodeling.match.replace import replace
 from jijmodeling.problem.problem import Problem, ProblemSense
 from jijmodeling.protobuf.from_protobuf.from_protobuf import from_protobuf
 from jijmodeling.protobuf.to_protobuf.to_protobuf import to_protobuf
@@ -89,6 +90,7 @@ __all__ = [
     "is_same_expr",
     "penalty_same",
     "problem_same",
+    "replace",
     "Binary",
     "DecisionVariable",
     "Element",

jijmodeling/_version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '0.10.15'
-__version_tuple__ = version_tuple = (0, 10, 15)
+__version__ = version = '0.10.16'
+__version_tuple__ = version_tuple = (0, 10, 16)

jijmodeling/expression/utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import itertools as it
 import typing as tp
 
 import typeguard as _typeguard
@@ -173,3 +174,28 @@ def check_non_decision_variable(
         for v in variables:
             if isinstance(v, _deci_vars.DecisionVariable):
                 raise _exceptions.CannotContainDecisionVarError(error_msg)
+
+
+def flatten_binary_operator(
+    expression: _expression.Expression,
+    op_type: tp.Type[_expression.BinaryOperator] = _expression.Add,
+) -> tp.List[_expression.Expression]:
+    """
+    Flatten `op_type` binary operator to list.
+    This function flattens a given node to the following:
+        node1 <> node2 <> node3 <> ... <> nodeN -> [node1, node2, node3, ..., nodeN]
+    where <> is a specified binary operator by `op_type`.
+
+    Args:
+        expression (Expression): target expression.
+        op_type (Type[BinaryOperator]): target binary operator.
+
+    Returns:
+        List[Expression]: list of expression. Each element is not binary operator.
+    """
+    if isinstance(expression, op_type):
+        left = flatten_binary_operator(expression.left, op_type)
+        right = flatten_binary_operator(expression.right, op_type)
+        return list(it.chain.from_iterable([left, right]))
+    else:
+        return [expression]

jijmodeling/match/expr_same.py

@@ -13,6 +13,15 @@ def expr_same(
     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)
     ):

jijmodeling/match/is_same_expr.py

@@ -31,6 +31,8 @@ def is_same_expr(
     # 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:
@@ -70,9 +72,11 @@ def is_same_expr(
         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.")
+        raise TypeError(f"{target.__class__.__name__} is not supported in `is_same_expr`.")
 
 
 def is_same_cond(target: Condition, pattern: Condition, check_id) -> bool:
@@ -112,6 +116,18 @@ def is_same_number(target: Number, pattern: Number) -> bool:
         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

jijmodeling/match/replace.py

@@ -0,0 +1,210 @@
+import typing as tp
+
+from functools import singledispatch
+
+import jijmodeling as jm
+from jijmodeling.exceptions.exceptions import JijModelingError
+import jijmodeling.expression.condition as jc
+
+from jijmodeling.match.expr_same import expr_same
+
+
+def replace(
+    expr: jm.Expression, target: jm.Expression, source: jm.Expression, check_id: bool
+) -> jm.Expression:
+    """
+    replace expression (from `target` element to `source` one)
+    This function selects the target element from the expression and replaces it with the source element.
+
+    Args:
+        expr (jm.Expression): expression
+        target (jm.Expression): target sub tree
+        source (jm.Expression): new sub tree
+        check_id (bool): replace only if the uuid is the same, default is True
+
+    Returns:
+        jm.Expression: replaced sub tree
+
+    Examples:
+        >>> import jijmodeling as jm
+        >>> n = jm.Placeholder("n")
+        >>> i = jm.Element("i", n)
+        >>> x = jm.Binary("x", shape=(n, n))
+        >>> x_i = x[i]  # [i] は xi を生成するたびにuuidが変わるので replaceで使うには一度だけ生成したオブジェクトを使い回す必要がある
+        >>> expr = jm.Sum(i, x_i)
+        >>> u = jm.Integer("u", shape=(n,), lower=0, upper=10)
+        >>> k = jm.Placeholder("k")
+        >>> j = jm.Element("j", k)
+        >>> y = jm.Placeholder("y", shape=(n, k))
+        >>> replaced = replace(expr, x_i, jm.Sum(j, u[i]*y[i,j]), check_id=True)
+        >>> print(replaced)
+        >>> Sum_{i=0}^{n}(Sum_{j=0}^{k}(u[i]*y[i,j]))
+
+        >>> import jijmodeling as jm
+        >>> n = jm.Placeholder("n")
+        >>> i = jm.Element("i", n)
+        >>> x = jm.Binary("x", shape=(n, n))
+        >>> expr = jm.Sum(i, x[i])
+        >>> u = jm.Integer("u", shape=(n,), lower=0, upper=10)
+        >>> k = jm.Placeholder("k")
+        >>> j = jm.Element("j", k)
+        >>> y = jm.Placeholder("y", shape=(n, k))
+        >>> replaced = replace(expr, x[i], jm.Sum(j, u[i]*y[i,j]), check_id=False) # check_id=False にすると、uuidが異なっていても置換できる
+        >>> print(replaced)
+        >>> Sum_{i=0}^{n}(Sum_{j=0}^{k}(u[i]*y[i,j]))
+    """
+    if expr_same(expr, target, check_id):
+        return source
+    
+    return _replace(expr, target, source, check_id)
+
+
+@singledispatch
+def _replace(
+    expr: jm.Expression, target: jm.Expression, source: jm.Expression, check_id: bool
+) -> jm.Expression:
+    raise TypeError(f"{type(expr)} is not supported in `replace`.")
+
+
+# List all the types that are inherited from `jm.Expression` and register them to `_replace` function.
+@_replace.register
+def _(expr: jm.ArrayShape, target: jm.Expression, source: jm.Expression, check_id: bool) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+    if isinstance(source, (jm.Variable, jm.Subscripts)) and expr_same(expr.array, target, check_id):
+        return source.shape[expr.dim]
+    return expr
+
+
+@_replace.register
+def _(
+    expr: jm.expression.Number,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+    return expr
+
+
+@_replace.register
+def _(
+    expr: jm.expression.BinaryOperator,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+
+    cls = type(expr)
+    replaced_left = _replace(expr.left, target, source, check_id)
+    replaced_right = _replace(expr.right, target, source, check_id)
+    return cls(replaced_left, replaced_right)
+
+
+@_replace.register
+def _(
+    expr: jm.expression.UnaryOperator,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+
+    cls = type(expr)
+    replaced = _replace(expr, target, source, check_id)
+    return cls(replaced)
+
+
+@_replace.register
+def _(
+    expr: jm.expression.sum.ReductionOperator,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+
+    replaced_sum_index = tp.cast(
+        jm.Element, _replace(expr.sum_index, target, source, check_id)
+    )
+    replaced_operand = _replace(expr.operand, target, source, check_id)
+    replaced_condition = _replace_condition(expr.condition, target, source, check_id)
+    cls = type(expr)
+    return cls(replaced_sum_index, replaced_operand, replaced_condition)
+
+
+@_replace.register
+def _(
+    expr: jm.Variable, target: jm.Expression, source: jm.Expression, check_id: bool
+) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+    return expr
+
+
+
+@_replace.register
+def _(
+    expr: jm.Subscripts, target: jm.Expression, source: jm.Expression, check_id: bool
+) -> jm.Expression:
+    if expr_same(expr, target, check_id):
+        return source
+    replaced_variable = tp.cast(
+        jm.Variable, _replace(expr.variable, target, source, check_id)
+    )
+    replaced_subscripts = [
+        _replace(s, target, source, check_id) for s in expr.subscripts
+    ]
+    cls = type(expr)
+    return cls(replaced_variable, replaced_subscripts)
+
+
+@singledispatch
+def _replace_condition(
+    condition: jc.Condition,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jc.Condition:
+    raise TypeError(f"{type(condition)} is not supported in `replace`.")
+
+
+@_replace_condition.register
+def _(
+    condition: jc.NoneCondition,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jc.Condition:
+    return condition
+
+
+@_replace_condition.register
+def _(
+    condition: jc.CompareCondition,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jc.Condition:
+    replaced_left = _replace(condition.left, target, source, check_id)
+    replaced_right = _replace(condition.right, target, source, check_id)
+    cls = type(condition)
+    return cls(replaced_left, replaced_right)
+
+
+@_replace_condition.register
+def _(
+    condition: jc.ConditionOperator,
+    target: jm.Expression,
+    source: jm.Expression,
+    check_id: bool,
+) -> jc.Condition:
+    replaced_left = _replace_condition(condition.left, target, source, check_id)
+    replaced_right = _replace_condition(condition.right, target, source, check_id)
+    cls = type(condition)
+    return cls(replaced_left, replaced_right)