Skip to content

Commit ecc3125

Browse files
jorenhamjorenham
authored
Merge pull request #1556 from scipy/gh-1553 
2 parents 7452d18 + 07603f1 commit ecc3125

2 files changed

Lines changed: 104 additions & 65 deletions

File tree

‎scipy-stubs/signal/_ltisys.pyi‎

Lines changed: 53 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
1-
# mypy: disable-error-code="explicit-override"
21
import abc
32
import types
4-
from typing import Any, ClassVar, Final, Generic, Literal, Never, Self, TypeAlias, final, overload, type_check_only
3+
from typing import Any, ClassVar, Final, Generic, Literal, Self, TypeAlias, final, overload, type_check_only
54
from typing_extensions import TypeVar, override
65

76
import numpy as np
@@ -109,7 +108,7 @@ class LinearTimeInvariant(Generic[_ZerosT_co, _PolesT_co, _DTT_co]):
109108
def __class_getitem__(cls, args: object | tuple[object, ...], /) -> types.GenericAlias: ...
110109

111110
#
112-
def __new__(cls, *system: Never, **kwargs: Never) -> Self: ...
111+
def __new__(cls, /, *system: *tuple[()]) -> Self: ...
113112

114113
#
115114
@abc.abstractmethod
@@ -133,18 +132,18 @@ class LinearTimeInvariant(Generic[_ZerosT_co, _PolesT_co, _DTT_co]):
133132
class lti(LinearTimeInvariant[_ZerosT_co, _PolesT_co, None], Generic[_ZerosT_co, _PolesT_co], metaclass=abc.ABCMeta):
134133
@override
135134
@overload
136-
def __new__(cls, *system: *tuple[_ToFloat12D, onp.ToFloat1D]) -> TransferFunctionContinuous[_Float]: ... # pyrefly:ignore[bad-override]
135+
def __new__(cls, num: _ToFloat12D, den: onp.ToFloat1D, /) -> TransferFunctionContinuous[_Float]: ... # pyrefly:ignore[bad-override]
137136
@overload
138-
def __new__(cls, *system: *tuple[onp.ToFloat1D, onp.ToFloat1D, onp.ToFloat]) -> ZerosPolesGainContinuous[_Float]: ...
137+
def __new__(cls, zeros: onp.ToFloat1D, poles: onp.ToFloat1D, gain: onp.ToFloat, /) -> ZerosPolesGainContinuous[_Float]: ...
139138
@overload
140-
def __new__(cls, *system: *tuple[onp.ToComplex1D, onp.ToComplex1D, onp.ToFloat]) -> ZerosPolesGainContinuous: ...
139+
def __new__(cls, zeros: onp.ToComplex1D, poles: onp.ToComplex1D, gain: onp.ToFloat, /) -> ZerosPolesGainContinuous: ...
141140
@overload
142-
def __new__(cls, *system: *tuple[_ToFloat012D, _ToFloat012D, _ToFloat012D, _ToFloat012D]) -> StateSpaceContinuous[_Float]: ...
141+
def __new__(cls, A: _ToFloat012D, B: _ToFloat012D, C: _ToFloat012D, D: _ToFloat012D, /) -> StateSpaceContinuous[_Float]: ...
143142
@overload
144-
def __new__(cls, *system: *tuple[_ToComplex012D, _ToComplex012D, _ToComplex012D, _ToComplex012D]) -> StateSpaceContinuous: ...
143+
def __new__(cls, A: _ToComplex012D, B: _ToComplex012D, C: _ToComplex012D, D: _ToComplex012D, /) -> StateSpaceContinuous: ...
145144

146145
#
147-
def __init__(self, /, *system: Never) -> None: ...
146+
def __init__(self, /, *system: *tuple[()]) -> None: ...
148147

