jijmodeling 1.12.3__cp38-abi3-win_amd64.whl → 2.0.0b4__cp38-abi3-win_amd64.whl

jijmodeling/dataset.py

@@ -1,5 +0,0 @@
-from ._jijmodeling import dataset as _dataset  # type: ignore
-import sys
-
-for component in _dataset.__all__:
-    setattr(sys.modules[__name__], component, getattr(_dataset, component))

jijmodeling/dataset.pyi

@@ -1,106 +0,0 @@
-# This file is automatically generated by pyo3_stub_gen
-# ruff: noqa: E501, F401
-
-import builtins
-import typing
-
-class Miplib:
-    r"""
-    Automatically load problems from the MIPLIB dataset.
-    
-    Warning: the whole dataset is downloaded and cached in your filesystem when
-    first used. It is quite large (~300MB download, ~600MB extracted), so the
-    time it takes to download will likely be significant. We recommend first
-    trying to use this class in a REPL to assure the dataset has been cached.
-    
-    The dataset is stored at `{data_dir}/jijmodeling/miplib`, where
-    `{data_dir}` depends on your operating system:
-    
-    |Platform| {data_dir} location                    | Example/System Default                   |
-    |:-------|:---------------------------------------|:-----------------------------------------|
-    |Linux   |`$XDG_DATA_HOME` or `$HOME/.local/share`|`/home/alice/.local/share`                |
-    |macOS   |`$HOME/Library/Application Support`     |`/Users/Alice/Library/Application Support`|
-    |Windows |`%AppData%                              |`C:\Users\Alice\AppData\Roaming`          |
-    
-    
-    Examples
-    ---------
-    ```python
-    >>> import jijmodeling.dataset
-    
-    Initialize the dataset. If not cached in your filesystem, this will take several minutes.
-    >>> miplib = jijmodeling.dataset.Miplib()
-    
-    Show names of each available instance.
-    >>> miplib.available_names  # doctest: +ELLIPSIS
-    [...]
-    
-    Get basic statistics of a specific instance.
-    >>> miplib.instance_statistics["unitcal_7"]
-    {'variable': 25755, 'constraint': 48939, 'binary': 2856, 'integer': 0, 'continuous': 22899, 'non_zero': 127595}
-    
-    Load "revised-submissions/miplib2010_pg/instances/pg.mps.gz" in benchmark.zip
-    >>> problem, instance_data = miplib.load("pg")
-    
-    ```
-    """
-    available_names: builtins.list[builtins.str]
-    instance_statistics: typing.Any
-    def __new__(cls,verbose:builtins.bool=True): ...
-    def load(self, name:str) -> tuple:
-        r"""
-        Load a problem from the MIPLIB dataset.
-        """
-        ...
-
-
-class Qplib:
-    r"""
-    Automatically load problems from the MIPLIB dataset.
-    
-    Warning: the whole dataset is downloaded and cached in your filesystem when
-    first used. It is quite large (~700MB download, ~1.5GB extracted), so the
-    time it takes to download will likely be significant. We recommend first
-    trying to use this class in a REPL to assure the dataset has been cached.
-    
-    The dataset is stored at `{data_dir}/jijmodeling/qplib`, where
-    `{data_dir}` depends on your operating system:
-    
-    |Platform| {data_dir} location                    | Example/System Default                   |
-    |:-------|:---------------------------------------|:-----------------------------------------|
-    |Linux   |`$XDG_DATA_HOME` or `$HOME/.local/share`|`/home/alice/.local/share`                |
-    |macOS   |`$HOME/Library/Application Support`     |`/Users/Alice/Library/Application Support`|
-    |Windows |`%AppData%                              |`C:\Users\Alice\AppData\Roaming`          |
-    
-    
-    Examples
-    ---------
-    ```python
-    >>> import jijmodeling.dataset
-    
-    Initialize the dataset. If not cached in your filesystem, this will take several minutes.
-    >>> qplib = jijmodeling.dataset.Qplib()
-    
-    Show the names of each available instance.
-    >>> qplib.available_names  # doctest: +ELLIPSIS
-    [...]
-    
-    Get basic statistics of a specific instance.
-    >>> qplib.instance_statistics["QPLIB_2205"]
-    {'variables': 2884, 'constraints': 2874, 'binary': 958, 'integer': 0, 'continuous': 1926, 'non_zero': 13013}
-    
-    Load a problem instance from QPLIB.
-    >>> problem, instance_data = qplib.load("QPLIB_1976")
-    
-    ```
-    """
-    available_names: builtins.list[builtins.str]
-    instance_statistics: typing.Any
-    def __new__(cls,verbose:builtins.bool=True): ...
-    def load(self, name:str) -> tuple:
-        r"""
-        Load a problem from the QPLIB dataset.
-        """
-        ...
-
-

