jijmodeling 0.13.2__cp310-cp310-win_amd64.whl → 1.12.0__cp310-cp310-win_amd64.whl

jijmodeling/expression/extract.py

@@ -1,186 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.condition as _condition
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.variables.deci_vars as _deci_vars
-import jijmodeling.expression.variables.variable as _variable
-import jijmodeling.problem.problem as _problem
-
-
-def extract_variables(
-    expression: _expression.Expression,
-) -> tp.List[_variable.Variable]:
-    """
-    Extract variables.
-
-    Args:
-        expression (Expression): target expression
-
-    Returns:
-        List[Variable]: A list of variables included in the expression.
-
-    Examples:
-        ```python
-        import jijmodeling as jm
-        from jijmodeling.expression.extract import extract_variables
-        a = jm.Placeholder("d", dim=2)
-        n = a.shape[0]
-        x = jm.Binary("x", shape=(n, ))
-        i, j = jm.Element("i", n), jm.Element("j", n)
-        term = jm.Sum([i, j], x[i] - s[i, j])
-        extract_variables(term)
-        # >>> [j, i, s, x, a, a_shape_0]
-        ```
-    """
-    return list(_extract_var_dict(expression).values())
-
-
-def extract_expressions(
-    expression: _expression.Expression,
-    pattern: tp.Callable[[_expression.Expression], bool],
-) -> tp.List[_expression.Expression]:
-    """
-    Extract expressions.
-
-    Args:
-        expression (Expression): target expression
-        pattern (Callable[Expression, bool]): pattern to extract
-
-    Returns:
-        List[Expression]: A list of expressions included in the expression.
-
-    Examples:
-        ```python
-        import jijmodeling as jm
-        from jijmodeling.expression.extract import extract_expressions
-        a = jm.Placeholder("d", dim=2)
-        n = a.shape[0]
-        x = jm.Binary("x", shape=(n, ))
-        i, j = jm.Element("i", n), jm.Element("j", n)
-        s = jm.Binary("s", shape=(n, n))
-        term = jm.Sum([i, j], x[i] - s[i, j])
-        extract_expressions(term, lambda x: isinstance(x, jm.Element))
-        # >>> [i, j]
-        extract_expressions(term, lambda x: isinstance(x, jm.Binary))
-        # >>> [x, s]
-        extract_expressions(term, lambda x: isinstance(x, jm.Subscripts) and x.variable.label == "s")
-        # >>> [s[i, j]]
-        ```
-    """
-    return list(_extract_node_dict(expression, pattern).values())
-
-
-def _extract_node_dict(
-    expression: _expression.Expression,
-    condition: tp.Callable[[_expression.Expression], bool],
-) -> tp.Dict[str, _expression.Expression]:
-    var_set = {}
-    for child in expression.children():
-        var_set.update(_extract_node_dict(child, condition))
-    if condition(expression):
-        var_set[expression.uuid] = expression
-    return var_set
-
-
-def _extract_var_dict(
-    expression: _expression.Expression,
-) -> tp.Dict[str, _variable.Variable]:
-    return tp.cast(
-        tp.Dict[str, _variable.Variable],
-        _extract_node_dict(expression, lambda x: isinstance(x, _variable.Variable)),
-    )
-
-
-def extract_vars_from_cond(
-    condition: _condition.Condition,
-) -> tp.List[_variable.Variable]:
-    return list(_extract_vars_from_cond_dict(condition).values())
-
-
-def _extract_vars_from_cond_dict(
-    condition: _condition.Condition,
-) -> tp.Dict[str, _variable.Variable]:
-    if isinstance(condition, _condition.CompareCondition):
-        var_dict = _extract_var_dict(condition.left)
-        var_dict.update(_extract_var_dict(condition.right))
-        return var_dict
-
-    elif isinstance(condition, _condition.ConditionOperator):
-        var_dict = _extract_vars_from_cond_dict(condition.left)
-        var_dict.update(_extract_vars_from_cond_dict(condition.right))
-        return var_dict
-    else:
-        return {}
-
-
-def extract_vars_from_problem(problem: _problem.Problem) -> tp.List[_variable.Variable]:
-    return list(_extract_vars_from_problem_dict(problem).values())
-
-
-def _extract_vars_from_problem_dict(
-    problem: _problem.Problem,
-) -> tp.Dict[str, _variable.Variable]:
-    # Extracts all variables from the objective function
-    variables = _extract_var_dict(problem.objective)
-
-    # Extracts all variables from all the constraints
-    for constraint in problem.constraints.values():
-        variables.update(_extract_vars_from_cond_dict(constraint.condition))
-        for index, condition in constraint.forall:
-            variables.update(_extract_var_dict(index))
-            variables.update(_extract_vars_from_cond_dict(condition))
-        if constraint.left_lower is not None:
-            variables.update(_extract_var_dict(constraint.left_lower))
-
-    # Extracts all variables from all the user-defined penalty
-    for penalty in problem.penalties.values():
-        variables.update(_extract_var_dict(penalty.penalty_term))
-        for index, condition in penalty.forall:
-            variables.update(_extract_var_dict(index))
-            variables.update(_extract_vars_from_cond_dict(condition))
-
-    return variables
-
-
-def check_unique_variable_label(expression: _expression.Expression):
-    """
-    Check unique variable label.
-
-    Args:
-        expression (Expression): target expression
-
-    Returns:
-        None: If the every variable label is unique.
-
-    Raises:
-        ModelingError: If label is not unique.
-    """
-    variables = extract_variables(expression)
-    var_labels = []
-    for v in variables:
-        if v.label not in var_labels:
-            var_labels.append(v.label)
-        else:
-            raise _exceptions.ModelingError(
-                f"It seems that the variable {v.label} is defined twice. "
-                + "Please check the label when defining the variable."
-            )
-
-
-def has_decivar(expression: _expression.Expression) -> bool:
-    variables = extract_variables(expression)
-    for v in variables:
-        if isinstance(v, _deci_vars.DecisionVariable):
-            return True
-    return False
-
-
-def condition_has_decivar(condition: _condition.Condition) -> bool:
-    variables = extract_vars_from_cond(condition)
-    for v in variables:
-        if isinstance(v, _deci_vars.DecisionVariable):
-            return True
-    return False

