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

jijmodeling/match/is_same_expr.py

@@ -1,304 +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

jijmodeling/match/replace.py

@@ -1,210 +0,0 @@
-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)

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