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

jijmodeling/expression/extract.py

@@ -1,139 +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:
-        Set[Variable]: A set 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_var_dict(
-    expression: _expression.Expression,
-) -> tp.Dict[str, _variable.Variable]:
-    var_set = {}
-    for child in expression.children():
-        var_set.update(_extract_var_dict(child))
-    if isinstance(expression, _variable.Variable):
-        var_set[expression.uuid] = expression
-    return var_set
-
-
-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
-
-    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,133 +0,0 @@
-from __future__ import annotations
-
-from jijmodeling.expression.condition import (
-    AndOperator,
-    Equal,
-    LessThan,
-    LessThanEqual,
-    NoneCondition,
-    OrOperator,
-    XorOperator,
-)
-from jijmodeling.expression.constraint import Constraint, Penalty
-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()}
-
-    return jm_cls(**attr_values)

jijmodeling/expression/mathfunc.py

@@ -1,269 +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",
-            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.
-
-        Example:
-            >>> 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):
-    def __repr__(self) -> str:
-        return "|" + str(self.operand) + "|"
-
-    @classmethod
-    def operation(cls, operand: _expression.NumericValue) -> _expression.NumericValue:
-        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):
-    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:
-        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):
-    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:
-        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):
-    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."""
-    return AbsoluteValue.create(term)
-
-
-def ceil(term) -> _expression.Expression:
-    """Ceiling function."""
-    return Ceil.create(term)
-
-
-def floor(term) -> _expression.Expression:
-    """Floor function."""
-    return Floor.create(term)
-
-
-def log2(antilog) -> _expression.Expression:
-    """
-    Log function.
-
-    Args:
-        antilog (int | float |_expression.Expression): antilog
-
-    ```math
-    \\log_{2}\\mathrm{antilog}
-    ```
-
-    Returns:
-        Log: Log2 value
-    """
-    return Log2.create(antilog)
-
-
-def max(left, right) -> _expression.Expression:
-    """Max function."""
-    return Max.create(left, right)
-
-
-def min(left, right) -> _expression.Expression:
-    """Min function."""
-    return Min.create(left, right)

jijmodeling/expression/prod.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Optional, Tuple, Union
-
-from typeguard import typechecked
-
-import jijmodeling.expression.condition as _condition
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.sum as _sum
-
-# type validation
-import jijmodeling.expression.variables.variable as _variable
-
-
-class ProdOperator(_sum.ReductionOperator):
-    pass
-
-
-INDEXWITHCOND = Union[_variable.Element, Tuple[_variable.Element, _condition.Condition]]
-
-
-def Prod(
-    indices: Union[INDEXWITHCOND, List[INDEXWITHCOND]],
-    term: _expression.Expression,
-) -> ProdOperator:
-    """
-    Prod function.
-
-    Args:
-        indices: index list of index.
-        term (Expression): operand
-
-    Returns:
-        ProdOperator: ProdOperator object.
-
-    Example:
-        Create $\\prod_{i=0}^n d_i x_i$
-
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', dim=1)
-        n = d.shape[0]
-        x = jm.Binary('x', shape=n)
-        i = jm._variable.Element('i', n)
-        jm.Prod(i, d[i]*x[i])
-        ```
-
-        Π_{i}(d[i]x[i])
-
-        Create $\\prod_{i}\\sum_j d_{ij}x_i x_j$
-
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', dim = 2)
-        n = d.shape[0]
-        x = jm.Binary('x', shape=n)
-        i = jm._variable.Element('i', n)
-        j = jm._variable.Element('j', n)
-        jm.Prod([i, j], d[i, j]*x[i]*x[j])
-        ```
-
-        Conditional production
-
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', dim = 2)
-        n = d.shape[0]
-        i, j = jm._variable.Element("i", n), jm._variable.Element("j", n)
-        x = jm.Binary('x', shape=n)
-        jm.Prod([i, (j, i < j)], d[i, j]*x[i]*x[j])
-        ```
-    """
-
-    # convert indices and condition to list-type object
-    # ex. i -> [i]
-    indices_list = indices if isinstance(indices, list) else [indices]  # type: ignore
-
-    # element type from users
-    IndexType = Union[
-        _variable.Element, Tuple[_variable.Element, Optional[_condition.Condition]]
-    ]
-
-    @typechecked
-    def convert_to_element(
-        index: IndexType,
-    ) -> Tuple[_variable.Element, Optional[_condition.Condition]]:
-        if isinstance(
-            index, tuple
-        ):  # Tuple[_variable.ElementType, Optional[Condition]]
-            elem, cond = index
-            return (elem, cond)
-        else:  # _variable.ElementType
-            return (index, None)
-
-    elems_and_conds: List[Tuple[_variable.Element, Optional[_condition.Condition]]] = [
-        convert_to_element(index) for index in indices_list
-    ]
-    elements = [elem for elem, _ in elems_and_conds]
-    condition_list = [cond for _, cond in elems_and_conds]
-
-    # list length validation
-    import jijmodeling.utils.utils as _utils
-
-    _utils.validate_value("len(indices) > 0", len(elements) > 0)
-    _utils.validate_value("len(condition_list) > 0", len(condition_list) > 0)
-    _utils.validate_value(
-        "len(indices_list)  == len(condition_list)",
-        len(indices_list) == len(condition_list),
-    )
-    sum_term = term
-    for sum_index, cond in zip(elements[::-1], condition_list[::-1]):
-        sum_term = ProdOperator(
-            sum_index=sum_index,
-            operand=sum_term,
-            condition=cond if cond is not None else _condition.NoneCondition(),
-        )
-    return sum_term  # type: ignore