149148
#
150149
@overload
@@ -227,27 +226,27 @@ class dlti(LinearTimeInvariant[_ZerosT_co, _PolesT_co, _DTT_co], Generic[_ZerosT
227226
@override
228227
@overload
229228
def __new__( # pyrefly:ignore[bad-override]
230-
cls, *system: *tuple[_ToFloat12D, onp.ToFloat1D], dt: _DTT_co = ...
229+
cls, num: _ToFloat12D, den: onp.ToFloat1D, /, *, dt: _DTT_co = ...
231230
) -> TransferFunctionDiscrete[_Float, _DTT_co]: ...
232231
@overload
233232
def __new__(
234-
cls, *system: *tuple[onp.ToFloat1D, onp.ToFloat2D, onp.ToFloat1D], dt: _DTT_co = ...
233+
cls, zeros: onp.ToFloat1D, poles: onp.ToFloat2D, gain: onp.ToFloat1D, /, *, dt: _DTT_co = ...
235234
) -> ZerosPolesGainDiscrete[_Float, _Float, _DTT_co]: ...
236235
@overload
237236
def __new__(
238-
cls, *system: *tuple[onp.ToComplex1D, onp.ToComplex1D, onp.ToFloat], dt: _DTT_co = ...
237+
cls, zeros: onp.ToComplex1D, poles: onp.ToComplex1D, gain: onp.ToFloat1D, /, *, dt: _DTT_co = ...
239238
) -> ZerosPolesGainDiscrete[_Inexact, _Float, _DTT_co]: ...
240239
@overload
241240
def __new__(
242-
cls, *system: *tuple[_ToFloat012D, _ToFloat012D, _ToFloat012D, _ToFloat012D], dt: _DTT_co = ...
241+
cls, A: _ToFloat012D, B: _ToFloat012D, C: _ToFloat012D, D: _ToFloat012D, /, *, dt: _DTT_co = ...
243242
) -> StateSpaceDiscrete[_Float, _Float, _DTT_co]: ...
244243
@overload
245244
def __new__(
246-
cls, *system: *tuple[_ToComplex012D, _ToComplex012D, _ToComplex012D, _ToComplex012D], dt: _DTT_co = ...
245+
cls, A: _ToComplex012D, B: _ToComplex012D, C: _ToComplex012D, D: _ToComplex012D, /, *, dt: _DTT_co = ...
247246
) -> StateSpaceDiscrete[_Inexact, _Float, _DTT_co]: ...
248247

249248
#
250-
def __init__(self, /, *system: Never, dt: float, **kwargs: Never) -> None: ...
249+
def __init__(self, /, *system: *tuple[()], dt: _DTT_co) -> None: ...
251250

252251
#
253252
def output(
@@ -269,31 +268,31 @@ class dlti(LinearTimeInvariant[_ZerosT_co, _PolesT_co, _DTT_co], Generic[_ZerosT
269268
class TransferFunction(LinearTimeInvariant[_PolesT_co, _PolesT_co, _DTT_co], Generic[_PolesT_co, _DTT_co], metaclass=abc.ABCMeta):
270269
@override
271270
@overload
272-
def __new__(cls, *system: *tuple[lti[_PolesT, _PolesT]]) -> TransferFunctionContinuous[_PolesT]: ... # pyrefly:ignore[bad-override]
271+
def __new__(cls, system: lti[_PolesT, _PolesT], /) -> TransferFunctionContinuous[_PolesT]: ... # pyrefly:ignore[bad-override]
273272
@overload
274-
def __new__(cls, *system: *tuple[dlti[_PolesT, _PolesT, _DTT]]) -> TransferFunctionDiscrete[_PolesT, _DTT]: ...
273+
def __new__(cls, system: dlti[_PolesT, _PolesT, _DTT], /) -> TransferFunctionDiscrete[_PolesT, _DTT]: ...
275274
@overload
276-
def __new__(cls, *system: *tuple[_ToFloat12D, onp.ToFloat1D]) -> TransferFunctionContinuous[_Float]: ...
275+
def __new__(cls, num: _ToFloat12D, den: onp.ToFloat1D, /) -> TransferFunctionContinuous[_Float]: ...
277276
@overload
278-
def __new__(cls, *system: *tuple[_ToFloat12D, onp.ToFloat1D], dt: _DTT) -> TransferFunctionDiscrete[_Float, _DTT]: ...
277+
def __new__(cls, num: _ToFloat12D, den: onp.ToFloat1D, /, *, dt: _DTT) -> TransferFunctionDiscrete[_Float, _DTT]: ...
279278

280279
#
281280
@overload
282281
def __init__(self, system: LinearTimeInvariant[_PolesT_co, _PolesT_co, _DTT_co], /) -> None: ...
283282
@overload
284-
def __init__(self, numerator: _ToFloat12D, denominator: onp.ToFloat1D, /) -> None: ...
283+
def __init__(self, num: _ToFloat12D, den: onp.ToFloat1D, /, *, dt: _DTT_co = ...) -> None: ...
285284

286285
#
287286
@property
288287
def num(self, /) -> _Array12D[_PolesT_co]: ...
289288
@num.setter
290-
def num(self, /, num: _ToFloat12D) -> None: ...
289+
def num(self, num: _ToFloat12D, /) -> None: ...
291290

292291
#
293292
@property
294293
def den(self, /) -> onp.Array1D[_PolesT_co]: ...
295294
@den.setter
296-
def den(self, /, den: onp.ToFloat1D) -> None: ...
295+
def den(self, den: onp.ToFloat1D, /) -> None: ...
297296

298297
#
299298
@override
@@ -331,31 +330,33 @@ class TransferFunctionDiscrete(
331330
class ZerosPolesGain(LinearTimeInvariant[_ZerosT_co, _PolesT_co, _DTT_co], Generic[_ZerosT_co, _PolesT_co, _DTT_co]):
332331
@override
333332
@overload
334-
def __new__(cls, *system: *tuple[lti[_ZerosT_co, _PolesT_co]]) -> ZerosPolesGainContinuous[_ZerosT_co, _PolesT_co]: ... # pyrefly:ignore[bad-override]
333+
def __new__(cls, system: lti[_ZerosT_co, _PolesT_co], /) -> ZerosPolesGainContinuous[_ZerosT_co, _PolesT_co]: ... # pyrefly:ignore[bad-override]
335334
@overload
336335
def __new__(
337-
cls, *system: *tuple[dlti[_ZerosT_co, _PolesT_co, _DTT_co]]
336+
cls, system: dlti[_ZerosT_co, _PolesT_co, _DTT_co], /
338337
) -> ZerosPolesGainDiscrete[_ZerosT_co, _PolesT_co, _DTT_co]: ...
339338
@overload
340-
def __new__(cls, *system: *tuple[_ToFloat12D, onp.ToFloat1D, onp.ToFloat]) -> ZerosPolesGainContinuous[_Float, _Float]: ...
339+
def __new__(
340+
cls, zeros: _ToFloat12D, poles: onp.ToFloat1D, gain: onp.ToFloat, /
341+
) -> ZerosPolesGainContinuous[_Float, _Float]: ...
341342
@overload
342343
def __new__(
343-
cls, *system: *tuple[_ToComplex12D, onp.ToFloat1D, onp.ToFloat]
344+
cls, zeros: _ToComplex12D, poles: onp.ToFloat1D, gain: onp.ToFloat, /
344345
) -> ZerosPolesGainContinuous[_Inexact, _Float]: ...
345346
@overload
346347
def __new__(
347-
cls, *system: *tuple[_ToFloat12D, onp.ToFloat1D, onp.ToFloat], dt: _DTT
348+
cls, zeros: _ToFloat12D, poles: onp.ToFloat1D, gain: onp.ToFloat, /, *, dt: _DTT
348349
) -> ZerosPolesGainDiscrete[_Float, _Float, _DTT]: ...
349350
@overload
350351
def __new__(
351-
cls, *system: *tuple[_ToComplex12D, onp.ToFloat1D, onp.ToFloat], dt: _DTT
352+
cls, zeros: _ToComplex12D, poles: onp.ToFloat1D, gain: onp.ToFloat, /, *, dt: _DTT
352353
) -> ZerosPolesGainDiscrete[_Inexact, _Float, _DTT]: ...
353354

354355
#
355356
@overload
356357
def __init__(self, system: LinearTimeInvariant[_ZerosT_co, _PolesT_co, _DTT_co], /) -> None: ...
357358
@overload
358-
def __init__(self, zeros: _ToComplex12D, poles: onp.ToFloat1D, gain: onp.ToFloat, /) -> None: ...
359+
def __init__(self, zeros: _ToComplex12D, poles: onp.ToFloat1D, gain: onp.ToFloat, /, *, dt: _DTT_co = ...) -> None: ...
359360

360361
#
361362
@property
@@ -439,38 +440,50 @@ class StateSpace(LinearTimeInvariant[_ZerosT_co, _PolesT_co, _DTT_co], Generic[_
439440

440441
@override
441442
@overload
442-
def __new__(cls, *system: *tuple[lti[_ZerosT_co, _PolesT_co]]) -> StateSpaceContinuous[_ZerosT_co, _PolesT_co]: ... # pyrefly:ignore[bad-override]
443+
def __new__(cls, system: lti[_ZerosT_co, _PolesT_co], /) -> StateSpaceContinuous[_ZerosT_co, _PolesT_co]: ... # pyrefly:ignore[bad-override]
443444
@overload
444-
def __new__(
445-
cls, *system: *tuple[dlti[_ZerosT_co, _PolesT_co, _DTT_co]]
446-
) -> StateSpaceDiscrete[_ZerosT_co, _PolesT_co, _DTT_co]: ...
445+
def __new__(cls, system: dlti[_ZerosT_co, _PolesT_co, _DTT_co], /) -> StateSpaceDiscrete[_ZerosT_co, _PolesT_co, _DTT_co]: ...
447446
@overload
448447
def __new__(
449-
cls, *system: *tuple[_ToFloat012D, _ToFloat012D, _ToFloat012D, _ToFloat012D]
448+
cls, A: _ToFloat012D, B: _ToFloat012D, C: _ToFloat012D, D: _ToFloat012D, /
450449
) -> StateSpaceContinuous[_Float, _Float]: ...
451450
@overload
452451
def __new__(
453-
cls, *system: *tuple[_ToComplex012D, _ToComplex012D, _ToComplex012D, _ToComplex012D]
452+
cls, A: _ToComplex012D, B: _ToComplex012D, C: _ToComplex012D, D: _ToComplex012D, /
454453
) -> StateSpaceContinuous[_Inexact, _Float]: ...
455454
@overload
456455
def __new__(
457-
cls, *system: *tuple[_ToFloat012D, _ToFloat012D, _ToFloat012D, _ToFloat012D], dt: _DTT
456+
cls, A: _ToFloat012D, B: _ToFloat012D, C: _ToFloat012D, D: _ToFloat012D, /, *, dt: _DTT
458457
) -> StateSpaceDiscrete[_Float, _Float, _DTT]: ...
459458
@overload
460459
def __new__(
461-
cls, *system: *tuple[_ToComplex012D, _ToComplex012D, _ToComplex012D, _ToComplex012D], dt: _DTT
460+
cls, A: _ToComplex012D, B: _ToComplex012D, C: _ToComplex012D, D: _ToComplex012D, /, *, dt: _DTT
462461
) -> StateSpaceDiscrete[_Inexact, _Float, _DTT]: ...
463462

464463
#
465464
@overload
466465
def __init__(self, system: StateSpace[_ZerosT_co, _PolesT_co, _DTT_co], /) -> None: ...
467466
@overload
468467
def __init__(
469-
self: StateSpace[_Float, _Float], A: _ToFloat012D, B: _ToFloat012D, C: _ToFloat012D, D: _ToFloat012D, /
468+
self: StateSpace[_Float, _Float],
469+
A: _ToFloat012D,
470+
B: _ToFloat012D,
471+
C: _ToFloat012D,
472+
D: _ToFloat012D,
473+
/,
474+
*,
475+
dt: _DTT_co = ...,
470476
) -> None: ...
471477
@overload
472478
def __init__(
473-
self: StateSpace[_Inexact, _Float], A: _ToComplex012D, B: _ToComplex012D, C: _ToComplex012D, D: _ToComplex012D, /
479+
self: StateSpace[_Inexact, _Float],
480+
A: _ToComplex012D,
481+
B: _ToComplex012D,
482+
C: _ToComplex012D,
483+
D: _ToComplex012D,
484+
/,
485+
*,
486+
dt: _DTT_co = ...,
474487
) -> None: ...
475488

476489
#
@@ -567,7 +580,7 @@ class Bunch:
567580
rtol: float
568581
nb_iter: int
569582

570-
def __init__(self, /, **kwds: Never) -> None: ...
583+
def __init__(self, /) -> None: ...
571584

572585
#
573586
def place_poles(

‎tests/signal/test_ltisys.pyi‎

Lines changed: 51 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -57,14 +57,14 @@ _c128_1d: _VecC128
5757
_c128_2d: onp.Array2D[np.complex128]
5858
_i64_1d: onp.Array1D[np.int64]
5959

60-
_lti_f32: lti[np.float32]
61-
_lti_f64: lti[np.float64]
62-
_lti_c64: lti[np.complex64]
63-
_lti_c128: lti[np.complex128]
64-
_dlti_f32: dlti[np.float32]
65-
_dlti_f64: dlti[np.float64]
66-
_dlti_c64: dlti[np.complex64]
67-
_dlti_c128: dlti[np.complex128]
60+
_lti_f32: lti[np.float32, np.float32]
61+
_lti_f64: lti[np.float64, np.float64]
62+
_lti_c64: lti[np.complex64, np.float32]
63+
_lti_c128: lti[np.complex128, np.float64]
64+
_dlti_f32: dlti[np.float32, np.float32, float]
65+
_dlti_f64: dlti[np.float64, np.float64, float]
66+
_dlti_c64: dlti[np.complex64, np.float32, float]
67+
_dlti_c128: dlti[np.complex128, np.float64, float]
6868
_ss_cont_f32: StateSpaceContinuous[np.float32, np.float32]
6969
_ss_cont_f64: StateSpaceContinuous[np.float64, np.float64]
7070
_ss_disc_f32: StateSpaceDiscrete[np.float32, np.float32, float]
@@ -108,23 +108,49 @@ _to_ss_disc_c128: tuple[
108108
]
109109

110110
###
111-
# StateSpace
112-
ss_f32 = StateSpace(_ss_cont_f32) # pyrefly: ignore[bad-argument-type]
113-
assert_type(ss_f32, StateSpaceContinuous[np.float32, np.float32]) # type: ignore[assert-type]
114-
ss_disc_f64 = StateSpace(_ss_disc_f64) # pyrefly: ignore[bad-argument-type]
115-
assert_type(ss_disc_f64, StateSpaceDiscrete[np.float64, np.float64, float]) # type: ignore[assert-type] # pyrefly: ignore[assert-type]
111+
112+
# mypy (still) doesn't support `__new__` methods that return a different type
116113

117114
# TransferFunction
118-
tf_f32 = TransferFunction(_tf_cont_f32) # pyrefly: ignore[bad-argument-type]
119-
assert_type(tf_f32, TransferFunctionContinuous[np.float32]) # type: ignore[assert-type]
120-
tf_disc_f64 = TransferFunctionDiscrete(_f64_2d, _f64_1d, dt=0.1) # pyrefly: ignore[bad-argument-type]
121-
assert_type(tf_disc_f64, TransferFunctionDiscrete[np.float32 | np.float64, float]) # type: ignore[assert-type]
115+
assert_type(TransferFunction(_tf_cont_f32), TransferFunctionContinuous[np.float32]) # type: ignore[assert-type]
116+
assert_type(TransferFunction(_tf_disc_f32), TransferFunctionDiscrete[np.float32, float]) # type: ignore[assert-type]
117+
assert_type(TransferFunction(_f64_1d, _f64_1d), TransferFunctionContinuous[np.float32 | np.float64]) # type: ignore[assert-type]
118+
assert_type(TransferFunction(_f64_1d, _f64_1d, dt=0.1), TransferFunctionDiscrete[np.float32 | np.float64, float]) # type: ignore[assert-type]
122119

123120
# ZerosPolesGain
124-
zpk_f32 = ZerosPolesGain(_f32_1d, _f32_1d, 1.0) # pyrefly: ignore[bad-argument-type]
125-
assert_type(zpk_f32, ZerosPolesGainContinuous[np.float32 | np.float64, np.float32 | np.float64]) # type: ignore[assert-type] # pyrefly: ignore[assert-type]
126-
zpk_disc_f64 = ZerosPolesGainDiscrete(_f64_1d, _f64_1d, 1.0, dt=0.1) # pyrefly: ignore[bad-argument-type]
127-
assert_type(zpk_disc_f64, ZerosPolesGainDiscrete[np.float32 | np.float64, np.float32 | np.float64, float])
121+
assert_type(ZerosPolesGain(_zpk_cont_f32), ZerosPolesGainContinuous[np.float32, np.float32]) # type: ignore[assert-type]
122+
assert_type(ZerosPolesGain(_zpk_disc_f32), ZerosPolesGainDiscrete[np.float32, np.float32, float]) # type: ignore[assert-type]
123+
assert_type(ZerosPolesGain(_f64_1d, _f64_1d, 5), ZerosPolesGainContinuous[np.float32 | np.float64, np.float32 | np.float64]) # type: ignore[assert-type]
124+
assert_type( # type: ignore[assert-type]
125+
ZerosPolesGain(_c128_1d, _f64_1d, 5),
126+
ZerosPolesGainContinuous[np.float32 | np.float64 | np.complex64 | np.complex128, np.float32 | np.float64],
127+
)
128+
assert_type( # type: ignore[assert-type]
129+
ZerosPolesGain(_f64_1d, _f64_1d, 5, dt=0.1), ZerosPolesGainDiscrete[np.float32 | np.float64, np.float32 | np.float64, float]
130+
)
131+
assert_type( # type: ignore[assert-type]
132+
ZerosPolesGain(_c128_1d, _f64_1d, 5, dt=0.1),
133+
ZerosPolesGainDiscrete[np.float32 | np.float64 | np.complex64 | np.complex128, np.float32 | np.float64, float],
134+
)
135+
136+
# StateSpace
137+
assert_type(StateSpace(_ss_cont_f32), StateSpaceContinuous[np.float32, np.float32]) # type: ignore[assert-type]
138+
assert_type(StateSpace(_ss_disc_f32), StateSpaceDiscrete[np.float32, np.float32, float]) # type: ignore[assert-type]
139+
assert_type( # type: ignore[assert-type]
140+
StateSpace(_f64_2d, _f64_2d, _f64_2d, _f64_2d), StateSpaceContinuous[np.float32 | np.float64, np.float32 | np.float64]
141+
)
142+
assert_type( # type: ignore[assert-type]
143+
StateSpace(_c128_2d, _c128_2d, _c128_2d, _c128_2d),
144+
StateSpaceContinuous[np.float32 | np.float64 | np.complex64 | np.complex128, np.float32 | np.float64],
145+
)
146+
assert_type( # type: ignore[assert-type]
147+
StateSpace(_f64_2d, _f64_2d, _f64_2d, _f64_2d, dt=0.1),
148+
StateSpaceDiscrete[np.float32 | np.float64, np.float32 | np.float64, float],
149+
)
150+
assert_type( # type: ignore[assert-type]
151+
StateSpace(_c128_2d, _c128_2d, _c128_2d, _c128_2d, dt=0.1),
152+
StateSpaceDiscrete[np.float32 | np.float64 | np.complex64 | np.complex128, np.float32 | np.float64, float],
153+
)
128154

129155
###
130156
# lsim (same as impulse and step)
@@ -222,22 +248,22 @@ assert_type(_lti_c128.step(), tuple[_VecF64, _VecC128])
222248
# what's going on with mypy here...?
223249

224250
# f32
225-
assert_type(bode(_lti_f32), tuple[_VecF32, _VecF32, _VecF32]) # type: ignore[assert-type]
251+
assert_type(bode(_lti_f32), tuple[_VecF32, _VecF32, _VecF32])
226252
assert_type(bode(_to_tf_cont_f32), tuple[_VecF32, _VecF32, _VecF32])
227253
assert_type(bode(_to_zpk_cont_f32), tuple[_VecF32, _VecF32, _VecF32])
228254
assert_type(bode(_to_ss_cont_f32), tuple[_VecF32, _VecF32, _VecF32])
229255
# c64
230-
assert_type(bode(_lti_c64), tuple[_VecF32, _VecF32, _VecF32]) # type: ignore[assert-type]
256+
assert_type(bode(_lti_c64), tuple[_VecF32, _VecF32, _VecF32])
231257
assert_type(bode(_to_tf_cont_c64), tuple[_VecF32, _VecF32, _VecF32])
232258
assert_type(bode(_to_zpk_cont_c64), tuple[_VecF32, _VecF32, _VecF32])
233259
assert_type(bode(_to_ss_cont_c64), tuple[_VecF32, _VecF32, _VecF32])
234260
# f64
235-
assert_type(bode(_lti_f64), tuple[_VecF64, _VecF64, _VecF64]) # type: ignore[assert-type]
261+
assert_type(bode(_lti_f64), tuple[_VecF64, _VecF64, _VecF64])
236262
assert_type(bode(_to_tf_cont_f64), tuple[_VecF64, _VecF64, _VecF64])
237263
assert_type(bode(_to_zpk_cont_f64), tuple[_VecF64, _VecF64, _VecF64])
238264
assert_type(bode(_to_ss_cont_f64), tuple[_VecF64, _VecF64, _VecF64])
239265
# c128
240-
assert_type(bode(_lti_c128), tuple[_VecF64, _VecF64, _VecF64]) # type: ignore[assert-type]
266+
assert_type(bode(_lti_c128), tuple[_VecF64, _VecF64, _VecF64])
241267
assert_type(bode(_to_tf_cont_c128), tuple[_VecF64, _VecF64, _VecF64])
242268
assert_type(bode(_to_zpk_cont_c128), tuple[_VecF64, _VecF64, _VecF64])
243269
assert_type(bode(_to_ss_cont_c128), tuple[_VecF64, _VecF64, _VecF64])

0 commit comments

Comments
 (0)