jijmodeling 1.13.1__cp38-abi3-manylinux_2_28_aarch64.whl → 1.13.3__cp38-abi3-manylinux_2_28_aarch64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of jijmodeling might be problematic. Click here for more details.
- jijmodeling/__init__.pyi +947 -2141
- jijmodeling/_jijmodeling.abi3.so +0 -0
- jijmodeling/dataset.pyi +41 -10
- jijmodeling/experimental.pyi +106 -157
- jijmodeling/range/__init__.pyi +0 -8
- jijmodeling/range/size.pyi +0 -8
- jijmodeling/range/value.pyi +0 -8
- {jijmodeling-1.13.1.dist-info → jijmodeling-1.13.3.dist-info}/METADATA +2 -1
- jijmodeling-1.13.3.dist-info/RECORD +18 -0
- {jijmodeling-1.13.1.dist-info → jijmodeling-1.13.3.dist-info}/WHEEL +1 -1
- jijmodeling-1.13.1.dist-info/RECORD +0 -18
- {jijmodeling-1.13.1.dist-info → jijmodeling-1.13.3.dist-info}/licenses/LICENSE.txt +0 -0
jijmodeling/_jijmodeling.abi3.so
CHANGED
|
Binary file
|
jijmodeling/dataset.pyi
CHANGED
|
@@ -3,6 +3,7 @@
|
|
|
3
3
|
|
|
4
4
|
import builtins
|
|
5
5
|
import typing
|
|
6
|
+
import typing_extensions
|
|
6
7
|
|
|
7
8
|
class Miplib:
|
|
8
9
|
r"""
|
|
@@ -44,15 +45,30 @@ class Miplib:
|
|
|
44
45
|
|
|
45
46
|
```
|
|
46
47
|
"""
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
def
|
|
48
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
49
|
+
@property
|
|
50
|
+
def available_names(self) -> builtins.list[builtins.str]:
|
|
51
|
+
r"""
|
|
52
|
+
List of available problem names.
|
|
53
|
+
"""
|
|
54
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
55
|
+
@property
|
|
56
|
+
def instance_statistics(self) -> typing.Any:
|
|
57
|
+
r"""
|
|
58
|
+
Dict of name to problem size, i.e. number of binary/integer/real variable and number of equality/inequality constraints
|
|
59
|
+
"""
|
|
60
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
61
|
+
def __new__(cls, verbose:builtins.bool=True) -> Miplib:
|
|
62
|
+
r"""
|
|
63
|
+
Setup MIPLIB dataset.
|
|
64
|
+
|
|
65
|
+
This downloads the MIPLIB dataset if not cached in your local filesystem.
|
|
66
|
+
"""
|
|
67
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
50
68
|
def load(self, name:str) -> tuple:
|
|
51
69
|
r"""
|
|
52
70
|
Load a problem from the MIPLIB dataset.
|
|
53
71
|
"""
|
|
54
|
-
...
|
|
55
|
-
|
|
56
72
|
|
|
57
73
|
class Qplib:
|
|
58
74
|
r"""
|
|
@@ -94,13 +110,28 @@ class Qplib:
|
|
|
94
110
|
|
|
95
111
|
```
|
|
96
112
|
"""
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
def
|
|
113
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
114
|
+
@property
|
|
115
|
+
def available_names(self) -> builtins.list[builtins.str]:
|
|
116
|
+
r"""
|
|
117
|
+
List of available problem names.
|
|
118
|
+
"""
|
|
119
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
120
|
+
@property
|
|
121
|
+
def instance_statistics(self) -> typing.Any:
|
|
122
|
+
r"""
|
|
123
|
+
Dict of name to problem size, i.e. number of binary/integer/real variable and number of equality/inequality constraints
|
|
124
|
+
"""
|
|
125
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
126
|
+
def __new__(cls, verbose:builtins.bool=True) -> Qplib:
|
|
127
|
+
r"""
|
|
128
|
+
Setup QPLIB dataset.
|
|
129
|
+
|
|
130
|
+
This downloads the QPLIB dataset if not cached in your local filesystem.
|
|
131
|
+
"""
|
|
132
|
+
@typing_extensions.deprecated("Dataset loading feature is deprecated and will be removed in JijModeling 2. Please use OMMX's corresponding feature instead.")
|
|
100
133
|
def load(self, name:str) -> tuple:
|
|
101
134
|
r"""
|
|
102
135
|
Load a problem from the QPLIB dataset.
|
|
103
136
|
"""
|
|
104
|
-
...
|
|
105
|
-
|
|
106
137
|
|
jijmodeling/experimental.pyi
CHANGED
|
@@ -5,46 +5,35 @@ import builtins
|
|
|
5
5
|
import numpy
|
|
6
6
|
import numpy.typing
|
|
7
7
|
import typing
|
|
8
|
-
from enum import Enum
|
|
8
|
+
from enum import Enum
|
|
9
9
|
|
|
10
10
|
class EvaluationResult:
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
def
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
def
|
|
19
|
-
|
|
20
|
-
|
|
11
|
+
@property
|
|
12
|
+
def objective(self) -> builtins.float: ...
|
|
13
|
+
@property
|
|
14
|
+
def constraints(self) -> builtins.dict[builtins.str, Violation]: ...
|
|
15
|
+
@property
|
|
16
|
+
def penalties(self) -> builtins.dict[builtins.str, Violation]: ...
|
|
17
|
+
def __new__(cls, objective:builtins.float=0.0, constraints:typing.Mapping[builtins.str, Violation]={}, penalties:typing.Mapping[builtins.str, Violation]={}) -> EvaluationResult: ...
|
|
18
|
+
def __str__(self) -> builtins.str: ...
|
|
19
|
+
def __repr__(self) -> builtins.str: ...
|
|
21
20
|
|
|
22
21
|
class MeasuringTime:
|
|
23
|
-
def __new__(cls,solving_time:typing.Optional[SolvingTime]=None, system_time:typing.Optional[SystemTime]=None): ...
|
|
24
|
-
def __str__(self) -> builtins.str:
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
def __repr__(self) -> builtins.str:
|
|
28
|
-
...
|
|
29
|
-
|
|
22
|
+
def __new__(cls, solving_time:typing.Optional[SolvingTime]=None, system_time:typing.Optional[SystemTime]=None) -> MeasuringTime: ...
|
|
23
|
+
def __str__(self) -> builtins.str: ...
|
|
24
|
+
def __repr__(self) -> builtins.str: ...
|
|
30
25
|
def total(self) -> builtins.float:
|
|
31
26
|
r"""
|
|
32
27
|
Returns the total time measurred, across both `SolvingTime` and `SystemTime`.
|
|
33
28
|
"""
|
|
34
|
-
...
|
|
35
|
-
|
|
36
29
|
def view_solving_time(self) -> SolvingTime:
|
|
37
30
|
r"""
|
|
38
31
|
Returns a readonly view of the internal `SolvingTime` field.
|
|
39
32
|
"""
|
|
40
|
-
...
|
|
41
|
-
|
|
42
33
|
def view_system_time(self) -> SystemTime:
|
|
43
34
|
r"""
|
|
44
35
|
Returns a readonly view of the internal `SystemTime` field.
|
|
45
36
|
"""
|
|
46
|
-
...
|
|
47
|
-
|
|
48
37
|
|
|
49
38
|
class Sample:
|
|
50
39
|
r"""
|
|
@@ -59,31 +48,24 @@ class Sample:
|
|
|
59
48
|
`run_id` is a unique identifier of the run in which this sample was found.
|
|
60
49
|
Note that this is not the same as a unique identifier of the Sample.
|
|
61
50
|
"""
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
def
|
|
51
|
+
@property
|
|
52
|
+
def run_id(self) -> builtins.str: ...
|
|
53
|
+
@property
|
|
54
|
+
def num_occurrences(self) -> builtins.int: ...
|
|
55
|
+
@property
|
|
56
|
+
def run_info(self) -> builtins.dict[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]: ...
|
|
57
|
+
@property
|
|
58
|
+
def var_values(self) -> builtins.dict[builtins.str, SparseVarValues]: ...
|
|
59
|
+
@property
|
|
60
|
+
def eval(self) -> EvaluationResult: ...
|
|
61
|
+
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) -> Sample: ...
|
|
68
62
|
@staticmethod
|
|
69
|
-
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:
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
def
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
def __repr__(self) -> builtins.str:
|
|
76
|
-
...
|
|
77
|
-
|
|
78
|
-
def __eq__(self, other:typing.Any) -> builtins.bool:
|
|
79
|
-
...
|
|
80
|
-
|
|
81
|
-
def is_feasible(self, epsilon:builtins.float=1e-08) -> builtins.bool:
|
|
82
|
-
...
|
|
83
|
-
|
|
84
|
-
def to_dense(self) -> builtins.dict[builtins.str, numpy.typing.NDArray[numpy.float64]]:
|
|
85
|
-
...
|
|
86
|
-
|
|
63
|
+
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: ...
|
|
64
|
+
def __str__(self) -> builtins.str: ...
|
|
65
|
+
def __repr__(self) -> builtins.str: ...
|
|
66
|
+
def __eq__(self, other:typing.Any) -> builtins.bool: ...
|
|
67
|
+
def is_feasible(self, epsilon:builtins.float=1e-08) -> builtins.bool: ...
|
|
68
|
+
def to_dense(self) -> builtins.dict[builtins.str, numpy.typing.NDArray[numpy.float64]]: ...
|
|
87
69
|
@staticmethod
|
|
88
70
|
def from_dict(dict:dict) -> Sample:
|
|
89
71
|
r"""
|
|
@@ -93,8 +75,6 @@ class Sample:
|
|
|
93
75
|
the `to_dict()` method. As such sparse value maps must be represented as
|
|
94
76
|
association lists.
|
|
95
77
|
"""
|
|
96
|
-
...
|
|
97
|
-
|
|
98
78
|
def to_dict(self) -> typing.Any:
|
|
99
79
|
r"""
|
|
100
80
|
Converts this SampleSet into a regular python dictionary.
|
|
@@ -104,43 +84,31 @@ class Sample:
|
|
|
104
84
|
with tuples as keys is transformed into an association list of key-value pairs,
|
|
105
85
|
that is, `[(k1, v1), (k2, v2), ...]`.
|
|
106
86
|
"""
|
|
107
|
-
...
|
|
108
|
-
|
|
109
87
|
|
|
110
88
|
class SampleIter:
|
|
111
|
-
def __iter__(self) -> SampleIter:
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
def __next__(self) -> Sample:
|
|
115
|
-
...
|
|
116
|
-
|
|
89
|
+
def __iter__(self) -> SampleIter: ...
|
|
90
|
+
def __next__(self) -> Sample: ...
|
|
117
91
|
|
|
118
92
|
class SampleSet:
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
def
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
def
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
def __len__(self) -> builtins.int:
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
def __getitem__(self, idx:builtins.int) -> Sample:
|
|
139
|
-
...
|
|
140
|
-
|
|
141
|
-
def __iter__(self) -> SampleIter:
|
|
142
|
-
...
|
|
143
|
-
|
|
93
|
+
@property
|
|
94
|
+
def data(self) -> builtins.list[Sample]: ...
|
|
95
|
+
@property
|
|
96
|
+
def set_id(self) -> builtins.str: ...
|
|
97
|
+
@property
|
|
98
|
+
def set_info(self) -> builtins.dict[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]: ...
|
|
99
|
+
@property
|
|
100
|
+
def run_info(self) -> builtins.dict[builtins.str, None | builtins.str | builtins.int | builtins.float | builtins.list | builtins.dict]: ...
|
|
101
|
+
@property
|
|
102
|
+
def measuring_time(self) -> MeasuringTime: ...
|
|
103
|
+
@property
|
|
104
|
+
def run_times(self) -> builtins.dict[builtins.str, MeasuringTime]: ...
|
|
105
|
+
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]={}) -> SampleSet: ...
|
|
106
|
+
def __str__(self) -> builtins.str: ...
|
|
107
|
+
def __repr__(self) -> builtins.str: ...
|
|
108
|
+
def __eq__(self, other:typing.Any) -> builtins.bool: ...
|
|
109
|
+
def __len__(self) -> builtins.int: ...
|
|
110
|
+
def __getitem__(self, idx:builtins.int) -> Sample: ...
|
|
111
|
+
def __iter__(self) -> SampleIter: ...
|
|
144
112
|
@staticmethod
|
|
145
113
|
def from_array(samples:typing.Sequence[typing.Mapping[builtins.str, numpy.typing.NDArray[numpy.float64] | list]]) -> SampleSet:
|
|
146
114
|
r"""
|
|
@@ -150,8 +118,6 @@ class SampleSet:
|
|
|
150
118
|
-----
|
|
151
119
|
- `samples`(`list[dict[str, list | numpy.ndarray]]`)
|
|
152
120
|
"""
|
|
153
|
-
...
|
|
154
|
-
|
|
155
121
|
@staticmethod
|
|
156
122
|
def concat(family:typing.Sequence[SampleSet]) -> SampleSet:
|
|
157
123
|
r"""
|
|
@@ -161,8 +127,6 @@ class SampleSet:
|
|
|
161
127
|
-----
|
|
162
128
|
- `family` (`list[SampleSet]`)
|
|
163
129
|
"""
|
|
164
|
-
...
|
|
165
|
-
|
|
166
130
|
@staticmethod
|
|
167
131
|
def from_dict(dict:dict) -> SampleSet:
|
|
168
132
|
r"""
|
|
@@ -172,8 +136,6 @@ class SampleSet:
|
|
|
172
136
|
the `to_dict()` method. As such sparse value maps must be represented as
|
|
173
137
|
association lists.
|
|
174
138
|
"""
|
|
175
|
-
...
|
|
176
|
-
|
|
177
139
|
def to_dict(self) -> typing.Any:
|
|
178
140
|
r"""
|
|
179
141
|
Converts this SampleSet into a regular python dictionary.
|
|
@@ -183,8 +145,6 @@ class SampleSet:
|
|
|
183
145
|
with tuples as keys is transformed into an association list of key-value pairs,
|
|
184
146
|
that is, `[(k1, v1), (k2, v2), ...]`.
|
|
185
147
|
"""
|
|
186
|
-
...
|
|
187
|
-
|
|
188
148
|
def feasibles(self, epsilon:builtins.float=1e-08) -> SampleSet:
|
|
189
149
|
r"""
|
|
190
150
|
Returns a SampleSet containing only the feasible samples.
|
|
@@ -197,8 +157,6 @@ class SampleSet:
|
|
|
197
157
|
--------
|
|
198
158
|
- `SampleSet`: a feasible subset of the current set.
|
|
199
159
|
"""
|
|
200
|
-
...
|
|
201
|
-
|
|
202
160
|
def separate(self) -> builtins.dict[builtins.str, SampleSet]:
|
|
203
161
|
r"""
|
|
204
162
|
Splits this `SampleSet` based on the `run_id` of the samples.
|
|
@@ -210,8 +168,6 @@ class SampleSet:
|
|
|
210
168
|
-----
|
|
211
169
|
- `sets` (dict[str, SampleSet]): The separated SampleSets. Keys are the run IDs.
|
|
212
170
|
"""
|
|
213
|
-
...
|
|
214
|
-
|
|
215
171
|
def lowest(self, epsilon:builtins.float=1e-08) -> builtins.list[Sample]:
|
|
216
172
|
r"""
|
|
217
173
|
Returns a list of the feasible samples which have the lowest objective value.
|
|
@@ -225,78 +181,71 @@ class SampleSet:
|
|
|
225
181
|
-----
|
|
226
182
|
`lowest_samples`: A list of Sample objects with the lowest ojective value in this SampleSet.
|
|
227
183
|
"""
|
|
228
|
-
...
|
|
229
|
-
|
|
230
184
|
|
|
231
185
|
class SolvingTime:
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
def
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
def
|
|
246
|
-
|
|
247
|
-
|
|
186
|
+
@property
|
|
187
|
+
def compiling_time(self) -> builtins.float: ...
|
|
188
|
+
@property
|
|
189
|
+
def transpiling_time(self) -> builtins.float: ...
|
|
190
|
+
@property
|
|
191
|
+
def preprocess_time(self) -> builtins.float: ...
|
|
192
|
+
@property
|
|
193
|
+
def solving_time(self) -> builtins.float: ...
|
|
194
|
+
@property
|
|
195
|
+
def decoding_time(self) -> builtins.float: ...
|
|
196
|
+
@property
|
|
197
|
+
def postprocess_time(self) -> builtins.float: ...
|
|
198
|
+
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) -> SolvingTime: ...
|
|
199
|
+
def __str__(self) -> builtins.str: ...
|
|
200
|
+
def __repr__(self) -> builtins.str: ...
|
|
201
|
+
def total(self) -> builtins.float: ...
|
|
248
202
|
|
|
249
203
|
class SparseVarValues:
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
def
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
def
|
|
259
|
-
|
|
260
|
-
|
|
204
|
+
@property
|
|
205
|
+
def name(self) -> builtins.str: ...
|
|
206
|
+
@property
|
|
207
|
+
def values(self) -> builtins.dict[typing.Tuple[int, ...], builtins.float]: ...
|
|
208
|
+
@property
|
|
209
|
+
def var_type(self) -> VarType: ...
|
|
210
|
+
@property
|
|
211
|
+
def shape(self) -> tuple: ...
|
|
212
|
+
def __new__(cls, name:builtins.str, values:typing.Mapping[typing.Tuple[int, ...], builtins.float], shape:typing.Sequence[builtins.int], var_type:VarType=VarType.CONTINUOUS) -> SparseVarValues: ...
|
|
213
|
+
def __str__(self) -> builtins.str: ...
|
|
214
|
+
def __repr__(self) -> builtins.str: ...
|
|
261
215
|
@staticmethod
|
|
262
|
-
def from_array(name:builtins.str, array:numpy.typing.NDArray[numpy.float64], var_type:VarType
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
def to_dense(self) -> numpy.typing.NDArray[numpy.float64]:
|
|
266
|
-
...
|
|
267
|
-
|
|
216
|
+
def from_array(name:builtins.str, array:numpy.typing.NDArray[numpy.float64], var_type:VarType=VarType.CONTINUOUS) -> SparseVarValues: ...
|
|
217
|
+
def to_dense(self) -> numpy.typing.NDArray[numpy.float64]: ...
|
|
268
218
|
|
|
269
219
|
class SystemTime:
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
def
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
def
|
|
280
|
-
|
|
281
|
-
|
|
220
|
+
@property
|
|
221
|
+
def posting_time(self) -> typing.Optional[builtins.float]: ...
|
|
222
|
+
@property
|
|
223
|
+
def request_queuing_time(self) -> typing.Optional[builtins.float]: ...
|
|
224
|
+
@property
|
|
225
|
+
def fetching_problem_time(self) -> typing.Optional[builtins.float]: ...
|
|
226
|
+
@property
|
|
227
|
+
def fetching_result_time(self) -> typing.Optional[builtins.float]: ...
|
|
228
|
+
@property
|
|
229
|
+
def deserialize_time(self) -> typing.Optional[builtins.float]: ...
|
|
230
|
+
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) -> SystemTime: ...
|
|
231
|
+
def __str__(self) -> builtins.str: ...
|
|
232
|
+
def __repr__(self) -> builtins.str: ...
|
|
282
233
|
|
|
283
234
|
class Violation:
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
def
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
def
|
|
292
|
-
|
|
293
|
-
|
|
235
|
+
@property
|
|
236
|
+
def name(self) -> builtins.str: ...
|
|
237
|
+
@property
|
|
238
|
+
def total_violation(self) -> builtins.float: ...
|
|
239
|
+
@property
|
|
240
|
+
def expr_values(self) -> builtins.dict[typing.Tuple[int, ...], builtins.float]: ...
|
|
241
|
+
def __new__(cls, name:builtins.str, total_violation:builtins.float, expr_values:typing.Mapping[typing.Tuple[int, ...], builtins.float]) -> Violation: ...
|
|
242
|
+
def __str__(self) -> builtins.str: ...
|
|
243
|
+
def __repr__(self) -> builtins.str: ...
|
|
294
244
|
|
|
295
245
|
class VarType(Enum):
|
|
296
|
-
CONTINUOUS =
|
|
297
|
-
INTEGER =
|
|
298
|
-
BINARY =
|
|
246
|
+
CONTINUOUS = ...
|
|
247
|
+
INTEGER = ...
|
|
248
|
+
BINARY = ...
|
|
299
249
|
|
|
300
|
-
def from_old_sampleset(sampleset:typing.Any) -> SampleSet:
|
|
301
|
-
...
|
|
250
|
+
def from_old_sampleset(sampleset:typing.Any) -> SampleSet: ...
|
|
302
251
|
|
jijmodeling/range/__init__.pyi
CHANGED
|
@@ -10,47 +10,39 @@ def at_least(bd:builtins.int | builtins.float) -> builtins.dict[builtins.str, bu
|
|
|
10
10
|
r"""
|
|
11
11
|
`at_least(lb)` returns a closed interval $[\mathtt{lb}, \infty)$; that is, $x \in \mathtt{at\_least(lb)} \iff x \geq \mathtt{lb}$.
|
|
12
12
|
"""
|
|
13
|
-
...
|
|
14
13
|
|
|
15
14
|
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']]:
|
|
16
15
|
r"""
|
|
17
16
|
`at_most(ub)` returns a closed interval $(-\infty, \mathtt{ub}]$; that is, $x \in \mathtt{at\_most(ub)} \iff x \leq \mathtt{ub}$.
|
|
18
17
|
"""
|
|
19
|
-
...
|
|
20
18
|
|
|
21
19
|
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']]:
|
|
22
20
|
r"""
|
|
23
21
|
`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}$
|
|
24
22
|
"""
|
|
25
|
-
...
|
|
26
23
|
|
|
27
24
|
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']]:
|
|
28
25
|
r"""
|
|
29
26
|
`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.
|
|
30
27
|
"""
|
|
31
|
-
...
|
|
32
28
|
|
|
33
29
|
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']]:
|
|
34
30
|
r"""
|
|
35
31
|
`greater_than(lb)` returns an open interval $(\mathtt{lb}, \infty)$; that is, $x \in \mathtt{greater\_than(lb)} \iff x > \mathtt{lb}$.
|
|
36
32
|
"""
|
|
37
|
-
...
|
|
38
33
|
|
|
39
34
|
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']]:
|
|
40
35
|
r"""
|
|
41
36
|
`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.
|
|
42
37
|
"""
|
|
43
|
-
...
|
|
44
38
|
|
|
45
39
|
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']]:
|
|
46
40
|
r"""
|
|
47
41
|
`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}$
|
|
48
42
|
"""
|
|
49
|
-
...
|
|
50
43
|
|
|
51
44
|
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']]:
|
|
52
45
|
r"""
|
|
53
46
|
`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}$.
|
|
54
47
|
"""
|
|
55
|
-
...
|
|
56
48
|
|
jijmodeling/range/size.pyi
CHANGED
|
@@ -8,47 +8,39 @@ def at_least(arg:builtins.int) -> builtins.dict[builtins.str, builtins.dict[buil
|
|
|
8
8
|
r"""
|
|
9
9
|
`at_least(lb)` returns a closed interval $[\mathtt{lb}, \infty)$; that is, $x \in \mathtt{at\_least(lb)} \iff x \geq \mathtt{lb}$.
|
|
10
10
|
"""
|
|
11
|
-
...
|
|
12
11
|
|
|
13
12
|
def at_most(bd:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
14
13
|
r"""
|
|
15
14
|
`at_most(ub)` returns a closed interval $(-\infty, \mathtt{ub}]$; that is, $x \in \mathtt{at\_most(ub)} \iff x \leq \mathtt{ub}$.
|
|
16
15
|
"""
|
|
17
|
-
...
|
|
18
16
|
|
|
19
17
|
def closed(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
20
18
|
r"""
|
|
21
19
|
`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}$
|
|
22
20
|
"""
|
|
23
|
-
...
|
|
24
21
|
|
|
25
22
|
def closed_open(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
26
23
|
r"""
|
|
27
24
|
`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.
|
|
28
25
|
"""
|
|
29
|
-
...
|
|
30
26
|
|
|
31
27
|
def greater_than(arg:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
32
28
|
r"""
|
|
33
29
|
`greater_than(lb)` returns an open interval $(\mathtt{lb}, \infty)$; that is, $x \in \mathtt{greater\_than(lb)} \iff x > \mathtt{lb}$.
|
|
34
30
|
"""
|
|
35
|
-
...
|
|
36
31
|
|
|
37
32
|
def less_than(bd:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
38
33
|
r"""
|
|
39
34
|
`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.
|
|
40
35
|
"""
|
|
41
|
-
...
|
|
42
36
|
|
|
43
37
|
def open(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
44
38
|
r"""
|
|
45
39
|
`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}$
|
|
46
40
|
"""
|
|
47
|
-
...
|
|
48
41
|
|
|
49
42
|
def open_closed(lb:builtins.int, ub:builtins.int) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.int] | typing.Literal['Unbounded']]:
|
|
50
43
|
r"""
|
|
51
44
|
`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}$.
|
|
52
45
|
"""
|
|
53
|
-
...
|
|
54
46
|
|
jijmodeling/range/value.pyi
CHANGED
|
@@ -8,47 +8,39 @@ def at_least(arg:builtins.float) -> builtins.dict[builtins.str, builtins.dict[bu
|
|
|
8
8
|
r"""
|
|
9
9
|
`at_least(lb)` returns a closed interval $[\mathtt{lb}, \infty)$; that is, $x \in \mathtt{at\_least(lb)} \iff x \geq \mathtt{lb}$.
|
|
10
10
|
"""
|
|
11
|
-
...
|
|
12
11
|
|
|
13
12
|
def at_most(bd:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
14
13
|
r"""
|
|
15
14
|
`at_most(ub)` returns a closed interval $(-\infty, \mathtt{ub}]$; that is, $x \in \mathtt{at\_most(ub)} \iff x \leq \mathtt{ub}$.
|
|
16
15
|
"""
|
|
17
|
-
...
|
|
18
16
|
|
|
19
17
|
def closed(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
20
18
|
r"""
|
|
21
19
|
`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}$
|
|
22
20
|
"""
|
|
23
|
-
...
|
|
24
21
|
|
|
25
22
|
def closed_open(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
26
23
|
r"""
|
|
27
24
|
`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.
|
|
28
25
|
"""
|
|
29
|
-
...
|
|
30
26
|
|
|
31
27
|
def greater_than(arg:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
32
28
|
r"""
|
|
33
29
|
`greater_than(lb)` returns an open interval $(\mathtt{lb}, \infty)$; that is, $x \in \mathtt{greater\_than(lb)} \iff x > \mathtt{lb}$.
|
|
34
30
|
"""
|
|
35
|
-
...
|
|
36
31
|
|
|
37
32
|
def less_than(bd:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
38
33
|
r"""
|
|
39
34
|
`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.
|
|
40
35
|
"""
|
|
41
|
-
...
|
|
42
36
|
|
|
43
37
|
def open(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
44
38
|
r"""
|
|
45
39
|
`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}$
|
|
46
40
|
"""
|
|
47
|
-
...
|
|
48
41
|
|
|
49
42
|
def open_closed(lb:builtins.float, ub:builtins.float) -> builtins.dict[builtins.str, builtins.dict[builtins.str, builtins.float] | typing.Literal['Unbounded']]:
|
|
50
43
|
r"""
|
|
51
44
|
`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}$.
|
|
52
45
|
"""
|
|
53
|
-
...
|
|
54
46
|
|
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
Metadata-Version: 2.4
|
|
2
2
|
Name: jijmodeling
|
|
3
|
-
Version: 1.13.
|
|
3
|
+
Version: 1.13.3
|
|
4
4
|
Classifier: Development Status :: 5 - Production/Stable
|
|
5
5
|
Classifier: Operating System :: POSIX :: Linux
|
|
6
6
|
Classifier: Operating System :: MacOS
|
|
@@ -21,6 +21,7 @@ Requires-Dist: numpy
|
|
|
21
21
|
Requires-Dist: pandas
|
|
22
22
|
Requires-Dist: orjson>=3.8.0,<4.0.0
|
|
23
23
|
Requires-Dist: ommx>=2.0.0,<3.0.0
|
|
24
|
+
Requires-Dist: typing-extensions
|
|
24
25
|
License-File: LICENSE.txt
|
|
25
26
|
Summary: Mathematical modeling tool for optimization problem
|
|
26
27
|
Author: Jij Inc.
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
jijmodeling-1.13.3.dist-info/METADATA,sha256=hELKMBppiHFXtHQUs9XpV6NaHGa2ziUOK5UgCjd_XLo,2511
|
|
2
|
+
jijmodeling-1.13.3.dist-info/WHEEL,sha256=Flq5NPP2j_RMfns2-YLcgMysMd1F4Y1bfmYWN9Ge8hw,107
|
|
3
|
+
jijmodeling-1.13.3.dist-info/licenses/LICENSE.txt,sha256=UDoDtHuEfRayMGh1HKVD3OR4lXFmXC4ifF2hQvwwj3w,3449
|
|
4
|
+
jijmodeling/__init__.py,sha256=43DV_WzDxS0n6FseNyfJZ6oQucO31T4qqbz3bx9JMtE,44
|
|
5
|
+
jijmodeling/__init__.pyi,sha256=XfykzhpFDhRMQ_E0YUhabcXpPmih_GoocYsomSna9nc,155852
|
|
6
|
+
jijmodeling/_jijmodeling.abi3.so,sha256=SHiuBOh51AXf8plUGsrN7KBRcKUYPOipZfwmQeZ1I9Y,8059456
|
|
7
|
+
jijmodeling/dataset.py,sha256=S4piVIiUGJMi8MlG3kFV-8JIkzvnktAS0IdkbJ655hw,185
|
|
8
|
+
jijmodeling/dataset.pyi,sha256=Ktyf4tYSS7hb5UdysFYs_Qv32tKbVNkCYVOL-ODtemY,6227
|
|
9
|
+
jijmodeling/experimental.py,sha256=Of-tUY3kfpFHpjGbIcclbMenCP2BMW07me895YH7tG8,575
|
|
10
|
+
jijmodeling/experimental.pyi,sha256=2p7SGwvBZrWKQe6N80o_ie0yKNyfaYwh4pqSKeOm2PA,11990
|
|
11
|
+
jijmodeling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
|
|
12
|
+
jijmodeling/range/__init__.py,sha256=4HqNNHBnK4H3EDl7nV7crz9EIEr85Uc3APnI6xvz4OQ,529
|
|
13
|
+
jijmodeling/range/__init__.pyi,sha256=9GvgBQIhVMkWWmCi95ookcMyDAPGEQk5PA09v6Luops,3847
|
|
14
|
+
jijmodeling/range/size.py,sha256=gBwFfLuO4GprRfjVWyCplEvFJri8cxPRtuEd5uXzo7Q,528
|
|
15
|
+
jijmodeling/range/size.pyi,sha256=yoKQNzsJG-TP1I5U4BXtl_nreD0yzH8_Qv6Sqrsatfo,2766
|
|
16
|
+
jijmodeling/range/value.py,sha256=aRwQGzpH5MZgpgKvd8gxMkMRyloq0S5zv87Kv3PHSd4,532
|
|
17
|
+
jijmodeling/range/value.pyi,sha256=n69FBubyMklpUEiFJEfFwvx8cbBxv-3x6YfO2oQ3c4I,2806
|
|
18
|
+
jijmodeling-1.13.3.dist-info/RECORD,,
|