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

jijmodeling/match/replace.py

@@ -1,249 +0,0 @@
-import typing as tp
-
-from functools import singledispatch
-
-import jijmodeling as jm
-import jijmodeling.expression.condition as jc
-
-from jijmodeling.expression.extract import extract_expressions
-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 recursively 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
-
-    Returns:
-        jm.Expression: replaced sub tree
-
-    Examples:
-        ```python
-        import jijmodeling as jm
-        n = jm.Placeholder("n")
-        i = jm.Element("i", n)
-        x = jm.Binary("x", shape=(n, n))
-        x_i = x[i]
-        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]))
-        ```
-
-        ```python
-        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)
-
-
-def replace_if(
-    expr: jm.Expression,
-    replace_func: tp.Callable[[jm.Expression], tp.Optional[jm.Expression]],
-):
-    """recursively replace expression if `replace_func` returns `jm.Expression` object. Otherwise, the expression is not replaced.
-    This function does the following process only once:
-    1. extract all the expressions that satisfies `replace_func`
-    2. replace the expression with the result of `replace_func`
-
-    Args:
-        expr (jm.Expression): expression
-        replace_func (tp.Callable[[jm.Expression], tp.Optional[jm.Expression]]): `jm.Expression` object is given and `jm.Expression` object is returned if the expression is replaced.
-
-    Returns:
-        jm.Expression: replaced expression
-    """
-    # list all expression to be replaced
-    replaced_expr = expr
-    is_replaced = lambda expr: replace_func(expr) is not None
-    replace_candidates = extract_expressions(replaced_expr, is_replaced)
-    new_replaced_expr = replaced_expr
-    for candidate in replace_candidates:
-        new_replaced_expr = replace(
-            new_replaced_expr,
-            candidate,
-            tp.cast(jm.Expression, replace_func(candidate)),
-            check_id=False,
-        )
-
-    return new_replaced_expr
-
-
-@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"]

jijmodeling/problem/problem.py

@@ -1,186 +0,0 @@
-from __future__ import annotations
-
-import copy as _copy
-import enum as _enum
-import typing as tp
-
-import typeguard as _typeguard
-
-from jijmodeling.deprecation.deprecation import deprecated_kwargs
-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):
-    """Problem sense.
-
-    Attributes:
-        MINIMUM (str): minimize problem.
-        MAXIMUM (str): maximize problem.
-    """
-
-    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.
-    """
-    @tp.overload
-    def __init__(
-        self,
-        name: str,
-        *,
-        sense: tp.Union[ProblemSense, str] = ProblemSense.MINIMUM,
-    ) -> None: ...
-
-    @deprecated_kwargs(
-        name="Problem",
-        pos_len=1,
-        removes=["objective", "constraints", "penalties"]
-    )
-    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:
-            name (str): problem name
-            sense (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, str)
-        _typeguard.check_type(self._sense, ProblemSense)
-        _typeguard.check_type(self._constraints, tp.Dict[str, _constraint.Constraint])
-        _typeguard.check_type(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
-    
-    @property
-    def custom_penalty_terms(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__)
-
-from jijmodeling.protobuf.to_protobuf import to_protobuf
-from jijmodeling.protobuf.from_protobuf import from_protobuf
-
-__all__ = ["to_protobuf", "from_protobuf"]