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

jijmodeling/protobuf/to_protobuf/placeholder_to_message.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.variables.placeholders import ArrayShape, Placeholder
-
-
-def placeholder_to_message(placeholder: Placeholder) -> pb.Expression:
-    """
-    Convert a `Placeholder` object to an `Expression` message.
-
-    Args:
-        placeholder (Placeholder): a `Placeholder` object
-
-    Returns:
-        pb.Expression: an `Expression` message
-    """
-    # Create an empty `Placeholder` message.
-    placeholder_message = pb.Placeholder()
-
-    # Set the symbol.
-    placeholder_message.symbol = placeholder.label
-
-    # Set the number of dimensions.
-    placeholder_message.dim = placeholder.dim
-
-    # Create an empty `Expression` message.
-    message = pb.Expression()
-
-    # Set the id that the `Placeholder` object has.
-    message.id = placeholder.uuid
-
-    # Set the shape
-    for shape in placeholder.shape:
-        # Case: number of elements is variadic.
-        if type(shape) is ArrayShape:
-            # Set the kind of the element of the shape.
-            placeholder_message.shape.append(pb.PlaceholderShapeElement.DYNAMIC)
-        # Case: number of elements is fixed.
-        else:
-            # Set the kind of the element of the shape.
-            placeholder_message.shape.append(pb.PlaceholderShapeElement.EXPRESSION)
-
-            # NOTE: Import a module within a local scope to fix a circular import.
-            # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-            # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-            from jijmodeling.protobuf.to_protobuf.expression_to_message import (
-                expression_to_message,
-            )
-
-            # Set the shape
-            message.children.append(expression_to_message(shape))
-
-    # Set the kind of nodes to a `Placeholder` message.
-    message.kind.placeholder = placeholder_message
-
-    # Serialize the `Expression` object into a bytes object.
-    return message

jijmodeling/protobuf/to_protobuf/problem_to_message.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from ulid import ULID
-
-from jijmodeling.problem.problem import Problem, ProblemSense
-from jijmodeling.protobuf.to_protobuf.constraint_to_message import constraint_to_message
-from jijmodeling.protobuf.to_protobuf.expression_to_message import expression_to_message
-from jijmodeling.protobuf.to_protobuf.penalty_to_message import penalty_to_message
-
-
-def problem_to_message(problem: Problem) -> pb.Problem:
-    """
-    Convert a `Problem` object into a `Problem` message.
-
-    Args:
-        problem (Problem): a `Problem` object
-
-    Returns:
-        pb.Problem: a `Problem` message
-    """
-    # Create an empty `Problem` message.
-    message = pb.Problem()
-
-    # Set the name of the problem.
-    message.name = problem.name
-
-    # Set the id of the problem.
-    message.id = str(ULID())
-
-    # Set sense of the problem.
-    if problem.sense == ProblemSense.MINIMUM:
-        message.sense = pb.ProblemSense.MIN
-    else:
-        message.sense = pb.ProblemSense.MAX
-
-    # Set the objective function.
-    message.objective = expression_to_message(problem.objective)
-
-    # Set the constraints.
-    message.constraints.extend(
-        [
-            constraint_to_message(constraint)
-            for constraint in problem.constraints.values()
-        ]
-    )
-
-    # Set the user-defined penalties.
-    message.penalties.extend(
-        [penalty_to_message(penalty) for penalty in problem.penalties.values()]
-    )
-
-    return message

