jijmodeling 1.8.1__cp310-none-win_amd64.whl → 1.10.0__cp310-none-win_amd64.whl

jijmodeling/__init__.pyi

@@ -4,7 +4,9 @@
 import numpy
 import numpy.typing
 import typing
+from . import dataset
 from . import experimental
+from . import range
 from enum import Enum, auto
 
 __version__: str
@@ -1676,6 +1678,7 @@ class Interpreter:
     ```
     """
     num_decision_variables: int
+    num_constraints: int
     def __new__(cls,instance_data:dict): ...
     def insert_instance_data(self, key:str, value:float | numpy.typing.NDArray[numpy.float64] | JaggedArray | typing.Sequence[float] | typing.Sequence[typing.Sequence[float]] | typing.Sequence[typing.Sequence[typing.Sequence[float]]] | typing.Sequence[typing.Sequence[typing.Sequence[typing.Sequence[float]]]]) -> None:
         ...
@@ -2793,12 +2796,18 @@ class Placeholder:
     -----------
     - `name` (`str`): A name of the placeholder.
     - `ndim` (`int`): The number of dimensions of the placeholder.
+    - `shape` (`list` of `Optional[Expression]`, optional): The (partial) shape of the placeholder if given.
+    - `dtype` (`DataType`, optional): The data type (`DataType.INT` or `DataType.FLOAT`) of the placeholder.
+    - `jagged` (`boolean`, defaut: `False`): `True` if the placeholder will be treated as a jagged array in random data generation. Ignored for scalars.
     - `description` (`str`, optional): A description of the placeholder.
     
     Args
     -----
     - `name` (`str`): A name of the placeholder.
-    - `ndim` (`int`): The number of dimensions of the placeholder. Defaults to `0`. The `ndim` must be set to a non-negative value.
+    - `ndim` (`Optional[int]`): The number of dimensions of the placeholder. Defaults to `0`. The `ndim` must be set to a non-negative value and must concide with the length of `shape` if both specified. If `None` is given, you must specify `shape` explicitly and the length of `shape` will be used.
+    - `shape` (`list[Optional[Expression]]`, optional): The (partial) shape of the placeholder. Used for random data generation.
+    - `dtype` (`DataType`, optional): The data type (`DataType.INT` or `DataType.FLOAT`) of the placeholder. Used for random data generation.
+    - `jagged` (`boolean`, defaut: `False`): `True` if the placeholder will be treated as a jagged array in random data generation. Ignored for scalars.
     - `latex` (`str`, optional): A LaTeX-name of the placeholder to be represented in Jupyter notebook.
       It is set to `name` by default.
     - `description` (`str`, optional): A description of the placeholder.
@@ -2838,9 +2847,11 @@ class Placeholder:
     """
     name: str
     ndim: int
+    dtype: typing.Optional[DataType]
+    jagged: bool
     description: typing.Optional[str]
     shape: tuple
-    def __new__(cls,name,*,ndim = ...,latex = ...,description = ...): ...
+    def __new__(cls,name,*,ndim = ...,shape = ...,dtype = ...,jagged = ...,latex = ...,description = ...): ...
     def len_at(self, axis,*,latex = ...,description = ...) -> ArrayLength:
         ...
 
@@ -3058,6 +3069,145 @@ class Problem:
         ...
 
     def get_problem_schema(self) -> dict:
+        r"""
+        Returns the schema of the problem.
+        
+        Returns
+        --------
+        - `schema`: The dictionary containing the schema of the problem.
+        """
+        ...
+
+    def generate_random_dataset(self, default = ...,options = ...,seed = ...) -> dict[str, float | numpy.typing.NDArray[numpy.float64] | JaggedArray]:
+        r"""
+        Generates a dictionary of random `InstanceDataValue` for a given problem.
+        To generate `ommx.v1.Instance` object directly, use `InstanceDataValue.generate_random_instance` instead.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" below).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        
+        Returns
+        --------
+        `dict`: The dictionary from the name of placeholders to the generated `InstanceDataValue` objects. To be fed to `Interpreter.eval_problem`.
+        
+        Range Parameters and Range Syntax
+        ----------------------------------
+        A range parameter is a dictionary consisting of the following fields:
+        - `size` (optional): interval of natural numbers for the size of each array dimension (default: `range(1, 6)`)
+        - `value` (optional): interval of real numbers for the value of each array element (default: `range(-1.0, 1.0)` - a uniform distribution on a closed interval $[-1.0, 1.0]$).
+        
+        Example range parameter config:
+        
+        ```python
+        {"size": range(2, 10), "value": jm.range.value.closed(100.0, 200.0)}
+        ```
+        
+        Intervals are expressed as a range object.
+        Currently, the following syntax is supported for range objects:
+        
+        1. Direct value of type `int` or `float` - it corresponds to a singleton interval $[a, a] = \{a\}$. In random generation context, this just means a constant fixed value.
+        2. Use the functions from `jijmodeling.range`, `jijmodeling.range.size`, or `jijmodeling.range.value` modules.
+           - Use functions from `jij.modeling.range.size` to specify (non-negative) integer intervals, and `jij.modeling.range.value` for real intervals. `jij.modeling.range` dynamically determines the type of the range based on the input.
+           - These three modules provides the following combinators (see the module documents for more details.):
+                    - `closed(a, b)`: a closed interval $[a, b]$
+                    - `open(a, b)`: an open interval $(a, b)$
+                    - `closed_open(a, b)`: an upper half-open interval $[a, b)$
+                    - `open_closed(a, b)`: a lower half-open interval $(a, b]$
+                    - `greater_than(a)`: an open interval $(a, \infty)$
+                    - `at_least(a)`: a closed interval $[a, \infty)$
+                    - `less_than(a)`: an open interval $(-\infty, a)$
+                    - `at_most(a)`: a closed interval $(-\infty, a]$
+        3. Use `range` builtin function: this is equivalent to `jijmodeling.range.value.closed_open(a, b)`.
+           - Any python range object with `step = 1` can be used as a size range; otherwise it results in runtime error.
+        4. Use a tuple: raw tuple `(a, b)` is equivalent to `jijmodeling.range.closed_open(a, b)` if `a` and `b` are either `int` or `float`.
+           - You can also use bound object as a tuple component; in such case, both tuple components must be one of the following:
+        
+                1. A string `"Unbounded"` means $-\infty$ (in the first component) or $\infty$ (the second).
+                2. A dictionary `{"Included": a}` means the endpoint is inclusive.
+                3. A dictionary `{"Excluded": a}` means the endpoint is exclusive.
+           - Examples:
+                    - `(1.2, 4)` is equivalent to `closed_open(1.2, 4)`,
+                    - `(-1, {"Included": 1})` is equivalent to `closed(-1, 1)`,
+                    - `(-5, {"Excluded": 4})` is equivalent to `closed_open(-5, 4)` and built in function `range(-5, 4)`,
+                    - `({"Excluded": 1}, {"Excluded": 2.5})` is equivalent to `open(1, 2.5)`,
+                    - `({"Included": -1}, "Unbounded")` is equivalent to `at_least(-1)`.
+                    - `(5, "Unbounded")` is **INVALID**; `5` must be bound object.
+        5. The range object: A dictionary of form `{"start": lb, "end": ub}`, where both `lb` and `ub` are the bound object described as above.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> inputs = problem.generate_random_dataset(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...          # You can also specify "size" for the range of jagged array dimension size.
+        ...     },
+        ...     seed=123 # omittable
+        ... )
+        >>> assert set(inputs.keys()) == {"N", "c"}
+        >>> inputs
+        {'N': 11.0, 'c': array([ 0.93914459, -0.06511935, -0.7460324 , -0.32443706,  0.99981451,
+               -0.24407535,  0.31329469,  0.52206453, -0.1291936 ,  0.30443087,
+                0.53125838])}
+        
+        ```
+        """
+        ...
+
+    def generate_random_instance(self, default = ...,options = ...,seed = ...) -> typing.Any:
+        r"""
+        Generates random `ommx.v1.Instance` for a given problem.
+        See also `InstanceDataValue.generate_random_dataset`.
+        
+        Args
+        -----
+        - `options` (optional): a dictionary of range parameters for each separate placeholders. The key must be the name of the placeholder and the value must be range parameter (as described in "Range Parameters and Range Syntax" section in :func:`~jijmodeling.Problem.generate_random_dataset`).
+        - `default` (optional): default range parameters for placeholders which is not specified in `options`.
+        - `seed` (optional): seed for random number generation.
+        
+        Returns
+        --------
+        `instance`: The OMMX v1 instance object.
+        
+        Examples
+        ---------
+        ```python
+        >>> import jijmodeling as jm
+        >>> import builtins
+        >>> import ommx.v1
+        >>> N = jm.Placeholder("N", dtype=jm.DataType.INTEGER)
+        >>> c = jm.Placeholder("c", dtype=jm.DataType.FLOAT, shape=(N,))
+        >>> x = jm.BinaryVar("x", shape=(N,))
+        >>> i = jm.Element("i", belong_to=N)
+        
+        >>> problem = jm.Problem("problem")
+        >>> problem += jm.sum(i, c[i] * x[i])
+        
+        >>> instance = problem.generate_random_instance(
+        ...     options={
+        ...         'N': {"value": builtins.range(10, 20)},
+        ...         'c': {"value": jm.range.value.closed(-1.0, 1.0)}
+        ...     },
+        ...     seed=123
+        ... )
+        >>> assert type(instance) is ommx.v1.Instance
+        
+        ```
+        """
         ...
 
 

jijmodeling/range/__init__.py

@@ -0,0 +1,14 @@
+# `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

@@ -0,0 +1,55 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import typing
+from . import size
+from . import value
+
+def at_least(bd:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float,ub:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float,ub:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float,ub:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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:int | float,ub:int | float) -> dict[str, dict[str, int] | typing.Literal['Unbounded']] | dict[str, dict[str, 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

@@ -0,0 +1,14 @@
+# `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

@@ -0,0 +1,53 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import typing
+
+def at_least(arg:int) -> dict[str, dict[str, 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:int) -> dict[str, dict[str, 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:int,ub:int) -> dict[str, dict[str, 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:int,ub:int) -> dict[str, dict[str, 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:int) -> dict[str, dict[str, 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:int) -> dict[str, dict[str, 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:int,ub:int) -> dict[str, dict[str, 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:int,ub:int) -> dict[str, dict[str, 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

@@ -0,0 +1,14 @@
+# `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

@@ -0,0 +1,53 @@
+# This file is automatically generated by pyo3_stub_gen
+# ruff: noqa: E501, F401
+
+import typing
+
+def at_least(arg:float) -> dict[str, dict[str, 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:float) -> dict[str, dict[str, 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:float,ub:float) -> dict[str, dict[str, 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:float,ub:float) -> dict[str, dict[str, 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:float) -> dict[str, dict[str, 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:float) -> dict[str, dict[str, 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:float,ub:float) -> dict[str, dict[str, 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:float,ub:float) -> dict[str, dict[str, 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.8.1.dist-info → jijmodeling-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: jijmodeling
-Version: 1.8.1
+Version: 1.10.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
@@ -18,9 +18,10 @@ Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: orjson >=3.8.0, <4.0.0
-Requires-Dist: ommx >=1.3.2, <2.0.0
+Requires-Dist: ommx >=1.5.1, <2.0.0
 Requires-Dist: pyright ; extra == 'test'
 Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: hypothesis ; extra == 'test'
 Requires-Dist: twine ; extra == 'test'
 Requires-Dist: pkginfo >=1.10.0 ; extra == 'test'
 Provides-Extra: test

jijmodeling-1.10.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+jijmodeling-1.10.0.dist-info/METADATA,sha256=PsOASI4WeW4WOpYimChiPlvmYC6-LhOZq8rKZOOt1us,13089
+jijmodeling-1.10.0.dist-info/WHEEL,sha256=dFcu9qOsa7YDFSHa8_VgUseX7dlAZ67iGT1C1h1z-T8,95
+jijmodeling-1.10.0.dist-info/licenses/LICENSE.txt,sha256=llUjgcEN5bUeFlj1RqxJxDMxUnlYvowLsldCF6Lwq8c,3445
+jijmodeling/dataset.py,sha256=L8yUjKp81m6_CoSfdPJMoJmlCQ_gf7n8okURTKRMXaw,190
+jijmodeling/dataset.pyi,sha256=CQKCr2hAJ2BX_zqI4tN9PUU_3zSkQ35lWIvsIVIBdwQ,4110
+jijmodeling/experimental.py,sha256=WWmxJzkyx_EYac1zmxflmFND191-xbVVXEdqot2VrM4,588
+jijmodeling/experimental.pyi,sha256=xEzVzawfe8a0xUNQ2ml6RK5CUbcuNGIoC-n-Nxd8P0E,9319
+jijmodeling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jijmodeling/range/size.py,sha256=F-cc3hLTAxUQo4umo6qFM5crGYdcWIEFLvWO963TyFY,542
+jijmodeling/range/size.pyi,sha256=3ov-8EUEY-qnRjjcqGbtP5PXRPqgREnjHTnCNiL9Xlg,2395
+jijmodeling/range/value.py,sha256=VCtUjzL4vfOo-yqSEmfLD1JZ98d73NYPuzohWDu5R2Q,546
+jijmodeling/range/value.pyi,sha256=1dm_bYaWuGyFw3Mo0FMwMtvd_2SjVUB69edxMo3A0Qg,2435
+jijmodeling/range/__init__.py,sha256=Dh-hTX2LMtTaM-Aps6Z4KfV28EoLI3vfkiRr4lQu13s,543
+jijmodeling/range/__init__.pyi,sha256=EOiepKqfYNuSJP9sdri0fx1airxxVySSCtMSjU4QcAU,3010
+jijmodeling/__init__.py,sha256=jJ6o5wp3MPAP1uR3dqSvjaXG57t1IwcS8ojqPpZL-gU,45
+jijmodeling/__init__.pyi,sha256=KFqeZV1ODzId-EHG6nQMgS1bPx3geNOax-3EzDnpc0Q,147834
+jijmodeling/_jijmodeling.cp310-win_amd64.pyd,sha256=TMANZMDVSpO_fbpJi9naVdfArkNvb_7e452_oHgzUlg,8097792
+jijmodeling-1.10.0.dist-info/RECORD,,

jijmodeling-1.8.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-jijmodeling-1.8.1.dist-info/METADATA,sha256=XcHhbilKB0X8eoZa650qV8KFdglmctYAOgDGm-g-SaQ,13044
-jijmodeling-1.8.1.dist-info/WHEEL,sha256=dFcu9qOsa7YDFSHa8_VgUseX7dlAZ67iGT1C1h1z-T8,95
-jijmodeling-1.8.1.dist-info/licenses/LICENSE.txt,sha256=llUjgcEN5bUeFlj1RqxJxDMxUnlYvowLsldCF6Lwq8c,3445
-jijmodeling/dataset.py,sha256=L8yUjKp81m6_CoSfdPJMoJmlCQ_gf7n8okURTKRMXaw,190
-jijmodeling/dataset.pyi,sha256=CQKCr2hAJ2BX_zqI4tN9PUU_3zSkQ35lWIvsIVIBdwQ,4110
-jijmodeling/experimental.py,sha256=WWmxJzkyx_EYac1zmxflmFND191-xbVVXEdqot2VrM4,588
-jijmodeling/experimental.pyi,sha256=xEzVzawfe8a0xUNQ2ml6RK5CUbcuNGIoC-n-Nxd8P0E,9319
-jijmodeling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jijmodeling/__init__.py,sha256=jJ6o5wp3MPAP1uR3dqSvjaXG57t1IwcS8ojqPpZL-gU,45
-jijmodeling/__init__.pyi,sha256=LXRHeFDzSMdcxAIonLhqySdi2AY0wjfV7vjA6g02hhg,139034
-jijmodeling/_jijmodeling.cp310-win_amd64.pyd,sha256=HaiQvu8fh1piDQzoDT4sMRKJY3sSLnp7Xpgci83b1FM,7895040
-jijmodeling-1.8.1.dist-info/RECORD,,