scirs2-python 0.4.3

Python bindings for SciRS2 - A comprehensive scientific computing library in Rust (SciPy alternative)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

"""Type stubs for scirs2.optimize — Optimization module."""

from __future__ import annotations

from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union

import numpy as np
from numpy.typing import ArrayLike, NDArray

# ---------------------------------------------------------------------------
# Result types
# ---------------------------------------------------------------------------

class OptimizeResult:
    """Optimization result container (mirrors scipy.optimize.OptimizeResult)."""
    x: NDArray[np.float64]
    success: bool
    fun: float
    nit: int
    message: str
    def __init__(self, **kwargs: Any) -> None: ...

# ---------------------------------------------------------------------------
# Minimization
# ---------------------------------------------------------------------------

def minimize_py(
    fun: Callable[[NDArray[np.float64]], float],
    x0: ArrayLike,
    method: str = "L-BFGS-B",
    jac: Optional[Callable[[NDArray[np.float64]], NDArray[np.float64]]] = None,
    bounds: Optional[Sequence[Tuple[Optional[float], Optional[float]]]] = None,
    tol: Optional[float] = None,
    maxiter: Optional[int] = None,
    options: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    """Minimise a scalar function of one or more variables.

    Mirrors the interface of ``scipy.optimize.minimize``.
    """
    ...

def minimize_scalar_py(
    fun: Callable[[float], float],
    bounds: Optional[Tuple[float, float]] = None,
    method: str = "brent",
) -> Dict[str, Any]:
    """Minimise a scalar function of a single variable."""
    ...

# ---------------------------------------------------------------------------
# Root finding
# ---------------------------------------------------------------------------

def brentq_py(
    f: Callable[[float], float],
    a: float,
    b: float,
    tol: float = 2e-12,
    maxiter: int = 100,
) -> float:
    """Find a root of f in the interval [a, b] using Brent's method."""
    ...

def fsolve_py(
    f: Callable[[NDArray[np.float64]], NDArray[np.float64]],
    x0: ArrayLike,
    tol: float = 1.49012e-8,
) -> NDArray[np.float64]:
    """Find roots of a multivariate function."""
    ...

# ---------------------------------------------------------------------------
# Curve fitting
# ---------------------------------------------------------------------------

def curve_fit_py(
    f: Callable[..., NDArray[np.float64]],
    xdata: ArrayLike,
    ydata: ArrayLike,
    p0: Optional[ArrayLike] = None,
    sigma: Optional[ArrayLike] = None,
    maxfev: int = 1000,
) -> Tuple[NDArray[np.float64], NDArray[np.float64]]:
    """Fit a curve to data using non-linear least squares.

    Returns (popt, pcov) — optimal parameters and covariance matrix.
    """
    ...

# ---------------------------------------------------------------------------
# Linear programming
# ---------------------------------------------------------------------------

def linprog_py(
    c: ArrayLike,
    a_ub: Optional[NDArray[np.float64]] = None,
    b_ub: Optional[NDArray[np.float64]] = None,
    a_eq: Optional[NDArray[np.float64]] = None,
    b_eq: Optional[NDArray[np.float64]] = None,
    bounds: Optional[Sequence[Tuple[Optional[float], Optional[float]]]] = None,
) -> Dict[str, Any]:
    """Minimise c^T x subject to linear constraints."""
    ...