`optimize.newton` rejects functions that return an array

[jorenham]

Discussed in #1517

^{Originally posted by wilgri April 7, 2026}
Hello,

I'm using scipy-stubs and I'm new to optype. The following call of newton is flagged by basedpyright in strict mode:

def func(x: ArrayND[np.float64]) -> ArrayND[np.float64]:
    return -2 * x + 1

newton(func, x0=np.zeros((2, 4), dtype=float))

I gives

Type "(x: ArrayND[float64, AnyShape]) -> ArrayND[float64, AnyShape]" is not assignable to type "_Fun1D[ToFloat]"
   Function return type "ArrayND[float64, AnyShape]" is incompatible with type "ToFloat"

Looking at newton's doc and in practice, func accepts ndarray of floats. What am I doing wrong ?

Looking at scipy.optimize.newton typing, I see that func can be a generic callable _Fun1D with a type variable named _ToFloatT . I'm not sure to understand it entirely but it seems that basedpyright does not find an appropriate overload and defaults _ToFloatT to ToFloat which is incompatible with ArrayND[np.float64]. Is my understanding correct ? In addition I don't understand why arguments are onp.Array1D[np.float64] instead of ArrayND ? I feel like I'm missing something.

How would you type this basic example ?

[wilgri]

Let me know if I'm heading in the right direction. If so, I can invest more time in it and open a pull request.

Looking at optimize/_zeros_py.pyi, I would modify and rename _Fun1D to accept ndarray as return type. It is only used in newton @overload definition and it is limited to a scalar output.

What do you think about using something like _FunND as a replacement for _Fun1D :

import numpy as np
from numpy.typing import NDArray

_X = TypeVar("_X", bound=_Floating | NDArray[np.floating])
_FunND: TypeAlias = Callable[Concatenate[_X, ...], NDArray[np.floating]]

and in newton overload :

@overload
def newton(
    func: _FunND[_X],
    x0: _X,
    fprime: _FunND[_X] | None = None,
    ...

I don't know if this would impact the rest of the stubs definitions. I also made it generic so the callable can accept a mix of either _Floating or NDArray[np.floating]. As I understand it, at least one ndarray in x0 or arg results in broadcasting and an ndarray as output in newton. I'm not good enough at typing to see a better way to type this combinations of possibilities.

I've tested basedpyright against my previous example and it does not complain in this case.

[jorenham]

What might also be an option @wilgri is to add dedicated overloads for func: _Func1D[onp.ToFloat1D], fprime: _Fun1D[onp.ToFloat2D] | None = None, and fprime2: _Fun1D[onp.ToFloat3D] | None. (although I'm not entirely sure if that's indeed how this function is supposed to be used).