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

jijmodeling/expression/prod.py

@@ -1,172 +0,0 @@
-from __future__ import annotations
-
-from typing import List, Optional, Tuple, Union
-import warnings
-
-from typeguard import typechecked
-
-from jijmodeling.deprecation.deprecation import (
-    deprecated_name,
-    JijFutureWarning
-)
-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]]
-
-
-@deprecated_name("Prod", "prod", kind="function")
-def Prod(
-    indices: Union[INDEXWITHCOND, List[INDEXWITHCOND]],
-    term: _expression.Expression,
-) -> ProdOperator:
-    """
-    Prod function.
-
-    Args:
-        indices: product index dict or 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.Element('i', n)
-        jm.Prod(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.Element('i', n)
-        j = jm.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.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
-
-    @typechecked
-    def convert_to_element(
-        index: Union[
-            _variable.Element, Tuple[_variable.Element, Optional[_condition.Condition]]
-        ],
-    ) -> 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
-
-
-def prod(
-    index: Union[INDEXWITHCOND, List[INDEXWITHCOND]],
-    operand: _expression.Expression,
-) -> ProdOperator:
-    """
-    Prod function.
-
-    Args:
-        indices: product index dict or list of index.
-        operand (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', ndim=1)
-        n = d.shape[0]
-        x = jm.BinaryVar('x', shape=n)
-        i = jm.Element('i', n)
-        jm.prod(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', ndim=2)
-        n = d.shape[0]
-        x = jm.BinaryVar('x', shape=n)
-        i = jm.Element('i', n)
-        j = jm.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', ndim=2)
-        n = d.shape[0]
-        i, j = jm.Element("i", n), jm._variable.Element("j", n)
-        x = jm.BinaryVar('x', shape=n)
-        jm.prod([i, (j, i < j)], d[i, j]*x[i]*x[j])
-        ```
-    """
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=JijFutureWarning)
-        return Prod(index, operand)

jijmodeling/expression/serializable.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import abc as _abc
-import enum as _enum
-import inspect as _inspect
-import typing as tp
-import uuid as _uuid
-import warnings
-
-from typeguard import typechecked
-
-import jijmodeling
-from jijmodeling.deprecation.deprecation import JijFutureWarning
-
-
-class Serializable(_abc.ABCMeta):
-    """
-    Meta class that can call `to_serializable()` and `from_serializable()`.
-    """
-
-    def __new__(cls, cls_name, cls_bases, cls_dict):
-        if "__init__" in cls_dict:
-            # serializeで用いるためExpressionクラスはコンストラクタの引数と対応する同じ名前の
-            # @property を持つ必要があるので, それが実装されているかをチェックする
-            init_func = _inspect.signature(cls_dict["__init__"])
-            params = [param for param in init_func.parameters if param != "self"]
-            for param in params:
-                if param not in cls_dict:
-                    bases_has_property = False
-                    for bases in cls_bases:
-                        if param in dir(bases):
-                            bases_has_property = True
-                    if not bases_has_property:
-                        raise NotImplementedError(
-                            f"propety '{param}' must be" + f" define in {cls_name}."
-                        )
-        return super().__new__(cls, cls_name, cls_bases, cls_dict)
-
-
-def to_serializable(expression: Serializable) -> dict:
-    """
-    Serialize an serializable object.
-
-    Args:
-        expression (Serializable): e.g. mathematical expression, problem, ...
-
-    Returns:
-        dict: serialized object
-    """
-    seri = obj_to_seri(expression)
-    return {"version": "0.10.0", "object": seri}
-
-
-def obj_to_seri(obj):
-    if isinstance(obj.__class__, Serializable):
-        return expression_to_seri(obj)
-    elif isinstance(obj, (list, tuple)):
-        return {
-            "iteratable": "list" if isinstance(obj, list) else "tuple",
-            "value": [obj_to_seri(v) for v in obj],
-        }
-    elif isinstance(obj, dict):
-        return {k: obj_to_seri(v) for k, v in obj.items()}
-    elif isinstance(obj, _uuid.UUID):
-        return obj.hex
-    elif isinstance(obj, _enum.Enum):
-        if isinstance(obj, jijmodeling.expression.expression.DataType):
-            return obj.value.lower()
-        else:
-            return obj.value
-    else:
-        return obj
-
-
-def expression_to_seri(expression: Serializable) -> dict:
-    exp_module = expression.__class__.__module__
-    exp_cls = expression.__class__.__name__
-    serializable: tp.Dict[str, tp.Any] = {"class": exp_module + "." + exp_cls}
-
-    init_args_keys = _inspect.signature(expression.__class__.__init__).parameters.keys()
-    init_params = {}
-    for key in init_args_keys:
-        # Ignore `self` because it is not used as a key for a serialized object
-        if key == "self":
-            continue
-        # Expression class の constructor の引数名と同じpropertyを必ず各クラスは持っているので
-        # それを情報としてserializeする
-        if f"_{key}" in dir(expression):
-            value = eval(f"expression._{key}")
-        else:
-            value = eval(f"expression.{key}")
-        init_params[key] = obj_to_seri(value)
-    serializable["attributes"] = init_params
-    return serializable
-
-
-@typechecked
-def from_serializable(serializable: tp.Union[dict, list]):
-    """
-    Convert to Expression from serializable object (dict).
-
-    Args:
-        serializable (dict): serialized object
-
-    Returns:
-        Expression|Problem: e.g. mathematical expression, problem, ...
-
-    """
-    if isinstance(serializable, dict) and "object" in serializable:
-        obj = serializable["object"]
-    else:
-        raise ValueError("version mismatch")
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=JijFutureWarning)
-        return obj_from_seri(obj)
-
-
-def obj_from_seri(obj):
-    if isinstance(obj, dict) and "class" in obj:
-        modulePath = obj["class"].split(".")[1:]
-        module = jijmodeling
-        for m in modulePath:
-            module = getattr(module, m)
-        # get name of arguments of __init__ of Expression object
-        init_args = _inspect.signature(module.__init__).parameters.keys()
-        init_arg_values = {
-            arg: obj_from_seri(obj["attributes"][arg])
-            for arg in init_args
-            if arg != "self"
-        }
-        return module(**init_arg_values)
-    elif isinstance(obj, dict) and "iteratable" in obj:
-        if obj["iteratable"] == "list":
-            return [obj_from_seri(s) for s in obj["value"]]
-        elif obj["iteratable"] == "tuple":
-            return tuple(obj_from_seri(s) for s in obj["value"])
-    elif isinstance(obj, list):
-        return [obj_from_seri(s) for s in obj]
-    elif isinstance(obj, dict):
-        return {k: obj_from_seri(v) for k, v in obj.items()}
-
-    return obj

jijmodeling/expression/sum.py

@@ -1,261 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-import warnings
-
-import typeguard as _typeguard
-
-from typeguard import typechecked
-
-from jijmodeling.deprecation.deprecation import (
-    deprecated_name,
-    JijFutureWarning
-)
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.condition as _conditions
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.extract as _extract
-
-# type validation
-import jijmodeling.expression.type_annotations as _type_annotations
-import jijmodeling.expression.variables.variable as _variable
-import jijmodeling.utils.utils as _utils
-
-
-class ReductionOperator(_expression.Expression):
-    """Super class of reduction operators.
-    Subclass examples: SumOperator, ProdOperator
-    """
-
-    def __init__(
-        self,
-        sum_index: _variable.Element,
-        operand: _expression.Expression,
-        condition: tp.Optional[_conditions.Condition] = None,
-        uuid: tp.Optional[str] = None,
-    ) -> None:
-        super().__init__(uuid=uuid)
-
-        self._sum_index = sum_index
-        self._operand = operand
-        self._condition: _conditions.Condition = (
-            _conditions.NoneCondition() if condition is None else condition
-        )
-        if uuid is not None:
-            self._uuid = uuid
-
-        if _extract.condition_has_decivar(self._condition):
-            raise _exceptions.CannotContainDecisionVarError(
-                "condition for sum index cannot contain decision variable."
-            )
-
-        ConditionType = tp.Optional[_conditions.Condition]
-        _typeguard.check_type(self._sum_index, _type_annotations.SumIndexType)
-        _typeguard.check_type(self._operand, _type_annotations.OperandType)
-        _typeguard.check_type(self._condition, ConditionType)
-
-    @property
-    def sum_index(self) -> _variable.Element:
-        """Summation index."""
-        return self._sum_index
-
-    @property
-    def operand(self) -> _expression.Expression:
-        """Summation operand."""
-        return self._operand
-
-    @property
-    def condition(self) -> _conditions.Condition:
-        """Summation condition."""
-        return self._condition
-
-    def children(self) -> list:
-        """[sum_index, operand, condition]."""
-        return [self._sum_index, self._operand] + self.condition.expressions()
-
-    def is_operatable(self) -> bool:
-        return True
-
-    def __repr__(self) -> str:
-        sum_index = ""
-        if isinstance(self.sum_index.parent, _variable.Range):
-            sum_index = "{" + "{}={}".format(
-                self.sum_index, self.sum_index.parent.start
-            )
-            sum_index = sum_index + "}"
-            sum_index = sum_index + "^{" + str(self.sum_index.parent.last) + "}"
-        else:
-            sum_index = "{" + f"{self.sum_index} in {self.sum_index.parent}"
-            sum_index = sum_index + "}"
-
-        return "Sum_" + sum_index + "(" + str(self.operand) + ")"
-
-
-class SumOperator(ReductionOperator):
-    """
-    Class that represents the sum.
-
-    Example:
-        Create $`\\sum_{i=0}^n d_i x_i`$
-
-        ```python
-        from jijmodeling import Placeholder, Binary, SumOperator
-        from jijmodeling import Element
-        d = Placeholder('d', dim=1)
-        n = d.shape[0]
-        x = Binary('x', shape=n)
-        i = Element("i", n)
-        SumOperator(sum_index=i, operand=d[i]*x[i], condition=None)
-        # Σ_{i}(d[i]x[i])
-        ```
-    """
-
-
-INDEXWITHCOND = tp.Union[
-    _variable.Element, tp.Tuple[_variable.Element, _conditions.Condition]
-]
-
-
-@deprecated_name("Sum", "sum", kind="function")
-def Sum(
-    indices: tp.Union[INDEXWITHCOND, tp.List[INDEXWITHCOND]],
-    term: _expression.Expression,
-) -> SumOperator:
-    """
-    Sum function.
-
-    Args:
-        indices: summation index dict or list of index.
-        term (Expression): operand of summation
-
-    Returns:
-        SumOperator: SumOperator object.
-
-    Example:
-        Create $`\\sum_{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.Element('i', n)
-        jm.Sum(i, d[i]*x[i])
-        # Σ_{i}(d[i]x[i])
-        ```
-
-        Create $`\\sum_{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.Element('i', n)
-        j = jm.Element('j', n)
-        jm.Sum([i, j], d[i, j]*x[i]*x[j])
-        ```
-
-        Conditional sum
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', dim = 2)
-        n = d.shape[0]
-        i, j = jm.Element("i", n), jm.Element("j", n)
-        x = jm.Binary('x', shape=n)
-        jm.Sum([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
-
-    @typechecked
-    def convert_to_element(
-        index: tp.Union[
-            _variable.Element,
-            tp.Tuple[_variable.Element, tp.Optional[_conditions.Condition]],
-        ]
-    ) -> tp.Tuple[_variable.Element, tp.Optional[_conditions.Condition]]:
-        if isinstance(index, tuple):  # Tuple[ElementType, Optional[Condition]]
-            elem, cond = index
-            return (elem, cond)
-        else:  # ElementType
-            return (index, None)
-
-    elems_and_conds: tp.List[
-        tp.Tuple[_variable.Element, tp.Optional[_conditions.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
-    _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 = SumOperator(
-            sum_index=sum_index,
-            operand=sum_term,
-            condition=cond if cond is not None else _conditions.NoneCondition(),
-        )
-    return sum_term  # type: ignore
-
-
-def sum(
-    index: tp.Union[INDEXWITHCOND, tp.List[INDEXWITHCOND]],
-    operand: _expression.Expression,
-) -> SumOperator:
-    """
-    Sum function.
-
-    Args:
-        indices: summation index dict or list of index.
-        operand (Expression): operand of summation
-
-    Returns:
-        SumOperator: SumOperator object.
-
-    Example:
-        Create $`\\sum_{i=0}^n d_i x_i`$
-
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', ndim=1)
-        n = d.shape[0]
-        x = jm.BinaryVar('x', shape=n)
-        i = jm.Element('i', n)
-        jm.sum(i, d[i]*x[i])
-        # Σ_{i}(d[i]x[i])
-        ```
-
-        Create $`\\sum_{i}\\sum_j d_{ij}x_i x_j`$
-
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', ndim=2)
-        n = d.shape[0]
-        x = jm.BinaryVar('x', shape=n)
-        i = jm.Element('i', n)
-        j = jm.Element('j', n)
-        jm.sum([i, j], d[i, j]*x[i]*x[j])
-        ```
-
-        Conditional sum
-        ```python
-        import jijmodeling as jm
-        d = jm.Placeholder('d', ndim=2)
-        n = d.shape[0]
-        i, j = jm.Element("i", n), jm.Element("j", n)
-        x = jm.BinaryVar('x', shape=n)
-        jm.sum([i, (j, i < j)], d[i, j]*x[i]*x[j])
-        ```
-    """
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", category=JijFutureWarning)
-        return Sum(index, operand)

jijmodeling/expression/type_annotations.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-
-from jijmodeling.expression.expression import BinaryOperator, Expression, Number
-from jijmodeling.expression.mathfunc import UnaryOperator
-from jijmodeling.expression.variables.placeholders import ArrayShape, Placeholder
-from jijmodeling.expression.variables.variable import (
-    Element,
-    Range,
-    Subscripts,
-    Variable,
-)
-
-# Type of subscript element
-SubscriptElementType = (
-    Expression  # tp.TypeVar("SubscriptElementType", bound=Expression)
-)
-# User Input type for subscript element
-SubscriptElemInputType = tp.Union[slice, SubscriptElementType, int]
-
-# Type of shape element
-# tp.TypeVar("ShapeElementType", bound=Expression)
-ShapeElementType = Expression
-# User input type for shape element
-ShapeElemInputType = tp.Union[ShapeElementType, int, None]
-
-ElementParentType = tp.Union[Range, Variable, Subscripts]
-
-
-NumericInt = int
-ExprOrNum = tp.Union[Expression, int, float]
-
-IntExpr = tp.Union[Expression, int]
-
-
-ElementSetType = tp.Union[Range, Variable, Subscripts]
-
-
-Operator = tp.Union[BinaryOperator, UnaryOperator]
-
-StrictShapeElemType = tp.Union[
-    Number,
-    Placeholder,
-    Operator,
-    ArrayShape,
-]
-RangeBoundType = tp.TypeVar("RangeBoundType", bound=Expression)
-SumIndexType = tp.TypeVar("SumIndexType", bound=Element)
-OperandType = tp.TypeVar("OperandType", bound=Expression)