jijmodeling/experimental.py

@@ -1,13 +0,0 @@
-# `jijmodeling.jijmodeling` is a module corresponding to the shared library created by PyO3,
-# and `jijmodeling.jijmodeling.experimental` is its submodule defined dynamically
-# while the initialization of the shared library.
-#
-# This file defines a new sub-module `jijmodeling.experimental`,
-# and exposes all the components in `jijmodeling.jijmodeling.experimental`
-#
-
-from ._jijmodeling import experimental as _experimental  # type: ignore
-import sys
-
-for component in _experimental.__all__:
-    setattr(sys.modules[__name__], component, getattr(_experimental, component))

jijmodeling/experimental.pyi

@@ -1,302 +0,0 @@
-# This file is automatically generated by pyo3_stub_gen
-# ruff: noqa: E501, F401
-
-import builtins
-import numpy
-import numpy.typing
-import typing
-from enum import Enum, auto
-
-class EvaluationResult:
-    objective: builtins.float
-    constraints: builtins.dict[builtins.str, Violation]
-    penalties: builtins.dict[builtins.str, Violation]
-    def __new__(cls,objective:builtins.float=0.0, constraints:typing.Mapping[builtins.str, Violation]={}, penalties:typing.Mapping[builtins.str, Violation]={}): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-
-class MeasuringTime:
-    def __new__(cls,solving_time:typing.Optional[SolvingTime]=None, system_time:typing.Optional[SystemTime]=None): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-    def total(self) -> builtins.float:
-        r"""
-        Returns the total time measurred, across both `SolvingTime` and `SystemTime`.
-        """
-        ...
-
-    def view_solving_time(self) -> SolvingTime:
-        r"""
-        Returns a readonly view of the internal `SolvingTime` field.
-        """
-        ...
-
-    def view_system_time(self) -> SystemTime:
-        r"""
-        Returns a readonly view of the internal `SystemTime` field.
-        """
-        ...
-
-
-class Sample:
-    r"""
-    A Sample representing an individual solution found by running the mathematical optimization model.
-    
-    Variables in `var_values` are stored in instances of `SparseVarValues`. This uses a dictionary
-    style, retaining only non-zero elements. For example, if the values for a two-dimensional
-    decision variable are `x = [[0, 1, 2], [1, 0, 0]]`, they will be stored as
-    `{(0,1): 1, (0,2): 2, (1,0): 1}`. To retrieve this, use `sample.var_values["x"].values`.
-    If you want a dense array of decision variables, you can use the `to_dense()` method.
-    
-    `run_id` is a unique identifier of the run in which this sample was found.
-    Note that this is not the same as a unique identifier of the Sample.
-    """
-    run_id: builtins.str
-    num_occurrences: builtins.int
-    run_info: builtins.dict[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]
-    var_values: builtins.dict[builtins.str, SparseVarValues]
-    eval: EvaluationResult
-    def __new__(cls,num_occurrences:builtins.int=1, run_id:typing.Optional[builtins.str]=None, run_info:typing.Optional[typing.Mapping[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]]=None, var_values:typing.Optional[typing.Mapping[builtins.str, SparseVarValues]]=None, eval:typing.Optional[EvaluationResult]=None): ...
-    @staticmethod
-    def from_dense_arrays(dict:typing.Mapping[builtins.str, numpy.typing.NDArray[numpy.float64] | list], num_occurrences:builtins.int=1, var_types:typing.Optional[typing.Mapping[builtins.str, VarType]]=None, run_id:typing.Optional[builtins.str]=None, meta_info:typing.Optional[typing.Mapping[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]]=None) -> Sample:
-        ...
-
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-    def __eq__(self, other:typing.Any) -> builtins.bool:
-        ...
-
-    def is_feasible(self, epsilon:builtins.float=1e-08) -> builtins.bool:
-        ...
-
-    def to_dense(self) -> builtins.dict[builtins.str, numpy.typing.NDArray[numpy.float64]]:
-        ...
-
-    @staticmethod
-    def from_dict(dict:dict) -> Sample:
-        r"""
-        Converts a python dictionary into a SampleSet.
-        
-        This is intended to be used primarily with dictionaries generated by
-        the `to_dict()` method. As such sparse value maps must be represented as
-        association lists.
-        """
-        ...
-
-    def to_dict(self) -> typing.Any:
-        r"""
-        Converts this SampleSet into a regular python dictionary.
-        
-        Note that this dictionary has a slightly different structure to better support JSON
-        serialization of the output dictionary: sparse values are stored differently. Any mapping
-        with tuples as keys is transformed into an association list of key-value pairs,
-        that is, `[(k1, v1), (k2, v2), ...]`.
-        """
-        ...
-
-
-class SampleIter:
-    def __iter__(self) -> SampleIter:
-        ...
-
-    def __next__(self) -> Sample:
-        ...
-
-
-class SampleSet:
-    data: builtins.list[Sample]
-    set_id: builtins.str
-    set_info: builtins.dict[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]
-    run_info: builtins.dict[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]
-    measuring_time: MeasuringTime
-    run_times: builtins.dict[builtins.str, MeasuringTime]
-    def __new__(cls,data:typing.Sequence[Sample]=[], *, set_id:typing.Optional[builtins.str]=None, set_info:typing.Optional[typing.Mapping[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]]=None, run_info:typing.Optional[typing.Mapping[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]]=None, measuring_time:MeasuringTime=..., run_times:typing.Mapping[builtins.str, MeasuringTime]={}): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-    def __eq__(self, other:typing.Any) -> builtins.bool:
-        ...
-
-    def __len__(self) -> builtins.int:
-        ...
-
-    def __getitem__(self, idx:builtins.int) -> Sample:
-        ...
-
-    def __iter__(self) -> SampleIter:
-        ...
-
-    @staticmethod
-    def from_array(samples:typing.Sequence[typing.Mapping[builtins.str, numpy.typing.NDArray[numpy.float64] | list]]) -> SampleSet:
-        r"""
-        Builds a SampleSet from a list of dictionaries, where each entry is interpreted as a sample.
-        
-        Args
-        -----
-        - `samples`(`list[dict[str, list | numpy.ndarray]]`)
-        """
-        ...
-
-    @staticmethod
-    def concat(family:typing.Sequence[SampleSet]) -> SampleSet:
-        r"""
-        Creates a single SampleSet by concatenating a list of multiple SampleSets.
-        
-        Args
-        -----
-        - `family` (`list[SampleSet]`)
-        """
-        ...
-
-    @staticmethod
-    def from_dict(dict:dict) -> SampleSet:
-        r"""
-        Converts a python dictionary into a SampleSet.
-        
-        This is intended to be used primarily with dictionaries generated by
-        the `to_dict()` method. As such sparse value maps must be represented as
-        association lists.
-        """
-        ...
-
-    def to_dict(self) -> typing.Any:
-        r"""
-        Converts this SampleSet into a regular python dictionary.
-        
-        Note that this dictionary has a slightly different structure to better support JSON
-        serialization of the output dictionary: sparse values are stored differently. Any mapping
-        with tuples as keys is transformed into an association list of key-value pairs,
-        that is, `[(k1, v1), (k2, v2), ...]`.
-        """
-        ...
-
-    def feasibles(self, epsilon:builtins.float=1e-08) -> SampleSet:
-        r"""
-        Returns a SampleSet containing only the feasible samples.
-        
-        Args
-        -----
-        - `epsilon` (`float`, optional): Tolerance threshold for constraint violations. Defaults to $1e-8$.
-        
-        Returns
-        --------
-        - `SampleSet`: a feasible subset of the current set.
-        """
-        ...
-
-    def separate(self) -> builtins.dict[builtins.str, SampleSet]:
-        r"""
-        Splits this `SampleSet` based on the `run_id` of the samples.
-        
-        In other words, for each distinct `run_id` among the `Sample`s contained in this instance, a
-        new `SampleSet` is created to store all `Sample`s with that ID.
-        
-        Returns
-        -----
-        - `sets` (dict[str, SampleSet]): The separated SampleSets. Keys are the run IDs.
-        """
-        ...
-
-    def lowest(self, epsilon:builtins.float=1e-08) -> builtins.list[Sample]:
-        r"""
-        Returns a list of the feasible samples which have the lowest objective value.
-        If there are no feasible solutions, this returns an empty list.
-        
-        Args
-        -----
-        - `epsilon` (`float`, optional): Tolerance threshold. Objective values within this tolerance are included, even if not exactly the minimum value. Defaults to $1e-8$.
-        
-        Returns
-        -----
-        `lowest_samples`: A list of Sample objects with the lowest ojective value in this SampleSet.
-        """
-        ...
-
-
-class SolvingTime:
-    compiling_time: builtins.float
-    transpiling_time: builtins.float
-    preprocess_time: builtins.float
-    solving_time: builtins.float
-    decoding_time: builtins.float
-    postprocess_time: builtins.float
-    def __new__(cls,compiling_time:builtins.float=0.0, transpiling_time:builtins.float=0.0, preprocess_time:builtins.float=0.0, solving_time:builtins.float=0.0, decoding_time:builtins.float=0.0, postprocess_time:builtins.float=0.0): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-    def total(self) -> builtins.float:
-        ...
-
-
-class SparseVarValues:
-    name: builtins.str
-    values: builtins.dict[typing.Tuple[int, ...], builtins.float]
-    var_type: VarType
-    shape: tuple
-    def __new__(cls,name:builtins.str, values:typing.Mapping[typing.Tuple[int, ...], builtins.float], shape:typing.Sequence[builtins.int], var_type:VarType=...): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-    @staticmethod
-    def from_array(name:builtins.str, array:numpy.typing.NDArray[numpy.float64], var_type:VarType=...) -> SparseVarValues:
-        ...
-
-    def to_dense(self) -> numpy.typing.NDArray[numpy.float64]:
-        ...
-
-
-class SystemTime:
-    posting_time: typing.Optional[builtins.float]
-    request_queuing_time: typing.Optional[builtins.float]
-    fetching_problem_time: typing.Optional[builtins.float]
-    fetching_result_time: typing.Optional[builtins.float]
-    deserialize_time: typing.Optional[builtins.float]
-    def __new__(cls,posting_time:typing.Optional[builtins.float]=None, request_queuing_time:typing.Optional[builtins.float]=None, fetching_problem_time:typing.Optional[builtins.float]=None, fetching_result_time:typing.Optional[builtins.float]=None, deserialize_time:typing.Optional[builtins.float]=None): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-
-class Violation:
-    name: builtins.str
-    total_violation: builtins.float
-    expr_values: builtins.dict[typing.Tuple[int, ...], builtins.float]
-    def __new__(cls,name:builtins.str, total_violation:builtins.float, expr_values:typing.Mapping[typing.Tuple[int, ...], builtins.float]): ...
-    def __str__(self) -> builtins.str:
-        ...
-
-    def __repr__(self) -> builtins.str:
-        ...
-
-
-class VarType(Enum):
-    CONTINUOUS = auto()
-    INTEGER = auto()
-    BINARY = auto()
-
-def from_old_sampleset(sampleset:typing.Any) -> SampleSet:
-    ...
-

