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
105
106
107
108
109
110
111
112
113
114
115
| from __future__ import annotations
|
| from ._dtypes import (
| _floating_dtypes,
| _numeric_dtypes,
| )
| from ._array_object import Array
| from ._creation_functions import asarray
| from ._dtypes import float32, float64
|
| from typing import TYPE_CHECKING, Optional, Tuple, Union
|
| if TYPE_CHECKING:
| from ._typing import Dtype
|
| import numpy as np
|
|
| def max(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| keepdims: bool = False,
| ) -> Array:
| if x.dtype not in _numeric_dtypes:
| raise TypeError("Only numeric dtypes are allowed in max")
| return Array._new(np.max(x._array, axis=axis, keepdims=keepdims))
|
|
| def mean(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| keepdims: bool = False,
| ) -> Array:
| if x.dtype not in _floating_dtypes:
| raise TypeError("Only floating-point dtypes are allowed in mean")
| return Array._new(np.mean(x._array, axis=axis, keepdims=keepdims))
|
|
| def min(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| keepdims: bool = False,
| ) -> Array:
| if x.dtype not in _numeric_dtypes:
| raise TypeError("Only numeric dtypes are allowed in min")
| return Array._new(np.min(x._array, axis=axis, keepdims=keepdims))
|
|
| def prod(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| dtype: Optional[Dtype] = None,
| keepdims: bool = False,
| ) -> Array:
| if x.dtype not in _numeric_dtypes:
| raise TypeError("Only numeric dtypes are allowed in prod")
| # Note: sum() and prod() always upcast float32 to float64 for dtype=None
| # We need to do so here before computing the product to avoid overflow
| if dtype is None and x.dtype == float32:
| dtype = float64
| return Array._new(np.prod(x._array, dtype=dtype, axis=axis, keepdims=keepdims))
|
|
| def std(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| correction: Union[int, float] = 0.0,
| keepdims: bool = False,
| ) -> Array:
| # Note: the keyword argument correction is different here
| if x.dtype not in _floating_dtypes:
| raise TypeError("Only floating-point dtypes are allowed in std")
| return Array._new(np.std(x._array, axis=axis, ddof=correction, keepdims=keepdims))
|
|
| def sum(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| dtype: Optional[Dtype] = None,
| keepdims: bool = False,
| ) -> Array:
| if x.dtype not in _numeric_dtypes:
| raise TypeError("Only numeric dtypes are allowed in sum")
| # Note: sum() and prod() always upcast integers to (u)int64 and float32 to
| # float64 for dtype=None. `np.sum` does that too for integers, but not for
| # float32, so we need to special-case it here
| if dtype is None and x.dtype == float32:
| dtype = float64
| return Array._new(np.sum(x._array, axis=axis, dtype=dtype, keepdims=keepdims))
|
|
| def var(
| x: Array,
| /,
| *,
| axis: Optional[Union[int, Tuple[int, ...]]] = None,
| correction: Union[int, float] = 0.0,
| keepdims: bool = False,
| ) -> Array:
| # Note: the keyword argument correction is different here
| if x.dtype not in _floating_dtypes:
| raise TypeError("Only floating-point dtypes are allowed in var")
| return Array._new(np.var(x._array, axis=axis, ddof=correction, keepdims=keepdims))
|
|
