gtsam-develop 4.3a0.dev202510101133__cp311-cp311-macosx_11_0_arm64.whl → 4.3a0.dev202510101309__cp311-cp311-macosx_11_0_arm64.whl

gtsam/gtsam/gtsfm.pyi

@@ -2,15 +2,20 @@
 gtsfm submodule
 """
 from __future__ import annotations
+import collections.abc
 import gtsam.gtsam
 import numpy
+import numpy.typing
 import typing
 __all__: list[str] = ['Keypoints', 'tracksFromPairwiseMatches']
-M = typing.TypeVar("M", bound=int)
-N = typing.TypeVar("N", bound=int)
 class Keypoints:
-    coordinates: numpy.ndarray[tuple[M, typing.Literal[2]], numpy.dtype[numpy.float64]]
-    def __init__(self, coordinates: numpy.ndarray[tuple[M, typing.Literal[2]], numpy.dtype[numpy.float64]]) -> None:
+    def __init__(self, coordinates: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 2]"]) -> None:
         ...
-def tracksFromPairwiseMatches(matches_dict: dict[gtsam.gtsam.IndexPair, numpy.ndarray[tuple[M, typing.Literal[2]], numpy.dtype[numpy.int32]]], keypoints_list: list[Keypoints], verbose: bool = False) -> list[gtsam.gtsam.SfmTrack2d]:
+    @property
+    def coordinates(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 2]"]:
+        ...
+    @coordinates.setter
+    def coordinates(self, arg0: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 2]"]) -> None:
+        ...
+def tracksFromPairwiseMatches(matches_dict: collections.abc.Mapping[gtsam.gtsam.IndexPair, typing.Annotated[numpy.typing.ArrayLike, numpy.int32, "[m, 2]"]], keypoints_list: collections.abc.Sequence[Keypoints], verbose: bool = False) -> list[gtsam.gtsam.SfmTrack2d]:
     ...

gtsam/gtsam/imuBias.pyi

@@ -3,9 +3,9 @@ imuBias submodule
 """
 from __future__ import annotations
 import numpy
+import numpy.typing
 import typing
 __all__: list[str] = ['ConstantBias']
-M = typing.TypeVar("M", bound=int)
 class ConstantBias:
     @staticmethod
     def Identity() -> ConstantBias:
@@ -20,7 +20,7 @@ class ConstantBias:
     def __init__(self) -> None:
         ...
     @typing.overload
-    def __init__(self, biasAcc: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], biasGyro: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> None:
+    def __init__(self, biasAcc: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], biasGyro: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> None:
         ...
     def __neg__(self) -> ConstantBias:
         ...
@@ -30,41 +30,41 @@ class ConstantBias:
         ...
     def __sub__(self, arg0: ConstantBias) -> ConstantBias:
         ...