jijmodeling/expression/from_old_serializable.py

@@ -1,137 +0,0 @@
-from __future__ import annotations
-import warnings
-
-from jijmodeling.expression.condition import (
-    AndOperator,
-    Equal,
-    LessThan,
-    LessThanEqual,
-    NoneCondition,
-    OrOperator,
-    XorOperator,
-)
-from jijmodeling.expression.constraint import Constraint, Penalty
-from jijmodeling.deprecation.deprecation import JijFutureWarning
-from jijmodeling.expression.expression import (
-    Add,
-    Div,
-    Expression,
-    Mod,
-    Mul,
-    Number,
-    Power,
-)
-from jijmodeling.expression.mathfunc import AbsoluteValue, Ceil, Floor, Log2, Max, Min
-from jijmodeling.expression.prod import ProdOperator
-from jijmodeling.expression.sum import SumOperator
-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
-from jijmodeling.problem import Problem, ProblemSense
-
-_OLD_NAME_TO_CLASS = {
-    "jijmodeling.expression.variables.placeholders.Placeholder": Placeholder,
-    "jijmodleing.expression.variables.jagged_array.JaggedArray": JaggedArray,
-    "jijmodeling.expression.variables.variable.Subscripts": Subscripts,
-    "jijmodeling.expression.variables.variable.Element": Element,
-    "jijmodeling.expression.variables.variable.Range": Range,
-    "jijmodeling.expression.variables.placeholders.ArrayShape": ArrayShape,
-    "jijmodeling.expression.expression.Number": Number,
-    "jijmodeling.expression.expression.Add": Add,
-    "jijmodeling.expression.expression.Mul": Mul,
-    "jijmodeling.expression.expression.Div": Div,
-    "jijmodeling.expression.expression.Power": Power,
-    "jijmodeling.expression.expression.Mod": Mod,
-    "jijmodeling.expression.mathfunc.AbsoluteValue": AbsoluteValue,
-    "jijmodeling.expression.mathfunc.Max": Max,
-    "jijmodeling.expression.mathfunc.Min": Min,
-    "jijmodeling.expression.mathfunc.Ceil": Ceil,
-    "jijmodeling.expression.mathfunc.Floor": Floor,
-    "jijmodeling.expression.mathfunc.Log2": Log2,
-    "jijmodeling.expression.prod.ProdOperator": ProdOperator,
-    "jijmodeling.expression.sum.SumOperator": SumOperator,
-    "jijmodeling.expression.variables.deci_vars.Binary": Binary,
-    "jijmodeling.expression.variables.deci_vars.LogEncInteger": Integer,
-    "jijmodeling.expression.condition.NoneCondition": NoneCondition,
-    "jijmodeling.expression.condition.AndOperator": AndOperator,
-    "jijmodeling.expression.condition.OrOperator": OrOperator,
-    "jijmodeling.expression.condition.XorOperator": XorOperator,
-    "jijmodeling.expression.condition.Equal": Equal,
-    "jijmodeling.expression.condition.LessEqual": LessThan,
-    "jijmodeling.expression.condition.LessThanEqual": LessThanEqual,
-    "jijmodeling.expression.constraint.Constraint": Constraint,
-    "jijmodeling.expression.constraint.Penalty": Penalty,
-}
-
-
-def from_0_10_0_serializable(serializable: dict) -> Problem:
-    if not serializable["version"] == "0.10.0":
-        raise ValueError(
-            f"In 'from_0_10_0_serializable', support only 0.10.0, not {serializable['version']}."
-        )
-
-    object_schema = serializable["object"]
-    if not object_schema["class"] == "jijmodeling.problem.Problem":
-        raise ValueError(
-            f"{object_schema['class']} is not supported in 'from_0_10_0_serializable'."
-        )
-
-    attributes = object_schema["attributes"]
-    name = attributes["name"]
-    _kind_map = {"Minimum": ProblemSense.MINIMUM, "Maximum": ProblemSense.MAXIMUM}
-    kind = _kind_map[attributes["kind"]]
-    objective = _class_0100_from_serializable(attributes["objective"])
-    constraints = [
-        _class_0100_from_serializable(c) for c in attributes["constraints"].values()
-    ]
-    penalties = [
-        _class_0100_from_serializable(c) for c in attributes["penalties"].values()
-    ]
-
-    problem = Problem(name, sense=kind)
-    problem += objective
-    for c in constraints:
-        problem += c
-    for p in penalties:
-        problem += p
-
-    return problem
-
-
-def old_0_10_0_to_new_from_serializable(serializable: dict) -> Expression:
-    """Deserialize from old schema to new JijModeling Expression."""
-    object_schema = serializable["object"]
-    return _class_0100_from_serializable(object_schema)
-
-
-def _0100_from_serializable(object_schema: dict | int | float | None):
-    if not isinstance(object_schema, dict):
-        return object_schema
-    if "class" in object_schema:
-        return _class_0100_from_serializable(object_schema)
-    elif "iteratable" in object_schema:
-        return _iteratable_0100_from_serializable(object_schema)
-    else:
-        raise ValueError(
-            f"'{object_schema.keys()}' is not supported in 0_10_0 deserializer."
-        )
-
-
-def _iteratable_0100_from_serializable(object_schema: dict):
-    value = [_0100_from_serializable(v) for v in object_schema["value"]]
-    if object_schema["iteratable"] == "tuple":
-        return tuple(value)
-    else:
-        return value
-
-
-def _class_0100_from_serializable(object_schema: dict):
-    jm_cls = _OLD_NAME_TO_CLASS[object_schema["class"]]
-    attributes = object_schema["attributes"]
-
-    attr_values = {k: _0100_from_serializable(v) for k, v in attributes.items()}
-
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=JijFutureWarning)
-        return jm_cls(**attr_values)