jijmodeling/range/__init__.py

@@ -1,14 +0,0 @@
-# `jijmodeling.jijmodeling` is a module corresponding to the shared library
-# created by PyO3,
-# and `jijmodeling.jijmodeling.range` is its submodule defined dynamically
-# while the initialization of the shared library.
-#
-# This file defines a new sub-module `jijmodeling.range`,
-# and exposes all the components in `jijmodeling.jijmodeling.range`
-#
-
-from .._jijmodeling import range as _range  # type: ignore
-import sys
-
-for component in _range.__all__:
-    setattr(sys.modules[__name__], component, getattr(_range, component))

jijmodeling/range/__init__.pyi

@@ -1,56 +0,0 @@
-# This file is automatically generated by pyo3_stub_gen
-# ruff: noqa: E501, F401
-
-import builtins
-import typing
-from . import size
-from . import value
-
-def at_least(bd:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `at_least(lb)` returns a closed interval $[\mathtt{lb}, \infty)$; that is, $x \in \mathtt{at\_least(lb)} \iff x \geq \mathtt{lb}$.
-    """
-    ...
-
-def at_most(bd:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `at_most(ub)` returns a closed interval $(-\infty, \mathtt{ub}]$; that is, $x \in \mathtt{at\_most(ub)} \iff x \leq \mathtt{ub}$.
-    """
-    ...
-
-def closed(lb:builtins.int | builtins.float, ub:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `closed(lb, ub)` returns a closed interval $[\mathtt{lb}, \mathtt{ub}]$; that is, $x \in \mathtt{closed(lb, ub)} \iff \mathtt{lb} \leq x \leq \mathtt{ub}$
-    """
-    ...
-
-def closed_open(lb:builtins.int | builtins.float, ub:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `closed_open(lb, ub)` returns a upper half-open interval $[\mathtt{lb}, \mathtt{ub})$; that is, $x \in \mathtt{closed\_open(lb, ub)} \iff \mathtt{lb} \leq x < \mathtt{ub}$. For size range, it is same as the python's standard `range(lb, ub)` function.
-    """
-    ...
-
-def greater_than(bd:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `greater_than(lb)` returns an open interval $(\mathtt{lb}, \infty)$; that is, $x \in \mathtt{greater\_than(lb)} \iff x > \mathtt{lb}$.
-    """
-    ...
-
-def less_than(bd:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `less_than(ub)` returns an open interval $(-\infty, \mathtt{ub})$; that is, $x \in \mathtt{less\_than(ub)} \iff x < \mathtt{ub}$. For size range, it is same as the python's standard `range(ub)` function.
-    """
-    ...
-
-def open(lb:builtins.int | builtins.float, ub:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `open(lb, ub)` returns an open interval $(\mathtt{lb}, \mathtt{ub})$; that is, $x \in \mathtt{open(lb, ub)} \iff \mathtt{lb} < x < \mathtt{ub}$
-    """
-    ...
-
-def open_closed(lb:builtins.int | builtins.float, ub:builtins.int | builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']] | builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `open_closed(lb, ub)` returns a lower half-open interval $(\mathtt{lb}, \mathtt{ub}]$; that is, $x \in \mathtt{open\_closed(lb, ub)} \iff \mathtt{lb} < x \leq \mathtt{ub}$.
-    """
-    ...
-

jijmodeling/range/size.py

@@ -1,14 +0,0 @@
-# `jijmodeling.jijmodeling` is a module corresponding to the shared library
-# created by PyO3,
-# and `jijmodeling.jijmodeling.range` is its submodule defined dynamically
-# while the initialization of the shared library.
-#
-# This file defines a new sub-module `jijmodeling.range`,
-# and exposes all the components in `jijmodeling.jijmodeling.range`
-#
-
-from . import size as _size  # type: ignore
-import sys
-
-for component in _size.__all__:  # type: ignore
-    setattr(sys.modules[__name__], component, getattr(_size, component))

jijmodeling/range/size.pyi

@@ -1,54 +0,0 @@
-# This file is automatically generated by pyo3_stub_gen
-# ruff: noqa: E501, F401
-
-import builtins
-import typing
-
-def at_least(arg:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `at_least(lb)` returns a closed interval $[\mathtt{lb}, \infty)$; that is, $x \in \mathtt{at\_least(lb)} \iff x \geq \mathtt{lb}$.
-    """
-    ...
-
-def at_most(bd:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `at_most(ub)` returns a closed interval $(-\infty, \mathtt{ub}]$; that is, $x \in \mathtt{at\_most(ub)} \iff x \leq \mathtt{ub}$.
-    """
-    ...
-
-def closed(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `closed(lb, ub)` returns a closed interval $[\mathtt{lb}, \mathtt{ub}]$; that is, $x \in \mathtt{closed(lb, ub)} \iff \mathtt{lb} \leq x \leq \mathtt{ub}$
-    """
-    ...
-
-def closed_open(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `closed_open(lb, ub)` returns a upper half-open interval $[\mathtt{lb}, \mathtt{ub})$; that is, $x \in \mathtt{closed\_open(lb, ub)} \iff \mathtt{lb} \leq x < \mathtt{ub}$. For size range, it is same as the python's standard `range(lb, ub)` function.
-    """
-    ...
-
-def greater_than(arg:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `greater_than(lb)` returns an open interval $(\mathtt{lb}, \infty)$; that is, $x \in \mathtt{greater\_than(lb)} \iff x > \mathtt{lb}$.
-    """
-    ...
-
-def less_than(bd:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `less_than(ub)` returns an open interval $(-\infty, \mathtt{ub})$; that is, $x \in \mathtt{less\_than(ub)} \iff x < \mathtt{ub}$. For size range, it is same as the python's standard `range(ub)` function.
-    """
-    ...
-
-def open(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `open(lb, ub)` returns an open interval $(\mathtt{lb}, \mathtt{ub})$; that is, $x \in \mathtt{open(lb, ub)} \iff \mathtt{lb} < x < \mathtt{ub}$
-    """
-    ...
-
-def open_closed(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
-    r"""
-    `open_closed(lb, ub)` returns a lower half-open interval $(\mathtt{lb}, \mathtt{ub}]$; that is, $x \in \mathtt{open\_closed(lb, ub)} \iff \mathtt{lb} < x \leq \mathtt{ub}$.
-    """
-    ...
-

jijmodeling/range/value.py

@@ -1,14 +0,0 @@
-# `jijmodeling.jijmodeling` is a module corresponding to the shared library
-# created by PyO3,
-# and `jijmodeling.jijmodeling.range` is its submodule defined dynamically
-# while the initialization of the shared library.
-#
-# This file defines a new sub-module `jijmodeling.range`,
-# and exposes all the components in `jijmodeling.jijmodeling.range`
-#
-
-from . import value as _value  # type: ignore
-import sys
-
-for component in _value.__all__:  # type: ignore
-    setattr(sys.modules[__name__], component, getattr(_value, component))

jijmodeling/range/value.pyi

@@ -1,54 +0,0 @@
-# This file is automatically generated by pyo3_stub_gen
-# ruff: noqa: E501, F401
-
-import builtins
-import typing
-
-def at_least(arg:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `at_least(lb)` returns a closed interval $[\mathtt{lb}, \infty)$; that is, $x \in \mathtt{at\_least(lb)} \iff x \geq \mathtt{lb}$.
-    """
-    ...
-
-def at_most(bd:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `at_most(ub)` returns a closed interval $(-\infty, \mathtt{ub}]$; that is, $x \in \mathtt{at\_most(ub)} \iff x \leq \mathtt{ub}$.
-    """
-    ...
-
-def closed(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `closed(lb, ub)` returns a closed interval $[\mathtt{lb}, \mathtt{ub}]$; that is, $x \in \mathtt{closed(lb, ub)} \iff \mathtt{lb} \leq x \leq \mathtt{ub}$
-    """
-    ...
-
-def closed_open(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `closed_open(lb, ub)` returns a upper half-open interval $[\mathtt{lb}, \mathtt{ub})$; that is, $x \in \mathtt{closed\_open(lb, ub)} \iff \mathtt{lb} \leq x < \mathtt{ub}$. For size range, it is same as the python's standard `range(lb, ub)` function.
-    """
-    ...
-
-def greater_than(arg:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `greater_than(lb)` returns an open interval $(\mathtt{lb}, \infty)$; that is, $x \in \mathtt{greater\_than(lb)} \iff x > \mathtt{lb}$.
-    """
-    ...
-
-def less_than(bd:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `less_than(ub)` returns an open interval $(-\infty, \mathtt{ub})$; that is, $x \in \mathtt{less\_than(ub)} \iff x < \mathtt{ub}$. For size range, it is same as the python's standard `range(ub)` function.
-    """
-    ...
-
-def open(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `open(lb, ub)` returns an open interval $(\mathtt{lb}, \mathtt{ub})$; that is, $x \in \mathtt{open(lb, ub)} \iff \mathtt{lb} < x < \mathtt{ub}$
-    """
-    ...
-
-def open_closed(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
-    r"""
-    `open_closed(lb, ub)` returns a lower half-open interval $(\mathtt{lb}, \mathtt{ub}]$; that is, $x \in \mathtt{open\_closed(lb, ub)} \iff \mathtt{lb} < x \leq \mathtt{ub}$.
-    """
-    ...
-

jijmodeling-1.12.3.dist-info/RECORD

@@ -1,18 +0,0 @@
-jijmodeling-1.12.3.dist-info/METADATA,sha256=05o9V0utDNpgl8ZlxNBsXj5MIzTzXRd-fbvv7kzjqF8,2494
-jijmodeling-1.12.3.dist-info/WHEEL,sha256=hKPP3BCTWtTwj6SFaSI--T5aOGqh_llYfbZ_BsqivwA,94
-jijmodeling-1.12.3.dist-info/licenses/LICENSE.txt,sha256=llUjgcEN5bUeFlj1RqxJxDMxUnlYvowLsldCF6Lwq8c,3445
-jijmodeling/dataset.py,sha256=L8yUjKp81m6_CoSfdPJMoJmlCQ_gf7n8okURTKRMXaw,190
-jijmodeling/dataset.pyi,sha256=lUu23EjUbmU6AKiQkWWkN_c0Yw_r_C-5FrD1ZzQZEm4,4189
-jijmodeling/experimental.py,sha256=WWmxJzkyx_EYac1zmxflmFND191-xbVVXEdqot2VrM4,588
-jijmodeling/experimental.pyi,sha256=Rrir0zWKwY-IN75Jm3Rx2aRYTOEkdM4wpzns2AewvYY,11577
-jijmodeling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jijmodeling/range/size.py,sha256=F-cc3hLTAxUQo4umo6qFM5crGYdcWIEFLvWO963TyFY,542
-jijmodeling/range/size.pyi,sha256=UBRz76PS9Wqo2TL0yMDx26XIa8AnfPt8dNWmyKmpYbg,2884
-jijmodeling/range/value.py,sha256=VCtUjzL4vfOo-yqSEmfLD1JZ98d73NYPuzohWDu5R2Q,546
-jijmodeling/range/value.pyi,sha256=TKdEWQz9DHttbW2WXVKeEYPzyZe9InF7ZQuLQrGsosc,2924
-jijmodeling/range/__init__.py,sha256=Dh-hTX2LMtTaM-Aps6Z4KfV28EoLI3vfkiRr4lQu13s,543
-jijmodeling/range/__init__.pyi,sha256=aZCIz2ZjSBDDo3rhhluu_mzpuIIJYbclqTEt5JYu-Vc,3967
-jijmodeling/__init__.py,sha256=jJ6o5wp3MPAP1uR3dqSvjaXG57t1IwcS8ojqPpZL-gU,45
-jijmodeling/__init__.pyi,sha256=QnIq71jPVWbhRAqBYNZ4a5xIXoarSODDst2Rc7RBV7A,160154
-jijmodeling/_jijmodeling.pyd,sha256=hHXhaVNdlEnZFuopVnzXkDF5AdKQLNDwFCivZtqL7g8,10842624
-jijmodeling-1.12.3.dist-info/RECORD,,