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

jijmodeling/expression/serializable.py

@@ -1,132 +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
-
-from typeguard import typechecked
-
-import jijmodeling
-
-
-class Serializable(_abc.ABCMeta):
-    """
-    Meta class that can call `to_serializable()` and `from_serializable()`.
-
-    Args:
-        ABCMeta ([type]): [description]
-    """
-
-    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.getfullargspec(expression.__class__.__init__).args
-    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)."""
-    if isinstance(serializable, dict) and "object" in serializable:
-        obj = serializable["object"]
-    else:
-        raise ValueError("version mismatch")
-    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.getfullargspec(module.__init__).args
-        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,197 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-
-import typeguard as _typeguard
-
-from typeguard import typechecked
-
-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):
-    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", self._sum_index, _type_annotations.SumIndexType
-        )
-        _typeguard.check_type(
-            "self._operand", self._operand, _type_annotations.OperandType
-        )
-        _typeguard.check_type("self._condition", 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`$
-
-        >>> 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]
-]
-
-
-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`$
-
-        >>> 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`$
-
-        >>> 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
-        >>> 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
-
-    # element type from users
-    IndexType = tp.Union[
-        _variable.Element,
-        tp.Tuple[_variable.Element, tp.Optional[_conditions.Condition]],
-    ]
-
-    @typechecked
-    def convert_to_element(
-        index: IndexType,
-    ) -> 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

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)

jijmodeling/expression/utils.py

@@ -1,175 +0,0 @@
-from __future__ import annotations
-
-import typing as tp
-
-import typeguard as _typeguard
-
-import jijmodeling.exceptions.exceptions as _exceptions
-import jijmodeling.expression.condition as _condition
-import jijmodeling.expression.expression as _expression
-import jijmodeling.expression.extract as _extract
-import jijmodeling.expression.sum as _sum
-import jijmodeling.expression.variables.deci_vars as _deci_vars
-import jijmodeling.expression.variables.variable as _variable
-
-T = tp.TypeVar("T")
-
-
-def type_check_bool(value, cls) -> bool:
-    try:
-        _typeguard.check_type("a", value, cls)
-    except TypeError:
-        return False
-    else:
-        return True
-
-
-def extract_nodes(tree: _expression.Expression, cls: tp.Type[T]) -> tp.List[T]:
-    """
-    Extract specified class object from Expression tree.
-
-    Args:
-        tree (Expression): Target expression tree.
-        cls (Type): Target class.
-
-    Returns:
-        List: `cls` object list are included in `tree`.
-
-    Examples:
-        ```python
-        >>> import jijmodeling as jm
-        >>> d = jm.Placheolder("d", dim=1)
-        >>> n = d.shape[0]
-        >>> x = jm.Binary("x", shape=(n, ))
-        >>> i = jm.Element("i", n)
-        >>> term = jm.Sum(i, d[i]*x[i])
-        >>> jm.extract_nodes(term, jm.DecisionVariable)
-        [x]
-        ```
-    """
-    if type_check_bool(tree, cls):
-        nodes = [tree]
-    else:
-        nodes = []
-    for child in tree.children():
-        nodes = nodes + extract_nodes(child, cls)  # type: ignore
-    return nodes  # type: ignore
-
-
-def get_order(expression: _expression.Expression) -> int:
-    """
-    Get an order of polynomial.
-
-    For example, x_i * y_i + x_i -> 2 if x and y is a decision variable.
-
-    Args:
-        expression (Expression): expression
-
-    Returns:
-        int: Integer
-    """
-    if isinstance(expression, _deci_vars.DecisionVariable):
-        return 1
-    if isinstance(expression, _variable.Subscripts):
-        if isinstance(expression.variable, _deci_vars.DecisionVariable):
-            return 1
-        else:
-            return 0
-    if isinstance(expression, (_expression.Add, _expression.Div)):
-        child_order = [get_order(child) for child in expression.children()]
-        return max(child_order)
-    if isinstance(expression, _expression.Mul):
-        child_order = [get_order(child) for child in expression.children()]
-        return sum(child_order)
-    if isinstance(expression, _expression.Power):
-        base_order = get_order(expression.left)
-        if base_order > 0:
-            if isinstance(expression.right, _expression.Number):
-                return base_order * int(expression.right.value)
-            else:
-                raise _exceptions.ModelingError("exponent should be number.")
-    if isinstance(expression, _sum.SumOperator):
-        return get_order(expression.operand)
-    else:
-        return 0
-
-
-def expression_indices(
-    expression: _expression.Expression,
-) -> tp.List[_variable.Element]:
-    """
-    Extract all indices from the expression.
-
-    Args:
-        expression (Expression): expression
-
-    Returns:
-        List[Element]:
-    """
-    # TODO: implement expression_indices for each expression?
-    indices: tp.List[_variable.Element]
-    if isinstance(expression, _variable.Element):
-        set_indices: tp.List[_variable.Element] = []
-        for child in expression.children():
-            set_indices = set_indices + expression_indices(child)
-        indices = [expression] + set_indices
-    elif isinstance(expression, _expression.Number):
-        indices = []
-    elif isinstance(expression, _variable.Variable):
-        indices = []
-    elif isinstance(expression, _variable.Subscripts):
-        indices = []
-        for subs in expression.subscripts:
-            indices = indices + expression_indices(subs)
-    elif isinstance(expression, _expression.Expression):
-        indices = []
-        for child in expression.children():
-            if child is not None:
-                indices = indices + expression_indices(child)
-    else:
-        raise TypeError(f"expression is Expression, not {type(expression)}")
-
-    # check duplicated element
-    el_label = []
-    if isinstance(expression, _sum.ReductionOperator):
-        el_label = [expression.sum_index.label]
-
-    unique_indices: tp.List[_variable.Element] = []
-    for index in indices:
-        if index.label not in el_label:
-            el_label.append(index.label)
-            unique_indices.append(index)
-    return unique_indices
-
-
-def condition_indices(condition: _condition.Condition) -> tp.List[_variable.Element]:
-    if isinstance(condition, _condition.CompareCondition):
-        left_indices = expression_indices(condition.left)
-        right_indices = expression_indices(condition.right)
-        return left_indices + right_indices
-    elif isinstance(condition, _condition.ConditionOperator):
-        left_indices = condition_indices(condition.left)
-        right_indices = condition_indices(condition.right)
-        return left_indices + right_indices
-    else:
-        return []
-
-
-def check_non_decision_variable(
-    exp_list: tp.Iterable[_expression.Expression], error_msg: str
-):
-    """
-    Check if list has decision variable or not.
-
-    Args:
-        exp_list (Iterable[Expression]): target iterator.
-        error_msg (str): error message.
-
-    Raises:
-        CannotContainDecisionVarError: if list has decision variable.
-    """
-    for e in exp_list:
-        variables = _extract.extract_variables(e)
-        for v in variables:
-            if isinstance(v, _deci_vars.DecisionVariable):
-                raise _exceptions.CannotContainDecisionVarError(error_msg)

jijmodeling/expression/variables/__init__.py

@@ -1,35 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.expression.variables.deci_vars as deci_vars
-import jijmodeling.expression.variables.jagged_array as jagged_array
-import jijmodeling.expression.variables.placeholders as placeholders
-import jijmodeling.expression.variables.variable as variable
-
-from jijmodeling.expression.variables.deci_vars import (
-    Binary,
-    DecisionVariable,
-    Integer,
-    LogEncInteger,
-)
-from jijmodeling.expression.variables.jagged_array import JaggedArray
-from jijmodeling.expression.variables.placeholders import ArrayShape, Placeholder
-from jijmodeling.expression.variables.variable import Element, Subscripts, Variable
-
-__all__ = [
-    "deci_vars",
-    "jagged_array",
-    "placeholders",
-    "variable",
-    "Variable",
-    "Subscripts",
-    "Element",
-    "Placeholder",
-    "ArrayShape",
-    "JaggedArray",
-    "DecisionVariable",
-    "Binary",
-    "LogEncInteger",
-    "Integer",
-]