jijmodeling/protobuf/to_protobuf/reduction_op_to_message.py

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.condition import NoneCondition
-from jijmodeling.expression.prod import ProdOperator
-from jijmodeling.expression.sum import ReductionOperator, SumOperator
-
-
-def reduction_op_to_message(reduction_op: ReductionOperator) -> pb.Expression:
-    """
-    Convert a `ReductionOperator` object to a `ReductionOp` message.
-
-    Args:
-        reduction_op (ReductionOperator): a `ReductionOperator` object.
-
-    Raises:
-        TypeError: the error occurs if the kind of the reduction operator is not supported
-
-    Returns:
-        pb.Expression: an `Expression` message.
-    """
-    # Create an empty `ReductionOp` message.
-    reduction_op_message = pb.ReductionOp()
-
-    # Set the kind of the `ReductionOp`.
-    if type(reduction_op) is SumOperator:
-        reduction_op_message.kind = pb.ReductionOpKind.SUM
-    elif type(reduction_op) is ProdOperator:
-        reduction_op_message.kind = pb.ReductionOpKind.PROD
-    else:
-        raise TypeError(f"{reduction_op.__class__.__name__} is not supported.")
-
-    # Create an empty `Expression` message.
-    message = pb.Expression()
-
-    # Set the id that the `Expression` object has.
-    message.id = reduction_op.uuid
-
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.to_protobuf.expression_to_message import (
-        expression_to_message,
-    )
-
-    # Set the index.
-    message.children.append(expression_to_message(reduction_op.sum_index))
-
-    # Set the operand.
-    message.children.append(expression_to_message(reduction_op.operand))
-
-    # Set the condition expression if the `ReductionOp` object has it.
-    if type(reduction_op.condition) is NoneCondition:
-        reduction_op_message.has_condition = False
-    else:
-        reduction_op_message.has_condition = True
-        # Set the condition expression
-        message.children.append(expression_to_message(reduction_op.condition))
-
-    # Set the kind of nodes to an `ReductionOp` message.
-    message.kind.reduction_op = reduction_op_message
-
-    return message

jijmodeling/protobuf/to_protobuf/subscript_op_to_message.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.variables.variable import Subscripts
-
-
-def subscript_op_to_message(subscript_op: Subscripts) -> pb.Expression:
-    """
-    Convert a `Subscripts` object to a `SubscriptOp` message.
-
-    Args:
-        subscript_op (Subscripts): a `Subscripts` object.
-
-    Returns:
-        pb.Expression: an `Expression` message.
-    """
-    # Create an empty `SubscriptOp` message.
-    subscript_op_message = pb.SubscriptOp()
-
-    # Set length of the subscripts.
-    subscript_op_message.num_subs = len(subscript_op.subscripts)
-
-    # Create an empty `Expression` message.
-    message = pb.Expression()
-
-    # Set the id that the `Expression` object has.
-    message.id = subscript_op.uuid
-
-    # Set the kind of nodes to an `BinaryOp` message.
-    message.kind.subscript_op = subscript_op_message
-
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.to_protobuf.expression_to_message import (
-        expression_to_message,
-    )
-
-    # Set the target array object.
-    message.children.append(expression_to_message(subscript_op.variable))
-
-    # Set the subscripts.
-    message.children.extend(
-        [expression_to_message(expr) for expr in subscript_op.subscripts]
-    )
-
-    return message

jijmodeling/protobuf/to_protobuf/to_protobuf.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-from jijmodeling.expression.condition import Condition
-from jijmodeling.expression.expression import Expression
-from jijmodeling.expression.variables.variable import Range
-from jijmodeling.problem.problem import Problem
-from jijmodeling.protobuf.to_protobuf.add_header_to_message import add_header_to_message
-from jijmodeling.protobuf.to_protobuf.expression_to_message import expression_to_message
-from jijmodeling.protobuf.to_protobuf.problem_to_message import problem_to_message
-
-
-def to_protobuf(object: Union[Expression, Range, Condition, Problem]) -> bytes:
-    """
-    Convert a JijModeling's object to a bytes object serialized by protobuf.
-
-    Args:
-        expr (Expression): a instance object of the `Expression` class
-
-    Raises:
-        TypeError: The error raises if the instance object cannot be converted to a protobuf object
-
-    Returns:
-        bytes: a bytes object
-    """
-    if isinstance(object, (Expression, Range, Condition)):
-        message = add_header_to_message(expression_to_message(object))
-        return bytes(message)
-    elif isinstance(object, Problem):
-        message = add_header_to_message(problem_to_message(object))
-        return bytes(message)
-    else:
-        raise TypeError(
-            f"{object.__class__.__name__} is not an {Expression.__name__} instance object."
-        )

jijmodeling/protobuf/to_protobuf/unary_op_to_message.py