-    def accelerometer(self) -> numpy.ndarray[tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def accelerometer(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]:
         """
         get accelerometer bias
         """
-    def correctAccelerometer(self, measurement: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> numpy.ndarray[tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def correctAccelerometer(self, measurement: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]:
         """
         Correct an accelerometer measurement using this bias model, and optionally compute Jacobians.
         """
-    def correctGyroscope(self, measurement: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> numpy.ndarray[tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def correctGyroscope(self, measurement: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]:
         """
         Correct a gyroscope measurement using this bias model, and optionally compute Jacobians.
         """
     def deserialize(self, serialized: str) -> None:
         ...
-    def equals(self, expected: ConstantBias, tol: float) -> bool:
+    def equals(self, expected: ConstantBias, tol: typing.SupportsFloat) -> bool:
         """
         equality up to tolerance
         """
-    def gyroscope(self) -> numpy.ndarray[tuple[typing.Literal[3], typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def gyroscope(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3, 1]"]:
         """
         get gyroscope bias
         """
-    def localCoordinates(self, b: ConstantBias) -> numpy.ndarray[tuple[typing.Literal[6], typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def localCoordinates(self, b: ConstantBias) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]:
         ...
     def print(self, s: str = '') -> None:
         """
         print with optional string
         """
-    def retract(self, v: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> ConstantBias:
+    def retract(self, v: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> ConstantBias:
         """
         The retract function.
         """
     def serialize(self) -> str:
         ...
-    def vector(self) -> numpy.ndarray[tuple[typing.Literal[6], typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def vector(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[6, 1]"]:
         """
         return the accelerometer and gyro biases in a single vector
         """

gtsam/gtsam/noiseModel/__init__.pyi

@@ -3,6 +3,7 @@ noiseModel submodule
 """
 from __future__ import annotations
 import numpy
+import numpy.typing
 import typing
 from . import mEstimator
 __all__: list[str] = ['Base', 'Constrained', 'Diagonal', 'Gaussian', 'Isotropic', 'Robust', 'Unit', 'mEstimator']
@@ -14,47 +15,47 @@ class Base:
 class Constrained(Diagonal):
     @staticmethod
     @typing.overload
-    def All(dim: int) -> Constrained:
+    def All(dim: typing.SupportsInt) -> Constrained:
         """
         Fully constrained variations.
         """
     @staticmethod
     @typing.overload
-    def All(dim: int, mu: float) -> Constrained:
+    def All(dim: typing.SupportsInt, mu: typing.SupportsFloat) -> Constrained:
         """
         Fully constrained variations.
         """
     @staticmethod
     @typing.overload
-    def MixedPrecisions(mu: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], precisions: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> Constrained:
+    def MixedPrecisions(mu: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], precisions: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> Constrained:
         """
         A diagonal noise model created by specifying a Vector of precisions, some of which might be inf.
         """
     @staticmethod
     @typing.overload
-    def MixedPrecisions(precisions: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> Constrained:
+    def MixedPrecisions(precisions: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> Constrained:
         ...
     @staticmethod
     @typing.overload
-    def MixedSigmas(mu: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], sigmas: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> Constrained:
+    def MixedSigmas(mu: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], sigmas: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> Constrained:
         """
         A diagonal noise model created by specifying a Vector of standard devations, some of which might be zero.
         """
     @staticmethod
     @typing.overload
-    def MixedSigmas(m: float, sigmas: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> Constrained:
+    def MixedSigmas(m: typing.SupportsFloat, sigmas: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> Constrained:
         """
         A diagonal noise model created by specifying a Vector of standard devations, some of which might be zero.
         """
     @staticmethod
     @typing.overload
-    def MixedVariances(mu: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], variances: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> Constrained:
+    def MixedVariances(mu: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], variances: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> Constrained:
         """
         A diagonal noise model created by specifying a Vector of standard devations, some of which might be zero.
         """
     @staticmethod
     @typing.overload
-    def MixedVariances(variances: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> Constrained:
+    def MixedVariances(variances: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> Constrained:
         ...
     def __getstate__(self) -> tuple:
         ...
@@ -70,21 +71,21 @@ class Constrained(Diagonal):
         """
 class Diagonal(Gaussian):
     @staticmethod
-    def Precisions(precisions: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], smart: bool = True) -> Diagonal:
+    def Precisions(precisions: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], smart: bool = True) -> Diagonal:
         """
         A diagonal noise model created by specifying a Vector of precisions, i.e.
         
         i.e. the diagonal of the information matrix, i.e., weights
         """
     @staticmethod
-    def Sigmas(sigmas: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], smart: bool = True) -> Diagonal:
+    def Sigmas(sigmas: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], smart: bool = True) -> Diagonal:
         """
         A diagonal noise model created by specifying a Vector of sigmas, i.e.
         
         standard deviations, the diagonal of the square root covariance matrix.
         """
     @staticmethod
-    def Variances(variances: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]], smart: bool = True) -> Diagonal:
+    def Variances(variances: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"], smart: bool = True) -> Diagonal:
         """
         A diagonal noise model created by specifying a Vector of variances, i.e.
         
@@ -92,7 +93,7 @@ class Diagonal(Gaussian):
         variances: A vector containing the variances of this noise model
         smart: check if can be simplified to derived class
         """
-    def R(self) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]]:
+    def R(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]"]:
         """
         Return R itself, but note that Whiten(H) is cheaper than R*H.
         """
@@ -102,29 +103,29 @@ class Diagonal(Gaussian):
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def invsigmas(self) -> numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def invsigmas(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]:
         """
         Return sqrt precisions.
         """
-    def precisions(self) -> numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def precisions(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]:
         """
         Return precisions.
         """
     def serialize(self) -> str:
         ...
-    def sigmas(self) -> numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def sigmas(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]:
         """
         Calculate standard deviations.
         """
 class Gaussian(Base):
     @staticmethod
-    def Covariance(R: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], smart: bool = True) -> Gaussian:
+    def Covariance(R: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, n]"], smart: bool = True) -> Gaussian:
         ...
     @staticmethod
-    def Information(R: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], smart: bool = True) -> Gaussian:
+    def Information(R: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, n]"], smart: bool = True) -> Gaussian:
         ...
     @staticmethod
-    def SqrtInformation(R: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]], smart: bool = True) -> Gaussian:
+    def SqrtInformation(R: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, n]"], smart: bool = True) -> Gaussian:
         """
         AGaussiannoise model created by specifying a square root information matrix.
         
@@ -132,11 +133,11 @@ class Gaussian(Base):
         R: The (upper-triangular) square root information matrix
         smart: check if can be simplified to derived class
         """
-    def R(self) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]]:
+    def R(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]"]:
         """
         Return R itself, but note that Whiten(H) is cheaper than R*H.
         """