jijmodeling/expression/mathfunc.py

@@ -1,335 +0,0 @@
-from __future__ import annotations
-
-import abc as _abc
-import builtins as _builtins
-import numbers as _numbers
-import typing as tp
-
-from abc import abstractmethod
-
-import numpy as np
-import typeguard as _typeguard
-
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.expression as _expression
-
-
-class UnaryOperator(_expression.Expression, metaclass=_abc.ABCMeta):
-    """
-    Binary Operator class represents each operation (ex. +,*,&,...) on `_expression.Expression`.
-    """
-
-    _mark = " "
-
-    def __init__(
-        self,
-        operand: tp.Union[_expression.Expression, _expression.NumericValue],
-        uuid: tp.Optional[str] = None,
-    ):
-        super().__init__()
-
-        _typeguard.check_type(
-            operand,
-            tp.Union[_expression.Expression, _expression.NumericValue],
-        )
-
-        # convert int float to Number
-        self._operand: _expression.Expression = (
-            operand
-            if isinstance(operand, _expression.Expression)
-            else _expression.Number(operand)
-        )
-
-        import jijmodeling.utils.utils as _utils
-
-        _utils.validate_value("operand.is_operatable()", self._operand.is_operatable())
-
-        import jijmodeling.expression.extract as _extract
-
-        if _extract.has_decivar(self._operand):
-            raise _exceptions.CannotContainDecisionVarError(
-                "An unary operator operand cannot contain a decision variable."
-            )
-
-        if uuid is not None:
-            self._uuid = uuid
-
-    @property
-    def operand(self) -> _expression.Expression:
-        return self._operand
-
-    @classmethod
-    @abstractmethod
-    def operation(
-        cls: tp.Type[UnaryOperator], operand: _expression.NumericValue
-    ) -> _expression.NumericValue:
-        """
-        Execute operation.
-
-        Examples:
-            ```python
-            Ceil.operation(4.3)
-            # >>> 5
-            Floor.operation(3.9)
-            # >>> 3
-            Log2.operation(4)
-            # >>> 2.0
-            ```
-        """
-
-    @classmethod
-    def create(
-        cls: tp.Type[UnaryOperator],
-        operand: tp.Union[_expression.Expression, _expression.NumericValue],
-    ) -> _expression.Expression:
-        if isinstance(operand, (int, float, _numbers.Real)):
-            return _expression.Number(cls.operation(operand))
-        elif isinstance(operand, _expression.Number):
-            return _expression.Number(cls.operation(operand.value))
-        elif isinstance(operand, _expression.Expression):
-            return cls(operand)
-        else:
-            raise _exceptions.ModelingError(
-                "The operand of {} is support only number or_expression.Expression, not {}.".format(
-                    cls.__name__, operand.__class__.__name__
-                )
-            )
-
-    def is_operatable(self) -> bool:
-        """
-        Unary operator is operatable.
-
-        Returns:
-            bool: True
-        """
-        return True
-
-    def children(self) -> tp.List[_expression.Expression]:
-        return [self.operand]
-
-
-class AbsoluteValue(UnaryOperator):
-    """Absolute value operator."""
-
-    def __repr__(self) -> str:
-        return "|" + str(self.operand) + "|"
-
-    @classmethod
-    def operation(cls, operand: _expression.NumericValue) -> _expression.NumericValue:
-        """operation of absolute value.
-        Args:
-            operand (_expression.NumericValue): operand of absolute value.
-
-        Returns:
-            _expression.NumericValue: absolute value of operand.
-        """
-        abs_value: _expression.NumericValue = np.abs(operand)
-        return abs_value
-
-    def _default_repr_latex_(self) -> str:
-        return r"\left|" + self.operand._make_latex() + r"\right|"
-
-
-class Max(_expression.BinaryOperator):
-    """Max operator."""
-
-    def __init__(
-        self,
-        left: _expression.Expression,
-        right: _expression.Expression,
-        uuid: tp.Optional[str] = None,
-    ):
-        super().__init__(left, right, uuid)
-
-        import jijmodeling.expression.extract as _extract
-
-        if _extract.has_decivar(self.left) or _extract.has_decivar(self.right):
-            raise _exceptions.CannotContainDecisionVarError(
-                "operands of Max function cannot contain a decision variable."
-            )
-
-    def __repr__(self) -> str:
-        return "max(" + ",".join(map(str, [self.left, self.right])) + ")"
-
-    @classmethod
-    def operation(cls, left, right) -> tp.Any:
-        """operation of max.
-
-        Args:
-            left (_expression.Expression): left operand of max.
-            right (_expression.Expression): right operand of max.
-
-        Returns:
-            tp.Any: max value of left and right.
-        """
-        return _builtins.max(left, right)
-
-    def _default_repr_latex_(self) -> str:
-        left = self.left._make_latex()
-        right = self.right._make_latex()
-        return r"\max(" + f"{left}, {right})"
-
-
-class Min(_expression.BinaryOperator):
-    """Min operator."""
-
-    def __init__(
-        self,
-        left: _expression.Expression,
-        right: _expression.Expression,
-        uuid: tp.Optional[str] = None,
-    ):
-        super().__init__(left, right, uuid)
-
-        import jijmodeling.expression.extract as _extract
-
-        if _extract.has_decivar(self.left) or _extract.has_decivar(self.right):
-            raise _exceptions.CannotContainDecisionVarError(
-                "operands of Max function cannot contain a decision variable."
-            )
-
-    def __repr__(self) -> str:
-        return "min(" + ",".join(map(str, [self.left, self.right])) + ")"
-
-    @classmethod
-    def operation(cls, left, right) -> tp.Any:
-        """operation of min.
-
-        Args:
-            left (_expression.Expression): left operand of min.
-            right (_expression.Expression): right operand of min.
-
-        Returns:
-            tp.Any: min value of left and right.
-        """
-        return _builtins.min(left, right)
-
-    def _default_repr_latex_(self) -> str:
-        left = self.left._make_latex()
-        right = self.right._make_latex()
-        return r"\min(" + f"{left}, {right})"
-
-
-class Ceil(UnaryOperator):
-    """Ceil operator."""
-
-    def __repr__(self):
-        return "[" + str(self.operand) + "]"
-
-    @classmethod
-    def operation(cls, operand: _expression.NumericValue) -> _expression.NumericValue:
-        ceil_value: _expression.NumericValue = np.ceil(operand)
-        return ceil_value
-
-    def _default_repr_latex_(self) -> str:
-        term_str = (
-            self.operand._make_latex()
-            if isinstance(self.operand, _expression.Expression)
-            else str(self.operand)
-        )
-        return r"\left\lceil " + term_str + r"\right\rceil"
-
-
-class Floor(UnaryOperator):
-    def __repr__(self) -> str:
-        return "|_" + str(self.operand) + "_|"
-
-    @classmethod
-    def operation(cls, operand: _expression.NumericValue) -> _expression.NumericValue:
-        floor_value: _expression.NumericValue = np.floor(operand)
-        return floor_value
-
-    def _default_repr_latex_(self) -> str:
-        term_str = (
-            self.operand._make_latex()
-            if isinstance(self.operand, _expression.Expression)
-            else str(self._operand)
-        )
-        return r"\left\lfloor " + term_str + r"\right\floor "
-
-
-class Log2(UnaryOperator):
-    def __repr__(self) -> str:
-        return f"log2({str(self.operand)})"
-
-    @classmethod
-    def operation(cls, operand: _expression.NumericValue) -> tp.Any:
-        return np.log2(operand)
-
-    def _default_repr_latex_(self) -> str:
-        return r"\log_2" + f"({self.operand._make_latex()})"
-
-
-def abs(term) -> _expression.Expression:
-    """Absolute function.
-    Args:
-        term (int | float | Expression): term of absolute value.
-    Returns:
-        Union[AbsoluteValue, Expression]: absolute value of term.
-    """
-    return AbsoluteValue.create(term)
-
-
-def ceil(term) -> _expression.Expression:
-    """Ceiling function.
-    Args:
-        term (int | float | Expression): term of ceiling function.
-
-    Returns:
-        Union[Ceil, Expression]: ceiling value of term.
-    """
-    return Ceil.create(term)
-
-
-def floor(term) -> _expression.Expression:
-    """Floor function.
-
-    Args:
-        term (int | float | Expression): term of floor function.
-
-    Returns:
-        Union[Floor, Expression]: floor value of term.
-    """
-    return Floor.create(term)
-
-
-def log2(antilog) -> _expression.Expression:
-    """
-    Log function.
-
-    Args:
-        antilog (int | float |_expression.Expression): antilog
-
-    $$\\log_{2}\\mathrm{antilog}$$
-
-
-    Returns:
-        : Log2 value
-    """
-    return Log2.create(antilog)
-
-
-def max(left, right) -> _expression.Expression:
-    """Max function.
-
-    Args:
-        left (int | float | _expression.Expression): left operand of max.
-        right (int | float | _expression.Expression): right operand of max.
-
-    Returns:
-        Union[Max, Expression]: max value of left and right.
-    """
-    return Max.create(left, right)
-
-
-def min(left, right) -> _expression.Expression:
-    """Min function.
-
-    Args:
-        left (int | float | _expression.Expression): left operand of min.
-        right (int | float | _expression.Expression): right operand of min.
-
-    Returns:
-        Union[Min, Expression]: min value of left and right.
-    """
-    return Min.create(left, right)