@@ -1,58 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling_schema as pb
-
-from jijmodeling.expression.mathfunc import (
-    AbsoluteValue,
-    Ceil,
-    Floor,
-    Log2,
-    UnaryOperator,
-)
-
-
-def unary_op_to_message(unary_op: UnaryOperator) -> pb.Expression:
-    """
-    Convert a `UnaryOperator` object to an `Expression` message.
-
-    Args:
-        unary_op (UnaryOperator): a `UnaryOperator` object
-
-    Returns:
-        pb.Expression: an `Expression` message
-    """
-    # Create an empty `UnaryOp` message.
-    unary_op_message = pb.UnaryOp()
-
-    # Set the kind of the unary operator node.
-    if type(unary_op) is AbsoluteValue:
-        unary_op_message.kind = pb.UnaryOpKind.ABS
-    elif type(unary_op) is Ceil:
-        unary_op_message.kind = pb.UnaryOpKind.CEIL
-    elif type(unary_op) is Floor:
-        unary_op_message.kind = pb.UnaryOpKind.FLOOR
-    elif type(unary_op) is Log2:
-        unary_op_message.kind = pb.UnaryOpKind.LOG2
-    else:
-        raise TypeError(f"{unary_op.__class__.__name__} is not supported")
-
-    # Create an empty `Expression` message.
-    message = pb.Expression()
-
-    # Set the id that the `Expression` object has.
-    message.id = unary_op.uuid
-
-    # Set the kind of nodes to an `UnaryOp` message.
-    message.kind.unary_op = unary_op_message
-
-    # NOTE: Import a module within a local scope to fix a circular import.
-    # - https://stackoverflow.com/questions/59462679/design-of-python-conditional-imports
-    # - https://medium.com/@hamana.hadrien/so-you-got-a-circular-import-in-python-e9142fe10591
-    from jijmodeling.protobuf.to_protobuf.expression_to_message import (
-        expression_to_message,
-    )
-
-    # Set the operand of the `UnaryOperator` object.
-    message.children.append(expression_to_message(unary_op.operand))
-
-    return message

jijmodeling/sampleset/__init__.py

@@ -1,33 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.sampleset.evaluation as evaluation
-import jijmodeling.sampleset.measuring_time as measuring_time
-import jijmodeling.sampleset.record as record
-import jijmodeling.sampleset.sampleset as sampleset
-import jijmodeling.sampleset.solving_time as solving_time
-import jijmodeling.sampleset.system_time as system_time
-
-from jijmodeling.sampleset.evaluation import Evaluation
-from jijmodeling.sampleset.measuring_time import MeasuringTime
-from jijmodeling.sampleset.record import Record
-from jijmodeling.sampleset.sampleset import SampleSet, concatenate
-from jijmodeling.sampleset.solving_time import SolvingTime
-from jijmodeling.sampleset.system_time import SystemTime
-
-__all__ = [
-    "evaluation",
-    "measuring_time",
-    "record",
-    "sampleset",
-    "solving_time",
-    "system_time",
-    "SampleSet",
-    "Record",
-    "Evaluation",
-    "MeasuringTime",
-    "SolvingTime",
-    "SystemTime",
-    "concatenate",
-]

jijmodeling/sampleset/evaluation.py