-    def Whiten(self, H: numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]]) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]]:
+    def Whiten(self, H: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, n]"]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]"]:
         """
         Multiply a derivative with R (derivative of whiten) Equivalent to whitening each column of the input matrix.
         """
@@ -144,15 +145,15 @@ class Gaussian(Base):
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
-    def covariance(self) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]]:
+    def covariance(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]"]:
         """
         Compute covariance matrix.
         """
     def deserialize(self, serialized: str) -> None:
         ...
-    def equals(self, expected: Base, tol: float) -> bool:
+    def equals(self, expected: Base, tol: typing.SupportsFloat) -> bool:
         ...
-    def information(self) -> numpy.ndarray[tuple[M, N], numpy.dtype[numpy.float64]]:
+    def information(self) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]"]:
         """
         Compute information matrix.
         """
@@ -164,27 +165,27 @@ class Gaussian(Base):
         """
     def serialize(self) -> str:
         ...
-    def unwhiten(self, v: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def unwhiten(self, v: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]:
         """
         Unwhiten an error vector.
         """
-    def whiten(self, v: numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]) -> numpy.ndarray[tuple[M, typing.Literal[1]], numpy.dtype[numpy.float64]]:
+    def whiten(self, v: typing.Annotated[numpy.typing.ArrayLike, numpy.float64, "[m, 1]"]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, 1]"]:
         """
         Whiten an error vector.
         """
 class Isotropic(Diagonal):
     @staticmethod
-    def Precision(dim: int, precision: float, smart: bool = True) -> Isotropic:
+    def Precision(dim: typing.SupportsInt, precision: typing.SupportsFloat, smart: bool = True) -> Isotropic:
         """
         An isotropic noise model created by specifying a precision.
         """
     @staticmethod
-    def Sigma(dim: int, sigma: float, smart: bool = True) -> Isotropic:
+    def Sigma(dim: typing.SupportsInt, sigma: typing.SupportsFloat, smart: bool = True) -> Isotropic:
         """
         An isotropic noise model created by specifying a standard devation sigma.
         """
     @staticmethod
-    def Variance(dim: int, varianace: float, smart: bool = True) -> Isotropic:
+    def Variance(dim: typing.SupportsInt, varianace: typing.SupportsFloat, smart: bool = True) -> Isotropic:
         ...
     def __getstate__(self) -> tuple:
         ...
@@ -214,7 +215,7 @@ class Robust(Base):
         ...
 class Unit(Isotropic):
     @staticmethod
-    def Create(dim: int) -> Unit:
+    def Create(dim: typing.SupportsInt) -> Unit:
         """
         Create a unit covariance noise model.
         """

gtsam/gtsam/noiseModel/mEstimator.pyi

@@ -2,55 +2,54 @@
 mEstimator submodule
 """
 from __future__ import annotations
+import collections.abc
 import typing
 __all__: list[str] = ['AsymmetricCauchy', 'AsymmetricTukey', 'Base', 'Cauchy', 'Custom', 'DCS', 'Fair', 'GemanMcClure', 'Huber', 'L2WithDeadZone', 'Null', 'Tukey', 'Welsch']
-M = typing.TypeVar("M", bound=int)
-N = typing.TypeVar("N", bound=int)
 class AsymmetricCauchy(Base):
     @staticmethod
-    def Create(k: float) -> AsymmetricCauchy:
+    def Create(k: typing.SupportsFloat) -> AsymmetricCauchy:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, k: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, k: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class AsymmetricTukey(Base):
     @staticmethod
