Domů Procházet Nápověda
Registrovat se Přihlásit se
yichael
/
AndroidRemoteController
1
0
Rozštěpit 0
Soubory Úkoly 0 Pull Requesty 0 Wiki
Strom: dc549c0739
Větve Značky
AndroidRemoteCo...
/
python
/
opencv
/
numpy
/
typing
/
tests
/
data
/
reveal
/
fromnumeric.pyi

fromnumeric.pyi 15 KB
Historie Surový

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343 
  1. """Tests for :mod:`_core.fromnumeric`."""
    2. 

  2. 

  3. from typing import Any, Literal as L
    4. 

  4. 

  5. import numpy as np
    6. 

  6. import numpy.typing as npt
    7. 

  7. 

  8. from typing_extensions import assert_type
    9. 

  9. 

  10. class NDArraySubclass(npt.NDArray[np.complex128]):
    11. 

  11.     ...
    12. 

  12. 

  13. AR_b: npt.NDArray[np.bool]
    14. 

  14. AR_f4: npt.NDArray[np.float32]
    15. 

  15. AR_c16: npt.NDArray[np.complex128]
    16. 

  16. AR_u8: npt.NDArray[np.uint64]
    17. 

  17. AR_i8: npt.NDArray[np.int64]
    18. 

  18. AR_O: npt.NDArray[np.object_]
    19. 

  19. AR_subclass: NDArraySubclass
    20. 

  20. AR_m: npt.NDArray[np.timedelta64]
    21. 

  21. AR_0d: np.ndarray[tuple[()], np.dtype[Any]]
    22. 

  22. AR_1d: np.ndarray[tuple[int], np.dtype[Any]]
    23. 

  23. AR_nd: np.ndarray[tuple[int, ...], np.dtype[Any]]
    24. 

  24. 

  25. b: np.bool
    26. 

  26. f4: np.float32
    27. 

  27. i8: np.int64
    28. 

  28. f: float
    29. 

  29. 

  30. assert_type(np.take(b, 0), np.bool)
    31. 

  31. assert_type(np.take(f4, 0), np.float32)
    32. 

  32. assert_type(np.take(f, 0), Any)
    33. 

  33. assert_type(np.take(AR_b, 0), np.bool)
    34. 

  34. assert_type(np.take(AR_f4, 0), np.float32)
    35. 

  35. assert_type(np.take(AR_b, [0]), npt.NDArray[np.bool])
    36. 

  36. assert_type(np.take(AR_f4, [0]), npt.NDArray[np.float32])
    37. 

  37. assert_type(np.take([1], [0]), npt.NDArray[Any])
    38. 

  38. assert_type(np.take(AR_f4, [0], out=AR_subclass), NDArraySubclass)
    39. 

  39. 

  40. assert_type(np.reshape(b, 1), np.ndarray[tuple[int], np.dtype[np.bool]])
    41. 

  41. assert_type(np.reshape(f4, 1), np.ndarray[tuple[int], np.dtype[np.float32]])
    42. 

  42. assert_type(np.reshape(f, 1), np.ndarray[tuple[int], np.dtype[Any]])
    43. 

  43. assert_type(np.reshape(AR_b, 1), np.ndarray[tuple[int], np.dtype[np.bool]])
    44. 

  44. assert_type(np.reshape(AR_f4, 1), np.ndarray[tuple[int], np.dtype[np.float32]])
    45. 

  45. 

  46. assert_type(np.choose(1, [True, True]), Any)
    47. 

  47. assert_type(np.choose([1], [True, True]), npt.NDArray[Any])
    48. 

  48. assert_type(np.choose([1], AR_b), npt.NDArray[np.bool])
    49. 

  49. assert_type(np.choose([1], AR_b, out=AR_f4), npt.NDArray[np.float32])
    50. 

  50. 

  51. assert_type(np.repeat(b, 1), npt.NDArray[np.bool])
    52. 

  52. assert_type(np.repeat(f4, 1), npt.NDArray[np.float32])
    53. 

  53. assert_type(np.repeat(f, 1), npt.NDArray[Any])
    54. 

  54. assert_type(np.repeat(AR_b, 1), npt.NDArray[np.bool])
    55. 

  55. assert_type(np.repeat(AR_f4, 1), npt.NDArray[np.float32])
    56. 

  56. 

  57. # TODO: array_bdd tests for np.put()
    58. 

  58. 

  59. assert_type(np.swapaxes([[0, 1]], 0, 0), npt.NDArray[Any])
    60. 

  60. assert_type(np.swapaxes(AR_b, 0, 0), npt.NDArray[np.bool])
    61. 

  61. assert_type(np.swapaxes(AR_f4, 0, 0), npt.NDArray[np.float32])
    62. 

  62. 

  63. assert_type(np.transpose(b), npt.NDArray[np.bool])
    64. 

  64. assert_type(np.transpose(f4), npt.NDArray[np.float32])
    65. 

  65. assert_type(np.transpose(f), npt.NDArray[Any])
    66. 

  66. assert_type(np.transpose(AR_b), npt.NDArray[np.bool])
    67. 

  67. assert_type(np.transpose(AR_f4), npt.NDArray[np.float32])
    68. 

  68. 

  69. assert_type(np.partition(b, 0, axis=None), npt.NDArray[np.bool])
    70. 

  70. assert_type(np.partition(f4, 0, axis=None), npt.NDArray[np.float32])
    71. 

  71. assert_type(np.partition(f, 0, axis=None), npt.NDArray[Any])
    72. 

  72. assert_type(np.partition(AR_b, 0), npt.NDArray[np.bool])
    73. 

  73. assert_type(np.partition(AR_f4, 0), npt.NDArray[np.float32])
    74. 

  74. 

  75. assert_type(np.argpartition(b, 0), npt.NDArray[np.intp])
    76. 

  76. assert_type(np.argpartition(f4, 0), npt.NDArray[np.intp])
    77. 

  77. assert_type(np.argpartition(f, 0), npt.NDArray[np.intp])
    78. 

  78. assert_type(np.argpartition(AR_b, 0), npt.NDArray[np.intp])
    79. 

  79. assert_type(np.argpartition(AR_f4, 0), npt.NDArray[np.intp])
    80. 

  80. 

  81. assert_type(np.sort([2, 1], 0), npt.NDArray[Any])
    82. 

  82. assert_type(np.sort(AR_b, 0), npt.NDArray[np.bool])
    83. 

  83. assert_type(np.sort(AR_f4, 0), npt.NDArray[np.float32])
    84. 

  84. 

  85. assert_type(np.argsort(AR_b, 0), npt.NDArray[np.intp])
    86. 

  86. assert_type(np.argsort(AR_f4, 0), npt.NDArray[np.intp])
    87. 

  87. 

  88. assert_type(np.argmax(AR_b), np.intp)
    89. 

  89. assert_type(np.argmax(AR_f4), np.intp)
    90. 

  90. assert_type(np.argmax(AR_b, axis=0), Any)
    91. 

  91. assert_type(np.argmax(AR_f4, axis=0), Any)
    92. 

  92. assert_type(np.argmax(AR_f4, out=AR_subclass), NDArraySubclass)
    93. 

  93. 

  94. assert_type(np.argmin(AR_b), np.intp)
    95. 

  95. assert_type(np.argmin(AR_f4), np.intp)
    96. 

  96. assert_type(np.argmin(AR_b, axis=0), Any)
    97. 

  97. assert_type(np.argmin(AR_f4, axis=0), Any)
    98. 

  98. assert_type(np.argmin(AR_f4, out=AR_subclass), NDArraySubclass)
    99. 

  99. 

  100. assert_type(np.searchsorted(AR_b[0], 0), np.intp)
    101. 

  101. assert_type(np.searchsorted(AR_f4[0], 0), np.intp)
    102. 

  102. assert_type(np.searchsorted(AR_b[0], [0]), npt.NDArray[np.intp])
    103. 

  103. assert_type(np.searchsorted(AR_f4[0], [0]), npt.NDArray[np.intp])
    104. 

  104. 

  105. assert_type(np.resize(b, (5, 5)), np.ndarray[tuple[int, int], np.dtype[np.bool]])
    106. 

  106. assert_type(np.resize(f4, (5, 5)), np.ndarray[tuple[int, int], np.dtype[np.float32]])
    107. 

  107. assert_type(np.resize(f, (5, 5)), np.ndarray[tuple[int, int], np.dtype[Any]])
    108. 

  108. assert_type(np.resize(AR_b, (5, 5)), np.ndarray[tuple[int, int], np.dtype[np.bool]])
    109. 

  109. assert_type(np.resize(AR_f4, (5, 5)), np.ndarray[tuple[int, int], np.dtype[np.float32]])
    110. 

  110. 

  111. assert_type(np.squeeze(b), np.bool)
    112. 

  112. assert_type(np.squeeze(f4), np.float32)
    113. 

  113. assert_type(np.squeeze(f), npt.NDArray[Any])
    114. 

  114. assert_type(np.squeeze(AR_b), npt.NDArray[np.bool])
    115. 

  115. assert_type(np.squeeze(AR_f4), npt.NDArray[np.float32])
    116. 

  116. 

  117. assert_type(np.diagonal(AR_b), npt.NDArray[np.bool])
    118. 

  118. assert_type(np.diagonal(AR_f4), npt.NDArray[np.float32])
    119. 

  119. 

  120. assert_type(np.trace(AR_b), Any)
    121. 

  121. assert_type(np.trace(AR_f4), Any)
    122. 

  122. assert_type(np.trace(AR_f4, out=AR_subclass), NDArraySubclass)
    123. 

  123. 

  124. assert_type(np.ravel(b), np.ndarray[tuple[int], np.dtype[np.bool]])
    125. 

  125. assert_type(np.ravel(f4), np.ndarray[tuple[int], np.dtype[np.float32]])
    126. 

  126. assert_type(np.ravel(f), np.ndarray[tuple[int], np.dtype[np.float64 | np.int_ | np.bool]])
    127. 

  127. assert_type(np.ravel(AR_b), np.ndarray[tuple[int], np.dtype[np.bool]])
    128. 

  128. assert_type(np.ravel(AR_f4), np.ndarray[tuple[int], np.dtype[np.float32]])
    129. 

  129. 

  130. assert_type(np.nonzero(AR_b), tuple[npt.NDArray[np.intp], ...])
    131. 

  131. assert_type(np.nonzero(AR_f4), tuple[npt.NDArray[np.intp], ...])
    132. 

  132. assert_type(np.nonzero(AR_1d), tuple[npt.NDArray[np.intp], ...])
    133. 

  133. assert_type(np.nonzero(AR_nd), tuple[npt.NDArray[np.intp], ...])
    134. 

  134. 

  135. assert_type(np.shape(b), tuple[()])
    136. 

  136. assert_type(np.shape(f), tuple[()])
    137. 

  137. assert_type(np.shape([1]), tuple[int])
    138. 

  138. assert_type(np.shape([[2]]), tuple[int, int])
    139. 

  139. assert_type(np.shape([[[3]]]), tuple[int, ...])
    140. 

  140. assert_type(np.shape(AR_b), tuple[int, ...])
    141. 

  141. assert_type(np.shape(AR_nd), tuple[int, ...])
    142. 

  142. # these fail on mypy, but it works as expected with pyright/pylance
    143. 

  143. # assert_type(np.shape(AR_0d), tuple[()])
    144. 

  144. # assert_type(np.shape(AR_1d), tuple[int])
    145. 

  145. # assert_type(np.shape(AR_2d), tuple[int, int])
    146. 

  146. 

  147. assert_type(np.compress([True], b), npt.NDArray[np.bool])
    148. 

  148. assert_type(np.compress([True], f4), npt.NDArray[np.float32])
    149. 

  149. assert_type(np.compress([True], f), npt.NDArray[Any])
    150. 

  150. assert_type(np.compress([True], AR_b), npt.NDArray[np.bool])
    151. 

  151. assert_type(np.compress([True], AR_f4), npt.NDArray[np.float32])
    152. 

  152. 

  153. assert_type(np.clip(b, 0, 1.0), np.bool)
    154. 

  154. assert_type(np.clip(f4, -1, 1), np.float32)
    155. 

  155. assert_type(np.clip(f, 0, 1), Any)
    156. 

  156. assert_type(np.clip(AR_b, 0, 1), npt.NDArray[np.bool])
    157. 

  157. assert_type(np.clip(AR_f4, 0, 1), npt.NDArray[np.float32])
    158. 

  158. assert_type(np.clip([0], 0, 1), npt.NDArray[Any])
    159. 

  159. assert_type(np.clip(AR_b, 0, 1, out=AR_subclass), NDArraySubclass)
    160. 

  160. 

  161. assert_type(np.sum(b), np.bool)
    162. 

  162. assert_type(np.sum(f4), np.float32)
    163. 

  163. assert_type(np.sum(f), Any)
    164. 

  164. assert_type(np.sum(AR_b), np.bool)
    165. 

  165. assert_type(np.sum(AR_f4), np.float32)
    166. 

  166. assert_type(np.sum(AR_b, axis=0), Any)
    167. 

  167. assert_type(np.sum(AR_f4, axis=0), Any)
    168. 

  168. assert_type(np.sum(AR_f4, out=AR_subclass), NDArraySubclass)
    169. 

  169. assert_type(np.sum(AR_f4, dtype=np.float64), np.float64)
    170. 

  170. assert_type(np.sum(AR_f4, None, np.float64), np.float64)
    171. 

  171. assert_type(np.sum(AR_f4, dtype=np.float64, keepdims=False), np.float64)
    172. 

  172. assert_type(np.sum(AR_f4, None, np.float64, keepdims=False), np.float64)
    173. 

  173. assert_type(np.sum(AR_f4, dtype=np.float64, keepdims=True), np.float64 | npt.NDArray[np.float64])
    174. 

  174. assert_type(np.sum(AR_f4, None, np.float64, keepdims=True), np.float64 | npt.NDArray[np.float64])
    175. 

  175. 

  176. assert_type(np.all(b), np.bool)
    177. 

  177. assert_type(np.all(f4), np.bool)
    178. 

  178. assert_type(np.all(f), np.bool)
    179. 

  179. assert_type(np.all(AR_b), np.bool)
    180. 

  180. assert_type(np.all(AR_f4), np.bool)
    181. 

  181. assert_type(np.all(AR_b, axis=0), Any)
    182. 

  182. assert_type(np.all(AR_f4, axis=0), Any)
    183. 

  183. assert_type(np.all(AR_b, keepdims=True), Any)
    184. 

  184. assert_type(np.all(AR_f4, keepdims=True), Any)
    185. 

  185. assert_type(np.all(AR_f4, out=AR_subclass), NDArraySubclass)
    186. 

  186. 

  187. assert_type(np.any(b), np.bool)
    188. 

  188. assert_type(np.any(f4), np.bool)
    189. 

  189. assert_type(np.any(f), np.bool)
    190. 

  190. assert_type(np.any(AR_b), np.bool)
    191. 

  191. assert_type(np.any(AR_f4), np.bool)
    192. 

  192. assert_type(np.any(AR_b, axis=0), Any)
    193. 

  193. assert_type(np.any(AR_f4, axis=0), Any)
    194. 

  194. assert_type(np.any(AR_b, keepdims=True), Any)
    195. 

  195. assert_type(np.any(AR_f4, keepdims=True), Any)
    196. 

  196. assert_type(np.any(AR_f4, out=AR_subclass), NDArraySubclass)
    197. 

  197. 

  198. assert_type(np.cumsum(b), npt.NDArray[np.bool])
    199. 

  199. assert_type(np.cumsum(f4), npt.NDArray[np.float32])
    200. 

  200. assert_type(np.cumsum(f), npt.NDArray[Any])
    201. 

  201. assert_type(np.cumsum(AR_b), npt.NDArray[np.bool])
    202. 

  202. assert_type(np.cumsum(AR_f4), npt.NDArray[np.float32])
    203. 

  203. assert_type(np.cumsum(f, dtype=float), npt.NDArray[Any])
    204. 

  204. assert_type(np.cumsum(f, dtype=np.float64), npt.NDArray[np.float64])
    205. 

  205. assert_type(np.cumsum(AR_f4, out=AR_subclass), NDArraySubclass)
    206. 

  206. 

  207. assert_type(np.cumulative_sum(b), npt.NDArray[np.bool])
    208. 

  208. assert_type(np.cumulative_sum(f4), npt.NDArray[np.float32])
    209. 

  209. assert_type(np.cumulative_sum(f), npt.NDArray[Any])
    210. 

  210. assert_type(np.cumulative_sum(AR_b), npt.NDArray[np.bool])
    211. 

  211. assert_type(np.cumulative_sum(AR_f4), npt.NDArray[np.float32])
    212. 

  212. assert_type(np.cumulative_sum(f, dtype=float), npt.NDArray[Any])
    213. 

  213. assert_type(np.cumulative_sum(f, dtype=np.float64), npt.NDArray[np.float64])
    214. 

  214. assert_type(np.cumulative_sum(AR_f4, out=AR_subclass), NDArraySubclass)
    215. 

  215. 

  216. assert_type(np.ptp(b), np.bool)
    217. 

  217. assert_type(np.ptp(f4), np.float32)
    218. 

  218. assert_type(np.ptp(f), Any)
    219. 

  219. assert_type(np.ptp(AR_b), np.bool)
    220. 

  220. assert_type(np.ptp(AR_f4), np.float32)
    221. 

  221. assert_type(np.ptp(AR_b, axis=0), Any)
    222. 

  222. assert_type(np.ptp(AR_f4, axis=0), Any)
    223. 

  223. assert_type(np.ptp(AR_b, keepdims=True), Any)
    224. 

  224. assert_type(np.ptp(AR_f4, keepdims=True), Any)
    225. 

  225. assert_type(np.ptp(AR_f4, out=AR_subclass), NDArraySubclass)
    226. 

  226. 

  227. assert_type(np.amax(b), np.bool)
    228. 

  228. assert_type(np.amax(f4), np.float32)
    229. 

  229. assert_type(np.amax(f), Any)
    230. 

  230. assert_type(np.amax(AR_b), np.bool)
    231. 

  231. assert_type(np.amax(AR_f4), np.float32)
    232. 

  232. assert_type(np.amax(AR_b, axis=0), Any)
    233. 

  233. assert_type(np.amax(AR_f4, axis=0), Any)
    234. 

  234. assert_type(np.amax(AR_b, keepdims=True), Any)
    235. 

  235. assert_type(np.amax(AR_f4, keepdims=True), Any)
    236. 

  236. assert_type(np.amax(AR_f4, out=AR_subclass), NDArraySubclass)
    237. 

  237. 

  238. assert_type(np.amin(b), np.bool)
    239. 

  239. assert_type(np.amin(f4), np.float32)
    240. 

  240. assert_type(np.amin(f), Any)
    241. 

  241. assert_type(np.amin(AR_b), np.bool)
    242. 

  242. assert_type(np.amin(AR_f4), np.float32)
    243. 

  243. assert_type(np.amin(AR_b, axis=0), Any)
    244. 

  244. assert_type(np.amin(AR_f4, axis=0), Any)
    245. 

  245. assert_type(np.amin(AR_b, keepdims=True), Any)
    246. 

  246. assert_type(np.amin(AR_f4, keepdims=True), Any)
    247. 

  247. assert_type(np.amin(AR_f4, out=AR_subclass), NDArraySubclass)
    248. 

  248. 

  249. assert_type(np.prod(AR_b), np.int_)
    250. 

  250. assert_type(np.prod(AR_u8), np.uint64)
    251. 

  251. assert_type(np.prod(AR_i8), np.int64)
    252. 

  252. assert_type(np.prod(AR_f4), np.floating[Any])
    253. 

  253. assert_type(np.prod(AR_c16), np.complexfloating[Any, Any])
    254. 

  254. assert_type(np.prod(AR_O), Any)
    255. 

  255. assert_type(np.prod(AR_f4, axis=0), Any)
    256. 

  256. assert_type(np.prod(AR_f4, keepdims=True), Any)
    257. 

  257. assert_type(np.prod(AR_f4, dtype=np.float64), np.float64)
    258. 

  258. assert_type(np.prod(AR_f4, dtype=float), Any)
    259. 

  259. assert_type(np.prod(AR_f4, out=AR_subclass), NDArraySubclass)
    260. 

  260. 

  261. assert_type(np.cumprod(AR_b), npt.NDArray[np.int_])
    262. 

  262. assert_type(np.cumprod(AR_u8), npt.NDArray[np.uint64])
    263. 

  263. assert_type(np.cumprod(AR_i8), npt.NDArray[np.int64])
    264. 

  264. assert_type(np.cumprod(AR_f4), npt.NDArray[np.floating[Any]])
    265. 

  265. assert_type(np.cumprod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
    266. 

  266. assert_type(np.cumprod(AR_O), npt.NDArray[np.object_])
    267. 

  267. assert_type(np.cumprod(AR_f4, axis=0), npt.NDArray[np.floating[Any]])
    268. 

  268. assert_type(np.cumprod(AR_f4, dtype=np.float64), npt.NDArray[np.float64])
    269. 

  269. assert_type(np.cumprod(AR_f4, dtype=float), npt.NDArray[Any])
    270. 

  270. assert_type(np.cumprod(AR_f4, out=AR_subclass), NDArraySubclass)
    271. 

  271. 

  272. assert_type(np.cumulative_prod(AR_b), npt.NDArray[np.int_])
    273. 

  273. assert_type(np.cumulative_prod(AR_u8), npt.NDArray[np.uint64])
    274. 

  274. assert_type(np.cumulative_prod(AR_i8), npt.NDArray[np.int64])
    275. 

  275. assert_type(np.cumulative_prod(AR_f4), npt.NDArray[np.floating[Any]])
    276. 

  276. assert_type(np.cumulative_prod(AR_c16), npt.NDArray[np.complexfloating[Any, Any]])
    277. 

  277. assert_type(np.cumulative_prod(AR_O), npt.NDArray[np.object_])
    278. 

  278. assert_type(np.cumulative_prod(AR_f4, axis=0), npt.NDArray[np.floating[Any]])
    279. 

  279. assert_type(np.cumulative_prod(AR_f4, dtype=np.float64), npt.NDArray[np.float64])
    280. 

  280. assert_type(np.cumulative_prod(AR_f4, dtype=float), npt.NDArray[Any])
    281. 

  281. assert_type(np.cumulative_prod(AR_f4, out=AR_subclass), NDArraySubclass)
    282. 

  282. 

  283. assert_type(np.ndim(b), int)
    284. 

  284. assert_type(np.ndim(f4), int)
    285. 

  285. assert_type(np.ndim(f), int)
    286. 

  286. assert_type(np.ndim(AR_b), int)
    287. 

  287. assert_type(np.ndim(AR_f4), int)
    288. 

  288. 

  289. assert_type(np.size(b), int)
    290. 

  290. assert_type(np.size(f4), int)
    291. 

  291. assert_type(np.size(f), int)
    292. 

  292. assert_type(np.size(AR_b), int)
    293. 

  293. assert_type(np.size(AR_f4), int)
    294. 

  294. 

  295. assert_type(np.around(b), np.float16)
    296. 

  296. assert_type(np.around(f), Any)
    297. 

  297. assert_type(np.around(i8), np.int64)
    298. 

  298. assert_type(np.around(f4), np.float32)
    299. 

  299. assert_type(np.around(AR_b), npt.NDArray[np.float16])
    300. 

  300. assert_type(np.around(AR_i8), npt.NDArray[np.int64])
    301. 

  301. assert_type(np.around(AR_f4), npt.NDArray[np.float32])
    302. 

  302. assert_type(np.around([1.5]), npt.NDArray[Any])
    303. 

  303. assert_type(np.around(AR_f4, out=AR_subclass), NDArraySubclass)
    304. 

  304. 

  305. assert_type(np.mean(AR_b), np.floating[Any])
    306. 

  306. assert_type(np.mean(AR_i8), np.floating[Any])
    307. 

  307. assert_type(np.mean(AR_f4), np.floating[Any])
    308. 

  308. assert_type(np.mean(AR_m), np.timedelta64)
    309. 

  309. assert_type(np.mean(AR_c16), np.complexfloating[Any, Any])
    310. 

  310. assert_type(np.mean(AR_O), Any)
    311. 

  311. assert_type(np.mean(AR_f4, axis=0), Any)
    312. 

  312. assert_type(np.mean(AR_f4, keepdims=True), Any)
    313. 

  313. assert_type(np.mean(AR_f4, dtype=float), Any)
    314. 

  314. assert_type(np.mean(AR_f4, dtype=np.float64), np.float64)
    315. 

  315. assert_type(np.mean(AR_f4, out=AR_subclass), NDArraySubclass)
    316. 

  316. assert_type(np.mean(AR_f4, dtype=np.float64), np.float64)
    317. 

  317. assert_type(np.mean(AR_f4, None, np.float64), np.float64)
    318. 

  318. assert_type(np.mean(AR_f4, dtype=np.float64, keepdims=False), np.float64)
    319. 

  319. assert_type(np.mean(AR_f4, None, np.float64, keepdims=False), np.float64)
    320. 

  320. assert_type(np.mean(AR_f4, dtype=np.float64, keepdims=True), np.float64 | npt.NDArray[np.float64])
    321. 

  321. assert_type(np.mean(AR_f4, None, np.float64, keepdims=True), np.float64 | npt.NDArray[np.float64])
    322. 

  322. 

  323. assert_type(np.std(AR_b), np.floating[Any])
    324. 

  324. assert_type(np.std(AR_i8), np.floating[Any])
    325. 

  325. assert_type(np.std(AR_f4), np.floating[Any])
    326. 

  326. assert_type(np.std(AR_c16), np.floating[Any])
    327. 

  327. assert_type(np.std(AR_O), Any)
    328. 

  328. assert_type(np.std(AR_f4, axis=0), Any)
    329. 

  329. assert_type(np.std(AR_f4, keepdims=True), Any)
    330. 

  330. assert_type(np.std(AR_f4, dtype=float), Any)
    331. 

  331. assert_type(np.std(AR_f4, dtype=np.float64), np.float64)
    332. 

  332. assert_type(np.std(AR_f4, out=AR_subclass), NDArraySubclass)
    333. 

  333. 

  334. assert_type(np.var(AR_b), np.floating[Any])
    335. 

  335. assert_type(np.var(AR_i8), np.floating[Any])
    336. 

  336. assert_type(np.var(AR_f4), np.floating[Any])
    337. 

  337. assert_type(np.var(AR_c16), np.floating[Any])
    338. 

  338. assert_type(np.var(AR_O), Any)
    339. 

  339. assert_type(np.var(AR_f4, axis=0), Any)
    340. 

  340. assert_type(np.var(AR_f4, keepdims=True), Any)
    341. 

  341. assert_type(np.var(AR_f4, dtype=float), Any)
    342. 

  342. assert_type(np.var(AR_f4, dtype=np.float64), np.float64)
    343. 

  343. assert_type(np.var(AR_f4, out=AR_subclass), NDArraySubclass)
    344.