Skip to content

Commit 60f2186

Browse files
jorenhamjorenham
authored
✅ fix failing type-tests on numpy<2.1 (#789)
2 parents 7131c9b + 9c71a6f commit 60f2186

File tree

5 files changed

+147
-85
lines changed

5 files changed

+147
-85
lines changed

‎tests/differentiate/test_differentiate.pyi

Lines changed: 45 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,11 @@
1+
# ruff: noqa: ERA001
2+
13
from typing import assert_type
24

35
import numpy as np
46
import optype.numpy as onp
57

6-
from scipy import differentiate
8+
from scipy.differentiate import derivative, hessian, jacobian
79
from scipy.differentiate._differentiate import _DerivativeResult0D, _DerivativeResultND, _HessianResult, _JacobianResult
810

911
# Test scalar
@@ -24,19 +26,27 @@ def f_f64_1nd_0d(x: onp.Array[onp.AtLeast1D, np.float64]) -> np.float64: ...
2426
def f_f64_1nd_nd(x: onp.Array[onp.AtLeast1D, np.float64]) -> onp.ArrayND[np.float64]: ...
2527
def f_f64_0d_arg(x: np.float64, a: float) -> np.float64: ...
2628

29+
# NOTE: the commented out assertions only work on numpy 2.1+, so we instead check for assignability
30+
2731
###
2832
# derivative
2933

30-
assert_type(differentiate.derivative(f_f64_0d, 1.0), _DerivativeResult0D[np.float64])
31-
assert_type(differentiate.derivative(f_f64_0d, f64_0d), _DerivativeResult0D[np.float64])
32-
assert_type(differentiate.derivative(f_f64_0d, i32_0d), _DerivativeResult0D[np.float64])
33-
assert_type(differentiate.derivative(f_f32_0d, f32_0d), _DerivativeResult0D[np.float32])
34-
assert_type(differentiate.derivative(f_f64_1d, f64_1d), _DerivativeResultND[np.float64, tuple[int]])
35-
assert_type(differentiate.derivative(f_f64_nd, f64_2d), _DerivativeResultND[np.float64, tuple[int, int]])
36-
assert_type(differentiate.derivative(f_f64_0d_arg, 1.0, args=(2.0,)), _DerivativeResult0D[np.float64])
37-
assert_type(differentiate.derivative(f_f64_0d, 1.0, tolerances={"atol": 0.1}), _DerivativeResult0D[np.float64])
34+
assert_type(derivative(f_f64_0d, 1.0), _DerivativeResult0D[np.float64])
35+
assert_type(derivative(f_f64_0d, f64_0d), _DerivativeResult0D[np.float64])
36+
assert_type(derivative(f_f64_0d, i32_0d), _DerivativeResult0D[np.float64])
37+
assert_type(derivative(f_f32_0d, f32_0d), _DerivativeResult0D[np.float32])
38+
39+
# assert_type(derivative(f_f64_1d, f64_1d), _DerivativeResultND[np.float64, tuple[int]])
40+
# assert_type(derivative(f_f64_nd, f64_2d), _DerivativeResultND[np.float64, tuple[int, int]])
41+
# assert_type(derivative(f_f64_1d, f64_1d, <...>), _DerivativeResultND[np.float64, tuple[int]])
42+
_0: _DerivativeResultND[np.float64, tuple[int]] = derivative(f_f64_1d, f64_1d)
43+
_1: _DerivativeResultND[np.float64, tuple[int, int]] = derivative(f_f64_nd, f64_2d)
44+
_2: _DerivativeResultND[np.float64, tuple[int]] = derivative(f_f64_1d, f64_1d, initial_step=f64_1d, step_direction=i64_1d)
45+
46+
assert_type(derivative(f_f64_0d_arg, 1.0, args=(2.0,)), _DerivativeResult0D[np.float64])
47+
assert_type(derivative(f_f64_0d, 1.0, tolerances={"atol": 0.1}), _DerivativeResult0D[np.float64])
3848
assert_type(
39-
differentiate.derivative(
49+
derivative(
4050
f_f64_0d,
4151
1.0,
4252
args=(),
@@ -51,12 +61,8 @@ assert_type(
5161
),
5262
_DerivativeResult0D[np.float64],
5363
)
54-
assert_type(
55-
differentiate.derivative(f_f64_1d, f64_1d, initial_step=f64_1d, step_direction=i64_1d),
56-
_DerivativeResultND[np.float64, tuple[int]],
57-
)
5864

59-
res_der_0d = differentiate.derivative(f_f64_0d, 1.0)
65+
res_der_0d = derivative(f_f64_0d, 1.0)
6066
assert_type(res_der_0d.success, np.bool_)
6167
assert_type(res_der_0d.status, np.int32)
6268
assert_type(res_der_0d.nfev, np.int32)
@@ -65,32 +71,38 @@ assert_type(res_der_0d.x, np.float64)
6571
assert_type(res_der_0d.df, np.float64)
6672
assert_type(res_der_0d.error, np.float64)
6773

68-
res_der_nd = differentiate.derivative(f_f64_1d, f64_1d)
69-
assert_type(res_der_nd.success, onp.Array1D[np.bool_])
70-
assert_type(res_der_nd.status, onp.Array1D[np.int32])
71-
assert_type(res_der_nd.nfev, onp.Array1D[np.int32])
72-
assert_type(res_der_nd.nit, onp.Array1D[np.int32])
73-
assert_type(res_der_nd.x, onp.Array1D[np.float64])
74-
assert_type(res_der_nd.df, onp.Array1D[np.float64])
75-
assert_type(res_der_nd.error, onp.Array1D[np.float64])
74+
res_der_nd = derivative(f_f64_1d, f64_1d)
75+
# assert_type(res_der_nd.success, onp.Array1D[np.bool_])
76+
# assert_type(res_der_nd.status, onp.Array1D[np.int32])
77+
# assert_type(res_der_nd.nfev, onp.Array1D[np.int32])
78+
# assert_type(res_der_nd.nit, onp.Array1D[np.int32])
79+
# assert_type(res_der_nd.x, onp.Array1D[np.float64])
80+
# assert_type(res_der_nd.df, onp.Array1D[np.float64])
81+
# assert_type(res_der_nd.error, onp.Array1D[np.float64])
82+
_3: onp.Array1D[np.bool_] = res_der_nd.success
83+
_4: onp.Array1D[np.int32] = res_der_nd.status
84+
_5: onp.Array1D[np.int32] = res_der_nd.nfev
85+
_6: onp.Array1D[np.int32] = res_der_nd.nit
86+
_7: onp.Array1D[np.float64] = res_der_nd.x
87+
_8: onp.Array1D[np.float64] = res_der_nd.df
88+
_9: onp.Array1D[np.float64] = res_der_nd.error
7689

7790
###
7891
# jacobian
7992

80-
assert_type(differentiate.jacobian(f_f64_1nd_0d, f64_1d), _JacobianResult[np.float64, onp.AtLeast1D])
81-
assert_type(differentiate.jacobian(f_f64_1nd_nd, f64_1d), _JacobianResult[np.float64, onp.AtLeast1D])
93+
assert_type(jacobian(f_f64_1nd_0d, f64_1d), _JacobianResult[np.float64, onp.AtLeast1D])
94+
assert_type(jacobian(f_f64_1nd_nd, f64_1d), _JacobianResult[np.float64, onp.AtLeast1D])
8295
assert_type(
83-
differentiate.jacobian(
96+
jacobian(
8497
f_f64_1nd_0d, f64_1d, tolerances={"atol": 0.1}, maxiter=15, order=6, initial_step=0.1, step_factor=1.8, step_direction=0
8598
),
8699
_JacobianResult[np.float64, onp.AtLeast1D],
87100
)
88101
assert_type(
89-
differentiate.jacobian(f_f64_1nd_nd, f64_2d, initial_step=f64_1d, step_direction=i64_1d),
90-
_JacobianResult[np.float64, onp.AtLeast1D],
102+
jacobian(f_f64_1nd_nd, f64_2d, initial_step=f64_1d, step_direction=i64_1d), _JacobianResult[np.float64, onp.AtLeast1D]
91103
)
92104

93-
res_jac = differentiate.jacobian(f_f64_1nd_0d, f64_1d)
105+
res_jac = jacobian(f_f64_1nd_0d, f64_1d)
94106
assert_type(res_jac.status, onp.Array[onp.AtLeast1D, np.int32])
95107
assert_type(res_jac.df, onp.Array[onp.AtLeast1D, np.float64])
96108
assert_type(res_jac.error, onp.Array[onp.AtLeast1D, np.float64])
@@ -101,16 +113,14 @@ assert_type(res_jac.success, onp.Array[onp.AtLeast1D, np.bool_])
101113
###
102114
# hessian
103115

104-
assert_type(differentiate.hessian(f_f64_1nd_0d, f64_1d), _HessianResult[np.float64, onp.AtLeast2D])
116+
assert_type(hessian(f_f64_1nd_0d, f64_1d), _HessianResult[np.float64, onp.AtLeast2D])
105117
assert_type(
106-
differentiate.hessian(
107-
f_f64_1nd_0d, f64_1d, tolerances={"atol": 0.1}, maxiter=25, order=10, initial_step=0.05, step_factor=2.5
108-
),
118+
hessian(f_f64_1nd_0d, f64_1d, tolerances={"atol": 0.1}, maxiter=25, order=10, initial_step=0.05, step_factor=2.5),
109119
_HessianResult[np.float64, onp.AtLeast2D],
110120
)
111-
assert_type(differentiate.hessian(f_f64_1nd_0d, f64_2d, initial_step=f64_1d), _HessianResult[np.float64, onp.AtLeast2D])
121+
assert_type(hessian(f_f64_1nd_0d, f64_2d, initial_step=f64_1d), _HessianResult[np.float64, onp.AtLeast2D])
112122

113-
res_hes = differentiate.hessian(f_f64_1nd_0d, f64_1d)
123+
res_hes = hessian(f_f64_1nd_0d, f64_1d)
114124
assert_type(res_hes.status, onp.Array[onp.AtLeast2D, np.int32])
115125
assert_type(res_hes.error, onp.Array[onp.AtLeast2D, np.float64])
116126
assert_type(res_hes.nfev, onp.Array[onp.AtLeast2D, np.int32])

‎tests/fft/test_basic.pyi

Lines changed: 43 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
# ruff: noqa: ERA001
2+
13
from typing import assert_type
24

35
import numpy as np
@@ -29,10 +31,6 @@ f64_1d: onp.Array1D[np.float64]
2931
f64_2d: onp.Array2D[np.float64]
3032
f64_3d: onp.Array3D[np.float64]
3133

32-
f80_1d: onp.Array1D[np.float128]
33-
f80_2d: onp.Array2D[np.float128]
34-
f80_3d: onp.Array3D[np.float128]
35-
3634
c64_1d: onp.Array1D[np.complex64]
3735
c64_2d: onp.Array2D[np.complex64]
3836
c64_3d: onp.Array3D[np.complex64]
@@ -41,37 +39,56 @@ c128_1d: onp.Array1D[np.complex128]
4139
c128_2d: onp.Array2D[np.complex128]
4240
c128_3d: onp.Array3D[np.complex128]
4341

42+
# NOTE: These extended precision types may not exist at runtime, but are used
43+
# here to work around `[c]longdouble` issues on `numpy<2.2`
44+
45+
f80_1d: onp.Array1D[np.float128]
46+
f80_2d: onp.Array2D[np.float128]
47+
f80_3d: onp.Array3D[np.float128]
48+
4449
c160_1d: onp.Array1D[np.complex256]
4550
c160_2d: onp.Array2D[np.complex256]
4651
c160_3d: onp.Array3D[np.complex256]
4752

4853
###
4954
# fft
5055

56+
# NOTE: the commented out assertions only work on numpy 2.1+, so we instead check for assignability
57+
5158
assert_type(fft(int_1d), onp.Array1D[np.complex128])
52-
assert_type(fft(int_2d), onp.ArrayND[np.complex128])
5359
assert_type(fft(float_1d), onp.Array1D[np.complex128])
54-
assert_type(fft(float_2d), onp.ArrayND[np.complex128])
5560
assert_type(fft(complex_1d), onp.Array1D[np.complex128])
56-
assert_type(fft(complex_2d), onp.ArrayND[np.complex128])
57-
58-
assert_type(fft(i16_1d), onp.Array1D[np.complex128])
59-
assert_type(fft(i16_2d), onp.Array2D[np.complex128])
60-
61-
assert_type(fft(f32_1d), onp.Array1D[np.complex64])
62-
assert_type(fft(f32_2d), onp.Array2D[np.complex64])
63-
64-
assert_type(fft(f64_1d), onp.Array1D[np.complex128])
65-
assert_type(fft(f64_2d), onp.Array2D[np.complex128])
6661

67-
assert_type(fft(f80_1d), onp.Array1D[np.clongdouble])
68-
assert_type(fft(f80_2d), onp.Array2D[np.clongdouble])
69-
70-
assert_type(fft(c64_1d), onp.Array1D[np.complex64])
71-
assert_type(fft(c64_2d), onp.Array2D[np.complex64])
72-
73-
assert_type(fft(c128_1d), onp.Array1D[np.complex128])
74-
assert_type(fft(c128_2d), onp.Array2D[np.complex128])
62+
assert_type(fft(int_2d), onp.ArrayND[np.complex128])
63+
assert_type(fft(float_2d), onp.ArrayND[np.complex128])
64+
assert_type(fft(complex_2d), onp.ArrayND[np.complex128])
7565

76-
assert_type(fft(c160_1d), onp.Array1D[np.clongdouble])
77-
assert_type(fft(c160_2d), onp.Array2D[np.clongdouble])
66+
# assert_type(fft(i16_1d), onp.Array1D[np.complex128])
67+
# assert_type(fft(f32_1d), onp.Array1D[np.complex64])
68+
# assert_type(fft(f64_1d), onp.Array1D[np.complex128])
69+
# assert_type(fft(f80_1d), onp.Array1D[np.clongdouble])
70+
# assert_type(fft(c64_1d), onp.Array1D[np.complex64])
71+
# assert_type(fft(c128_1d), onp.Array1D[np.complex128])
72+
# assert_type(fft(c160_1d), onp.Array1D[np.clongdouble])
73+
_10: onp.Array1D[np.complex128] = fft(i16_1d)
74+
_11: onp.Array1D[np.complex64] = fft(f32_1d)
75+
_12: onp.Array1D[np.complex128] = fft(f64_1d)
76+
_13: onp.Array1D[np.clongdouble] = fft(f80_1d)
77+
_14: onp.Array1D[np.complex64] = fft(c64_1d)
78+
_15: onp.Array1D[np.complex128] = fft(c128_1d)
79+
_16: onp.Array1D[np.clongdouble] = fft(c160_1d)
80+
81+
# assert_type(fft(i16_2d), onp.Array2D[np.complex128])
82+
# assert_type(fft(f32_2d), onp.Array2D[np.complex64])
83+
# assert_type(fft(f64_2d), onp.Array2D[np.complex128])
84+
# assert_type(fft(f80_2d), onp.Array2D[np.clongdouble])
85+
# assert_type(fft(c64_2d), onp.Array2D[np.complex64])
86+
# assert_type(fft(c128_2d), onp.Array2D[np.complex128])
87+
# assert_type(fft(c160_2d), onp.Array2D[np.clongdouble])
88+
_20: onp.Array2D[np.complex128] = fft(i16_2d)
89+
_21: onp.Array2D[np.complex64] = fft(f32_2d)
90+
_22: onp.Array2D[np.complex128] = fft(f64_2d)
91+
_23: onp.Array2D[np.clongdouble] = fft(f80_2d)
92+
_24: onp.Array2D[np.complex64] = fft(c64_2d)
93+
_25: onp.Array2D[np.complex128] = fft(c128_2d)
94+
_26: onp.Array2D[np.clongdouble] = fft(c160_2d)

‎tests/linalg/test__basic.pyi

Lines changed: 39 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
# type-tests for `linalg/_basic.pyi`
2+
# ruff: noqa: ERA001
23

34
from typing import assert_type
45

@@ -337,36 +338,56 @@ assert_type(solve_circulant(py_c_2d, py_c_1d), onp.ArrayND[np.complex128])
337338
###
338339
# inv
339340

340-
assert_type(inv(f32_2d), onp.Array2D[np.float32])
341-
assert_type(inv(f64_2d), onp.Array2D[np.float64])
342-
assert_type(inv(c64_2d), onp.Array2D[np.complex64])
343-
assert_type(inv(c128_2d), onp.Array2D[np.complex128])
341+
# NOTE: the commented out assertions only work on numpy 2.1+, so we instead check for assignability
342+
343+
# assert_type(inv(f32_2d), onp.Array2D[np.float32])
344+
# assert_type(inv(f64_2d), onp.Array2D[np.float64])
345+
# assert_type(inv(c64_2d), onp.Array2D[np.complex64])
346+
# assert_type(inv(c128_2d), onp.Array2D[np.complex128])
347+
_00: onp.Array2D[np.float32] = inv(f32_2d)
348+
_01: onp.Array2D[np.float64] = inv(f64_2d)
349+
_02: onp.Array2D[np.complex64] = inv(c64_2d)
350+
_03: onp.Array2D[np.complex128] = inv(c128_2d)
344351

345352
assert_type(inv(py_b_2d), onp.Array2D[np.float32])
346353
assert_type(inv(py_i_2d), onp.Array2D[np.float64])
347354
assert_type(inv(py_f_2d), onp.Array2D[np.float64])
348355
assert_type(inv(py_c_2d), onp.Array2D[np.complex128])
349356

350-
assert_type(inv(f32_3d), onp.Array3D[np.float32])
351-
assert_type(inv(f64_3d), onp.Array3D[np.float64])
352-
assert_type(inv(c64_3d), onp.Array3D[np.complex64])
353-
assert_type(inv(c128_3d), onp.Array3D[np.complex128])
357+
# assert_type(inv(f32_3d), onp.Array3D[np.float32])
358+
# assert_type(inv(f64_3d), onp.Array3D[np.float64])
359+
# assert_type(inv(c64_3d), onp.Array3D[np.complex64])
360+
# assert_type(inv(c128_3d), onp.Array3D[np.complex128])
361+
_10: onp.Array3D[np.float32] = inv(f32_3d)
362+
_11: onp.Array3D[np.float64] = inv(f64_3d)
363+
_12: onp.Array3D[np.complex64] = inv(c64_3d)
364+
_13: onp.Array3D[np.complex128] = inv(c128_3d)
354365

355366
assert_type(inv(py_b_3d), onp.ArrayND[np.float32])
356367
assert_type(inv(py_i_3d), onp.ArrayND[np.float64])
357368
assert_type(inv(py_f_3d), onp.ArrayND[np.float64])
358369
assert_type(inv(py_c_3d), onp.ArrayND[np.complex128])
359370

360-
assert_type(inv(b1_nd), onp.ArrayND[np.float32])
361-
assert_type(inv(i8_nd), onp.ArrayND[np.float32])
362-
assert_type(inv(f16_nd), onp.ArrayND[np.float32])
363-
assert_type(inv(f32_nd), onp.ArrayND[np.float32])
364-
assert_type(inv(i32_nd), onp.ArrayND[np.float64])
365-
assert_type(inv(f64_nd), onp.ArrayND[np.float64])
366-
assert_type(inv(f80_nd), onp.ArrayND[np.float64])
367-
assert_type(inv(c64_nd), onp.ArrayND[np.complex64])
368-
assert_type(inv(c128_nd), onp.ArrayND[np.complex128])
369-
assert_type(inv(c160_nd), onp.ArrayND[np.complex128])
371+
# assert_type(inv(b1_nd), onp.ArrayND[np.float32])
372+
# assert_type(inv(i8_nd), onp.ArrayND[np.float32])
373+
# assert_type(inv(f16_nd), onp.ArrayND[np.float32])
374+
# assert_type(inv(f32_nd), onp.ArrayND[np.float32])
375+
# assert_type(inv(i32_nd), onp.ArrayND[np.float64])
376+
# assert_type(inv(f64_nd), onp.ArrayND[np.float64])
377+
# assert_type(inv(f80_nd), onp.ArrayND[np.float64])
378+
# assert_type(inv(c64_nd), onp.ArrayND[np.complex64])
379+
# assert_type(inv(c128_nd), onp.ArrayND[np.complex128])
380+
# assert_type(inv(c160_nd), onp.ArrayND[np.complex128])
381+
_20: onp.ArrayND[np.float32] = inv(b1_nd)
382+
_21: onp.ArrayND[np.float32] = inv(i8_nd)
383+
_22: onp.ArrayND[np.float32] = inv(f16_nd)
384+
_23: onp.ArrayND[np.float32] = inv(f32_nd)
385+
_24: onp.ArrayND[np.float64] = inv(i32_nd)
386+
_25: onp.ArrayND[np.float64] = inv(f64_nd)
387+
_26: onp.ArrayND[np.float64] = inv(f80_nd)
388+
_27: onp.ArrayND[np.complex64] = inv(c64_nd)
389+
_28: onp.ArrayND[np.complex128] = inv(c128_nd)
390+
_29: onp.ArrayND[np.complex128] = inv(c160_nd)
370391

371392
###
372393
# det

‎tests/optimize/test_constraints.pyi

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
# ruff: noqa: ERA001
2+
13
from typing import Any, assert_type
24

35
import numpy as np
@@ -24,8 +26,11 @@ assert_type(Bounds(0.0, 1.0), Bounds[tuple[int], np.float64])
2426
assert_type(Bounds(floats_1d, floats_1d), Bounds[tuple[int], np.float64])
2527
assert_type(Bounds(floats_2d, floats_2d), Bounds[tuple[Any, ...], np.float64])
2628

27-
assert_type(Bounds(f32_1d, f32_1d), Bounds[tuple[int], np.float32])
28-
assert_type(Bounds(f32_2d, f32_2d), Bounds[tuple[int, int], np.float32])
29+
# NOTE: these two assertions only pass on numpy 2.1+, so we instead check for assignability
30+
# assert_type(Bounds(f32_1d, f32_1d), Bounds[tuple[int], np.float32])
31+
# assert_type(Bounds(f32_2d, f32_2d), Bounds[tuple[int, int], np.float32])
32+
_0: Bounds[tuple[int], np.float32] = Bounds(f32_1d, f32_1d)
33+
_1: Bounds[tuple[int, int], np.float32] = Bounds(f32_2d, f32_2d)
2934

3035
###
3136
# LinearConstraint

‎tests/sparse/test_spbase.pyi

Lines changed: 13 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
# ruff: noqa: ERA001
2+
13
from typing import assert_type
24

35
import numpy as np
@@ -12,6 +14,8 @@ f64_2d: np.ndarray[tuple[int, int], np.dtype[np.float64]]
1214
shape_2d: tuple[int, int]
1315
dense_2d: np.ndarray[tuple[int, int], np.dtype[ScalarType]]
1416

17+
# NOTE: the commented out assertions only work on numpy 2.1+, so we instead check for assignability
18+
1519
###
1620
# utility functions
1721

@@ -41,11 +45,14 @@ assert_type(sparse.lil_matrix(shape_2d), sparse.lil_matrix[np.float64])
4145

4246
assert_type(sparse.coo_array((i64_1d, (i64_1d, i64_1d)), shape=shape_2d), sparse.coo_array[np.int64, tuple[int, int]])
4347
assert_type(sparse.bsr_array(f64_2d), sparse.bsr_array[np.float64])
44-
assert_type(sparse.coo_array(f64_2d), sparse.coo_array[np.float64, tuple[int, int]])
48+
# assert_type(sparse.coo_array(f64_2d), sparse.coo_array[np.float64, tuple[int, int]])
49+
_0: sparse.coo_array[np.float64, tuple[int, int]] = sparse.coo_array(f64_2d)
4550
assert_type(sparse.csc_array(f64_2d), sparse.csc_array[np.float64])
46-
assert_type(sparse.csr_array(f64_2d), sparse.csr_array[np.float64])
51+
# assert_type(sparse.csr_array(f64_2d), sparse.csr_array[np.float64])
52+
_1: sparse.csr_array[np.float64, tuple[int, int]] = sparse.csr_array(f64_2d)
4753
assert_type(sparse.dia_array(f64_2d), sparse.dia_array[np.float64])
48-
assert_type(sparse.dok_array(f64_2d), sparse.dok_array[np.float64])
54+
# assert_type(sparse.dok_array(f64_2d), sparse.dok_array[np.float64])
55+
_2: sparse.dok_array[np.float64, tuple[int, int]] = sparse.dok_array(f64_2d)
4956
assert_type(sparse.lil_array(f64_2d), sparse.lil_array[np.float64])
5057

5158
###
@@ -87,7 +94,9 @@ assert_type(csr_mat @ csr_mat, sparse.csr_matrix[ScalarType])
8794
assert_type(csr_mat / csr_mat, np.matrix[tuple[int, int], np.dtype[np.float64]])
8895

8996
# CSR array
90-
assert_type(sparse.csr_array(dense_2d), sparse.csr_array[ScalarType])
97+
# assert_type(sparse.csr_array(dense_2d), sparse.csr_array[ScalarType])
98+
_3: sparse.csr_array[ScalarType] = sparse.csr_array(dense_2d)
99+
91100
assert_type(-csr_arr, sparse.csr_array[ScalarType])
92101
assert_type(round(csr_arr), sparse.csr_array[ScalarType])
93102
assert_type(csr_arr + 0, sparse.csr_array[ScalarType])

0 commit comments

Comments
 (0)