@@ -1,288 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from jijmodeling.type_annotations import (
-    ForallIndexType,
-    ForallValuesType,
-    ConstraintExpressionValuesType,
-)
-from typing import Dict, List, Optional, Tuple, Union
-
-import numpy as np
-import pandas as pd
-
-
-@dataclass
-class Evaluation:
-    """Schema for results of evaluating solutions.
-
-    Attributes:
-        energy (List[float]): a list of values of energy.
-        objective (Optional[List[float]], optional): a list of values of objective function. Defaults to None.
-        constraint_violations (Optional[Dict[str, List[float]]], optional): a list of constraint violations. A key is the name of a constraint. A value is cost of a constraint. Defaults to None.
-        constraint_forall (Optional[ForallIndexType], optional): a list of indices of forall constraints. Defaults to None.
-        constraint_values (Optional[List[ForallValuesType]], optional): a list of values of forall constraints. Defaults to None.
-        penalty (Optional[Dict[str, List[float]]], optional): a list of costs of penalty terms. A key is the name of a penalty. A value is cost of a penalty term. Defaults to None.
-    """
-
-    energy: Optional[List[float]] = None
-    objective: Optional[List[float]] = None
-    constraint_violations: Optional[Dict[str, List[float]]] = None
-    constraint_forall: Optional[ForallIndexType] = field(default=None, repr=False)
-    constraint_values: Optional[List[ForallValuesType]] = field(
-        default=None, repr=False
-    )
-    penalty: Optional[Dict[str, List[float]]] = None
-
-    def __post_init__(self):
-        self._current_index = 0
-
-    def __len__(self) -> int:
-        """
-        Perform the operation __len__.
-        """
-        if self.energy is None:
-            return 0
-        else:
-            return len(self.energy)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        if self.energy is None:
-            raise StopIteration()
-        else:
-            if self._current_index == len(self.energy):
-                self._current_index = 0
-                raise StopIteration()
-            ret = self[self._current_index]
-            self._current_index += 1
-            return ret
-
-    def __getitem__(
-        self, item: Union[int, slice, List[int], Tuple[int], np.ndarray]
-    ) -> Evaluation:
-        """Perform the operation __getitem__.
-
-        Args:
-            item (Union[int, slice, List[int], Tuple[int], np.ndarray]): Index of evaluation metrics.
-
-        Returns:
-            Evaluation: Evaluation object.
-        """
-
-        def _slice(start: int, stop: int, step: Optional[int] = None) -> Evaluation:
-            energy = None if self.energy is None else self.energy[start:stop:step]
-            objective = (
-                None if self.objective is None else self.objective[start:stop:step]
-            )
-            constraint_violations = (
-                None
-                if self.constraint_violations is None
-                else {
-                    label: constraint_violations[start:stop:step]
-                    for label, constraint_violations in self.constraint_violations.items()
-                }
-            )
-            constraint_values = (
-                None
-                if self.constraint_values is None
-                else self.constraint_values[start:stop:step]
-            )
-            penalty = (
-                None
-                if self.penalty is None
-                else {
-                    label: penalty[start:stop:step]
-                    for label, penalty in self.penalty.items()
-                }
-            )
-
-            return Evaluation(
-                energy=energy,
-                objective=objective,
-                constraint_violations=constraint_violations,
-                constraint_forall=self.constraint_forall,
-                constraint_values=constraint_values,
-                penalty=penalty,
-            )
-
-        if isinstance(item, int):
-            start, stop, step = item, item + 1, None
-            return _slice(start, stop, step)
-        elif isinstance(item, slice):
-            start, stop, step = item.start, item.stop, item.step
-            return _slice(start, stop, step)
-        elif isinstance(item, (list, tuple, np.ndarray)):
-            item = np.array(item) if len(item) else np.array([], dtype=int)
-            if item.dtype == int or item.dtype == bool:
-                energy = (
-                    None
-                    if self.energy is None
-                    else np.array(self.energy)[item].tolist()
-                )
-                objective = (
-                    None
-                    if self.objective is None
-                    else np.array(self.objective)[item].tolist()
-                )
-                constraint_violations = (
-                    None
-                    if self.constraint_violations is None
-                    else {
-                        label: np.array(constraint_violations)[item].tolist()
-                        for label, constraint_violations in self.constraint_violations.items()
-                    }
-                )
-                constraint_values = (
-                    None
-                    if self.constraint_values is None
-                    else np.array(self.constraint_values)[item].tolist()
-                )
-                penalty = (
-                    None
-                    if self.penalty is None
-                    else {
-                        label: np.array(penalty)[item].tolist()
-                        for label, penalty in self.penalty.items()
-                    }
-                )
-                return Evaluation(
-                    energy=energy,
-                    objective=objective,
-                    constraint_violations=constraint_violations,
-                    constraint_forall=self.constraint_forall,
-                    constraint_values=constraint_values,
-                    penalty=penalty,
-                )
-            else:
-                raise IndexError(f'Element of "{item}" must be int or bool.')
-        else:
-            raise IndexError(
-                f'Type of index "{item}" must be int, slice, list[int], tuple[int, ...] or 1d numpy.ndarray.'
-            )
-
-    @property
-    def constraint_expr_values(self) -> List[ConstraintExpressionValuesType] | None:
-        """
-        Values for each constraint. The values are stored in `Dict[Tuple[int, ...], float]` for each condition expanded by `forall`.
-        """
-        if self.constraint_forall is None:
-            return None
-        if self.constraint_values is None:
-            return None
-
-        expr_values = []
-        for v in self.constraint_values:
-            expr_values.append(
-                {
-                    const_name: {
-                        tuple(i): vi
-                        for i, vi in zip(
-                            self.constraint_forall[const_name], v[const_name]
-                        )
-                    }
-                    for const_name in self.constraint_forall
-                }
-            )
-        return expr_values
-
-    def to_pandas_dataframe(self) -> pd.DataFrame:
-        """Convert Evaluation object to pandas.DataFrame object.
-
-        Returns:
-            pandas.DataFrame: pandas.DataFrame object.
-        """
-
-        evaluation = asdict(self)
-
-        if evaluation["constraint_violations"]:
-            constraint_violations = {
-                f"constraint_violation[{k}]": v
-                for k, v in evaluation.pop("constraint_violations").items()
-            }
-        else:
-            constraint_violations = {}
-            del evaluation["constraint_violations"]
-        evaluation.update(constraint_violations)
-        evaluation["constraint_forall"] = [self.constraint_forall] * len(self)
-
-        if self.penalty:
-            penalty = {f"penalty[{k}]": v for k, v in evaluation.pop("penalty").items()}
-        else:
-            penalty = {}
-            del evaluation["penalty"]
-        evaluation.update(penalty)
-
-        return pd.DataFrame(evaluation)
-
-    @classmethod
-    def from_serializable(cls, obj: dict):
-        """To Evaluation object from Dict of SampleSet.
-
-        Args:
-            obj (Dict): Dict of Evaluation.
-
-        Returns:
-            Evaluation: Evaluation obj.
-        """
-
-        return cls(
-            energy=obj.get("energy"),
-            objective=obj.get("objective"),
-            constraint_violations=obj.get("constraint_violations"),
-            constraint_forall=obj.get("constraint_forall"),
-            constraint_values=obj.get("constraint_values"),
-            penalty=obj.get("penalty"),
-        )
-
-    def to_serializable(self):
-        return asdict(self)
-
-    def _extend(self, other: Evaluation):
-        if isinstance(other.energy, list):
-            # Concatenate energy
-            if self.energy is None:
-                self.energy = other.energy
-            else:
-                self.energy.extend(other.energy)
-
-        # Concatenate objective
-        if isinstance(other.objective, list):
-            if self.objective is None:
-                self.objective = other.objective
-            else:
-                self.objective.extend(other.objective)
-
-        # Concatenate constraint_violations
-        if isinstance(other.constraint_violations, dict):
-            if self.constraint_violations is None:
-                self.constraint_violations = other.constraint_violations
-            else:
-                for (
-                    con_label,
-                    constraint_violation,
-                ) in other.constraint_violations.items():
-                    self.constraint_violations[con_label].extend(constraint_violation)
-
-        # Overwrite constraint_forall
-        # Since SampleSet assumes that it does not contain solutions for different problem or instance data,
-        # the index of forall constraints (constraint_forall) are the same between the original SampleSet(self)
-        # and combined SampleSet(other)."
-        if isinstance(other.constraint_forall, dict):
-            self.constraint_forall = other.constraint_forall
-
-        if isinstance(other.constraint_values, list):
-            if self.constraint_values is None:
-                self.constraint_values = other.constraint_values
-            else:
-                self.constraint_values.extend(other.constraint_values)
-
-        # Concatenate penalty
-        if isinstance(other.penalty, dict):
-            if self.penalty is None:
-                self.penalty = other.penalty
-            else:
-                for (pane_label, pena) in other.penalty.items():
-                    self.penalty[pane_label].extend(pena)