-    def Create(k: float) -> AsymmetricTukey:
+    def Create(k: typing.SupportsFloat) -> AsymmetricTukey:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, k: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, k: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
@@ -80,7 +79,7 @@ class Base:
             ...
         def __index__(self) -> int:
             ...
-        def __init__(self, value: int) -> None:
+        def __init__(self, value: typing.SupportsInt) -> None:
             ...
         def __int__(self) -> int:
             ...
@@ -102,7 +101,7 @@ class Base:
             ...
         def __rxor__(self, other: typing.Any) -> typing.Any:
             ...
-        def __setstate__(self, state: int) -> None:
+        def __setstate__(self, state: typing.SupportsInt) -> None:
             ...
         def __str__(self) -> str:
             ...
@@ -120,157 +119,157 @@ class Base:
         ...
 class Cauchy(Base):
     @staticmethod
-    def Create(k: float) -> Cauchy:
+    def Create(k: typing.SupportsFloat) -> Cauchy:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, k: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, k: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class Custom(Base):
     @staticmethod
-    def Create(weight: typing.Callable[[float], float], loss: typing.Callable[[float], float], reweight: Base.ReweightScheme, name: str) -> Custom:
+    def Create(weight: collections.abc.Callable[[typing.SupportsFloat], float], loss: collections.abc.Callable[[typing.SupportsFloat], float], reweight: Base.ReweightScheme, name: str) -> Custom:
         ...
     def __getstate__(self) -> tuple:
         ...
-    def __init__(self, weight: typing.Callable[[float], float], loss: typing.Callable[[float], float], reweight: Base.ReweightScheme, name: str) -> None:
+    def __init__(self, weight: collections.abc.Callable[[typing.SupportsFloat], float], loss: collections.abc.Callable[[typing.SupportsFloat], float], reweight: Base.ReweightScheme, name: str) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class DCS(Base):
     @staticmethod
-    def Create(c: float) -> DCS:
+    def Create(c: typing.SupportsFloat) -> DCS:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, c: float) -> None:
+    def __init__(self, c: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, c: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, c: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class Fair(Base):
     @staticmethod
-    def Create(c: float) -> Fair:
+    def Create(c: typing.SupportsFloat) -> Fair:
         ...
     def __getstate__(self) -> tuple:
         ...
-    def __init__(self, c: float) -> None:
+    def __init__(self, c: typing.SupportsFloat) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class GemanMcClure(Base):
     @staticmethod
-    def Create(c: float) -> GemanMcClure:
+    def Create(c: typing.SupportsFloat) -> GemanMcClure:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, c: float) -> None:
+    def __init__(self, c: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, c: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, c: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class Huber(Base):
     @staticmethod
-    def Create(k: float) -> Huber:
+    def Create(k: typing.SupportsFloat) -> Huber:
         ...
     def __getstate__(self) -> tuple:
         ...
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class L2WithDeadZone(Base):
     @staticmethod
-    def Create(k: float) -> L2WithDeadZone:
+    def Create(k: typing.SupportsFloat) -> L2WithDeadZone:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, k: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, k: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
@@ -286,59 +285,59 @@ class Null(Base):
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class Tukey(Base):
     @staticmethod
-    def Create(k: float) -> Tukey:
+    def Create(k: typing.SupportsFloat) -> Tukey:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, k: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, k: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """
 class Welsch(Base):
     @staticmethod
-    def Create(k: float) -> Welsch:
+    def Create(k: typing.SupportsFloat) -> Welsch:
         ...
     def __getstate__(self) -> tuple:
         ...
     @typing.overload
-    def __init__(self, k: float) -> None:
+    def __init__(self, k: typing.SupportsFloat) -> None:
         ...
     @typing.overload
-    def __init__(self, k: float, reweight: Base.ReweightScheme) -> None:
+    def __init__(self, k: typing.SupportsFloat, reweight: Base.ReweightScheme) -> None:
         ...
     def __setstate__(self, arg0: tuple) -> None:
         ...
     def deserialize(self, serialized: str) -> None:
         ...
-    def loss(self, error: float) -> float:
+    def loss(self, error: typing.SupportsFloat) -> float:
         ...
     def serialize(self) -> str:
         ...
-    def weight(self, error: float) -> float:
+    def weight(self, error: typing.SupportsFloat) -> float:
         """
         produce a weight vector according to an error vector and the implemented robust function
         """