Эхлэл Бүгдийг харах Тусламж
Нэвтрэх
SRI-DYZBC2
/
Vehicle-cpp
2
0
Салаа 0
Файлууд Асуудлууд 0 Хуулах хүсэлтүүд 0 Мэдлэгийн сан
Салаа: master
Салаанууд Тагууд
Vehicle-cpp
/
hkpc
/
software
/
numpy
/
typing
/
tests
/
data
/
reveal
/
fromnumeric.pyi

fromnumeric.pyi 13 KB
Байнгын холболт Түүх Анхны өгөгдөл

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297 
  1. """Tests for :mod:`core.fromnumeric`."""
    2. 

  2. 

  3. import numpy as np
    4. 

  4. import numpy.typing as npt
    5. 

  5. 

  6. class NDArraySubclass(npt.NDArray[np.complex128]):
    7. 

  7.     ...
    8. 

  8. 

  9. AR_b: npt.NDArray[np.bool_]
    10. 

  10. AR_f4: npt.NDArray[np.float32]
    11. 

  11. AR_c16: npt.NDArray[np.complex128]
    12. 

  12. AR_u8: npt.NDArray[np.uint64]
    13. 

  13. AR_i8: npt.NDArray[np.int64]
    14. 

  14. AR_O: npt.NDArray[np.object_]
    15. 

  15. AR_subclass: NDArraySubclass
    16. 

  16. 

  17. b: np.bool_
    18. 

  18. f4: np.float32
    19. 

  19. i8: np.int64
    20. 

  20. f: float
    21. 

  21. 

  22. reveal_type(np.take(b, 0))  # E: bool_
    23. 

  23. reveal_type(np.take(f4, 0))  # E: {float32}
    24. 

  24. reveal_type(np.take(f, 0))  # E: Any
    25. 

  25. reveal_type(np.take(AR_b, 0))  # E: bool_
    26. 

  26. reveal_type(np.take(AR_f4, 0))  # E: {float32}
    27. 

  27. reveal_type(np.take(AR_b, [0]))  # E: ndarray[Any, dtype[bool_]]
    28. 

  28. reveal_type(np.take(AR_f4, [0]))  # E: ndarray[Any, dtype[{float32}]]
    29. 

  29. reveal_type(np.take([1], [0]))  # E: ndarray[Any, dtype[Any]]
    30. 

  30. reveal_type(np.take(AR_f4, [0], out=AR_subclass))  # E: NDArraySubclass
    31. 

  31. 

  32. reveal_type(np.reshape(b, 1))  # E: ndarray[Any, dtype[bool_]]
    33. 

  33. reveal_type(np.reshape(f4, 1))  # E: ndarray[Any, dtype[{float32}]]
    34. 

  34. reveal_type(np.reshape(f, 1))  # E: ndarray[Any, dtype[Any]]
    35. 

  35. reveal_type(np.reshape(AR_b, 1))  # E: ndarray[Any, dtype[bool_]]
    36. 

  36. reveal_type(np.reshape(AR_f4, 1))  # E: ndarray[Any, dtype[{float32}]]
    37. 

  37. 

  38. reveal_type(np.choose(1, [True, True]))  # E: Any
    39. 

  39. reveal_type(np.choose([1], [True, True]))  # E: ndarray[Any, dtype[Any]]
    40. 

  40. reveal_type(np.choose([1], AR_b))  # E: ndarray[Any, dtype[bool_]]
    41. 

  41. reveal_type(np.choose([1], AR_b, out=AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    42. 

  42. 

  43. reveal_type(np.repeat(b, 1))  # E: ndarray[Any, dtype[bool_]]
    44. 

  44. reveal_type(np.repeat(f4, 1))  # E: ndarray[Any, dtype[{float32}]]
    45. 

  45. reveal_type(np.repeat(f, 1))  # E: ndarray[Any, dtype[Any]]
    46. 

  46. reveal_type(np.repeat(AR_b, 1))  # E: ndarray[Any, dtype[bool_]]
    47. 

  47. reveal_type(np.repeat(AR_f4, 1))  # E: ndarray[Any, dtype[{float32}]]
    48. 

  48. 

  49. # TODO: array_bdd tests for np.put()
    50. 

  50. 

  51. reveal_type(np.swapaxes([[0, 1]], 0, 0))  # E: ndarray[Any, dtype[Any]]
    52. 

  52. reveal_type(np.swapaxes(AR_b, 0, 0))  # E: ndarray[Any, dtype[bool_]]
    53. 

  53. reveal_type(np.swapaxes(AR_f4, 0, 0))  # E: ndarray[Any, dtype[{float32}]]
    54. 

  54. 

  55. reveal_type(np.transpose(b))  # E: ndarray[Any, dtype[bool_]]
    56. 

  56. reveal_type(np.transpose(f4))  # E: ndarray[Any, dtype[{float32}]]
    57. 

  57. reveal_type(np.transpose(f))  # E: ndarray[Any, dtype[Any]]
    58. 

  58. reveal_type(np.transpose(AR_b))  # E: ndarray[Any, dtype[bool_]]
    59. 

  59. reveal_type(np.transpose(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    60. 

  60. 

  61. reveal_type(np.partition(b, 0, axis=None))  # E: ndarray[Any, dtype[bool_]]
    62. 

  62. reveal_type(np.partition(f4, 0, axis=None))  # E: ndarray[Any, dtype[{float32}]]
    63. 

  63. reveal_type(np.partition(f, 0, axis=None))  # E: ndarray[Any, dtype[Any]]
    64. 

  64. reveal_type(np.partition(AR_b, 0))  # E: ndarray[Any, dtype[bool_]]
    65. 

  65. reveal_type(np.partition(AR_f4, 0))  # E: ndarray[Any, dtype[{float32}]]
    66. 

  66. 

  67. reveal_type(np.argpartition(b, 0))  # E: ndarray[Any, dtype[{intp}]]
    68. 

  68. reveal_type(np.argpartition(f4, 0))  # E: ndarray[Any, dtype[{intp}]]
    69. 

  69. reveal_type(np.argpartition(f, 0))  # E: ndarray[Any, dtype[{intp}]]
    70. 

  70. reveal_type(np.argpartition(AR_b, 0))  # E: ndarray[Any, dtype[{intp}]]
    71. 

  71. reveal_type(np.argpartition(AR_f4, 0))  # E: ndarray[Any, dtype[{intp}]]
    72. 

  72. 

  73. reveal_type(np.sort([2, 1], 0))  # E: ndarray[Any, dtype[Any]]
    74. 

  74. reveal_type(np.sort(AR_b, 0))  # E: ndarray[Any, dtype[bool_]]
    75. 

  75. reveal_type(np.sort(AR_f4, 0))  # E: ndarray[Any, dtype[{float32}]]
    76. 

  76. 

  77. reveal_type(np.argsort(AR_b, 0))  # E: ndarray[Any, dtype[{intp}]]
    78. 

  78. reveal_type(np.argsort(AR_f4, 0))  # E: ndarray[Any, dtype[{intp}]]
    79. 

  79. 

  80. reveal_type(np.argmax(AR_b))  # E: {intp}
    81. 

  81. reveal_type(np.argmax(AR_f4))  # E: {intp}
    82. 

  82. reveal_type(np.argmax(AR_b, axis=0))  # E: Any
    83. 

  83. reveal_type(np.argmax(AR_f4, axis=0))  # E: Any
    84. 

  84. reveal_type(np.argmax(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    85. 

  85. 

  86. reveal_type(np.argmin(AR_b))  # E: {intp}
    87. 

  87. reveal_type(np.argmin(AR_f4))  # E: {intp}
    88. 

  88. reveal_type(np.argmin(AR_b, axis=0))  # E: Any
    89. 

  89. reveal_type(np.argmin(AR_f4, axis=0))  # E: Any
    90. 

  90. reveal_type(np.argmin(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    91. 

  91. 

  92. reveal_type(np.searchsorted(AR_b[0], 0))  # E: {intp}
    93. 

  93. reveal_type(np.searchsorted(AR_f4[0], 0))  # E: {intp}
    94. 

  94. reveal_type(np.searchsorted(AR_b[0], [0]))  # E: ndarray[Any, dtype[{intp}]]
    95. 

  95. reveal_type(np.searchsorted(AR_f4[0], [0]))  # E: ndarray[Any, dtype[{intp}]]
    96. 

  96. 

  97. reveal_type(np.resize(b, (5, 5)))  # E: ndarray[Any, dtype[bool_]]
    98. 

  98. reveal_type(np.resize(f4, (5, 5)))  # E: ndarray[Any, dtype[{float32}]]
    99. 

  99. reveal_type(np.resize(f, (5, 5)))  # E: ndarray[Any, dtype[Any]]
    100. 

  100. reveal_type(np.resize(AR_b, (5, 5)))  # E: ndarray[Any, dtype[bool_]]
    101. 

  101. reveal_type(np.resize(AR_f4, (5, 5)))  # E: ndarray[Any, dtype[{float32}]]
    102. 

  102. 

  103. reveal_type(np.squeeze(b))  # E: bool_
    104. 

  104. reveal_type(np.squeeze(f4))  # E: {float32}
    105. 

  105. reveal_type(np.squeeze(f))  # E: ndarray[Any, dtype[Any]]
    106. 

  106. reveal_type(np.squeeze(AR_b))  # E: ndarray[Any, dtype[bool_]]
    107. 

  107. reveal_type(np.squeeze(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    108. 

  108. 

  109. reveal_type(np.diagonal(AR_b))  # E: ndarray[Any, dtype[bool_]]
    110. 

  110. reveal_type(np.diagonal(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    111. 

  111. 

  112. reveal_type(np.trace(AR_b))  # E: Any
    113. 

  113. reveal_type(np.trace(AR_f4))  # E: Any
    114. 

  114. reveal_type(np.trace(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    115. 

  115. 

  116. reveal_type(np.ravel(b))  # E: ndarray[Any, dtype[bool_]]
    117. 

  117. reveal_type(np.ravel(f4))  # E: ndarray[Any, dtype[{float32}]]
    118. 

  118. reveal_type(np.ravel(f))  # E: ndarray[Any, dtype[Any]]
    119. 

  119. reveal_type(np.ravel(AR_b))  # E: ndarray[Any, dtype[bool_]]
    120. 

  120. reveal_type(np.ravel(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    121. 

  121. 

  122. reveal_type(np.nonzero(b))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
    123. 

  123. reveal_type(np.nonzero(f4))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
    124. 

  124. reveal_type(np.nonzero(f))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
    125. 

  125. reveal_type(np.nonzero(AR_b))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
    126. 

  126. reveal_type(np.nonzero(AR_f4))  # E: tuple[ndarray[Any, dtype[{intp}]], ...]
    127. 

  127. 

  128. reveal_type(np.shape(b))  # E: tuple[builtins.int, ...]
    129. 

  129. reveal_type(np.shape(f4))  # E: tuple[builtins.int, ...]
    130. 

  130. reveal_type(np.shape(f))  # E: tuple[builtins.int, ...]
    131. 

  131. reveal_type(np.shape(AR_b))  # E: tuple[builtins.int, ...]
    132. 

  132. reveal_type(np.shape(AR_f4))  # E: tuple[builtins.int, ...]
    133. 

  133. 

  134. reveal_type(np.compress([True], b))  # E: ndarray[Any, dtype[bool_]]
    135. 

  135. reveal_type(np.compress([True], f4))  # E: ndarray[Any, dtype[{float32}]]
    136. 

  136. reveal_type(np.compress([True], f))  # E: ndarray[Any, dtype[Any]]
    137. 

  137. reveal_type(np.compress([True], AR_b))  # E: ndarray[Any, dtype[bool_]]
    138. 

  138. reveal_type(np.compress([True], AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    139. 

  139. 

  140. reveal_type(np.clip(b, 0, 1.0))  # E: bool_
    141. 

  141. reveal_type(np.clip(f4, -1, 1))  # E: {float32}
    142. 

  142. reveal_type(np.clip(f, 0, 1))  # E: Any
    143. 

  143. reveal_type(np.clip(AR_b, 0, 1))  # E: ndarray[Any, dtype[bool_]]
    144. 

  144. reveal_type(np.clip(AR_f4, 0, 1))  # E: ndarray[Any, dtype[{float32}]]
    145. 

  145. reveal_type(np.clip([0], 0, 1))  # E: ndarray[Any, dtype[Any]]
    146. 

  146. reveal_type(np.clip(AR_b, 0, 1, out=AR_subclass))  # E: NDArraySubclass
    147. 

  147. 

  148. reveal_type(np.sum(b))  # E: bool_
    149. 

  149. reveal_type(np.sum(f4))  # E: {float32}
    150. 

  150. reveal_type(np.sum(f))  # E: Any
    151. 

  151. reveal_type(np.sum(AR_b))  # E: bool_
    152. 

  152. reveal_type(np.sum(AR_f4))  # E: {float32}
    153. 

  153. reveal_type(np.sum(AR_b, axis=0))  # E: Any
    154. 

  154. reveal_type(np.sum(AR_f4, axis=0))  # E: Any
    155. 

  155. reveal_type(np.sum(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    156. 

  156. 

  157. reveal_type(np.all(b))  # E: bool_
    158. 

  158. reveal_type(np.all(f4))  # E: bool_
    159. 

  159. reveal_type(np.all(f))  # E: bool_
    160. 

  160. reveal_type(np.all(AR_b))  # E: bool_
    161. 

  161. reveal_type(np.all(AR_f4))  # E: bool_
    162. 

  162. reveal_type(np.all(AR_b, axis=0))  # E: Any
    163. 

  163. reveal_type(np.all(AR_f4, axis=0))  # E: Any
    164. 

  164. reveal_type(np.all(AR_b, keepdims=True))  # E: Any
    165. 

  165. reveal_type(np.all(AR_f4, keepdims=True))  # E: Any
    166. 

  166. reveal_type(np.all(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    167. 

  167. 

  168. reveal_type(np.any(b))  # E: bool_
    169. 

  169. reveal_type(np.any(f4))  # E: bool_
    170. 

  170. reveal_type(np.any(f))  # E: bool_
    171. 

  171. reveal_type(np.any(AR_b))  # E: bool_
    172. 

  172. reveal_type(np.any(AR_f4))  # E: bool_
    173. 

  173. reveal_type(np.any(AR_b, axis=0))  # E: Any
    174. 

  174. reveal_type(np.any(AR_f4, axis=0))  # E: Any
    175. 

  175. reveal_type(np.any(AR_b, keepdims=True))  # E: Any
    176. 

  176. reveal_type(np.any(AR_f4, keepdims=True))  # E: Any
    177. 

  177. reveal_type(np.any(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    178. 

  178. 

  179. reveal_type(np.cumsum(b))  # E: ndarray[Any, dtype[bool_]]
    180. 

  180. reveal_type(np.cumsum(f4))  # E: ndarray[Any, dtype[{float32}]]
    181. 

  181. reveal_type(np.cumsum(f))  # E: ndarray[Any, dtype[Any]]
    182. 

  182. reveal_type(np.cumsum(AR_b))  # E: ndarray[Any, dtype[bool_]]
    183. 

  183. reveal_type(np.cumsum(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    184. 

  184. reveal_type(np.cumsum(f, dtype=float))  # E: ndarray[Any, dtype[Any]]
    185. 

  185. reveal_type(np.cumsum(f, dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
    186. 

  186. reveal_type(np.cumsum(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    187. 

  187. 

  188. reveal_type(np.ptp(b))  # E: bool_
    189. 

  189. reveal_type(np.ptp(f4))  # E: {float32}
    190. 

  190. reveal_type(np.ptp(f))  # E: Any
    191. 

  191. reveal_type(np.ptp(AR_b))  # E: bool_
    192. 

  192. reveal_type(np.ptp(AR_f4))  # E: {float32}
    193. 

  193. reveal_type(np.ptp(AR_b, axis=0))  # E: Any
    194. 

  194. reveal_type(np.ptp(AR_f4, axis=0))  # E: Any
    195. 

  195. reveal_type(np.ptp(AR_b, keepdims=True))  # E: Any
    196. 

  196. reveal_type(np.ptp(AR_f4, keepdims=True))  # E: Any
    197. 

  197. reveal_type(np.ptp(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    198. 

  198. 

  199. reveal_type(np.amax(b))  # E: bool_
    200. 

  200. reveal_type(np.amax(f4))  # E: {float32}
    201. 

  201. reveal_type(np.amax(f))  # E: Any
    202. 

  202. reveal_type(np.amax(AR_b))  # E: bool_
    203. 

  203. reveal_type(np.amax(AR_f4))  # E: {float32}
    204. 

  204. reveal_type(np.amax(AR_b, axis=0))  # E: Any
    205. 

  205. reveal_type(np.amax(AR_f4, axis=0))  # E: Any
    206. 

  206. reveal_type(np.amax(AR_b, keepdims=True))  # E: Any
    207. 

  207. reveal_type(np.amax(AR_f4, keepdims=True))  # E: Any
    208. 

  208. reveal_type(np.amax(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    209. 

  209. 

  210. reveal_type(np.amin(b))  # E: bool_
    211. 

  211. reveal_type(np.amin(f4))  # E: {float32}
    212. 

  212. reveal_type(np.amin(f))  # E: Any
    213. 

  213. reveal_type(np.amin(AR_b))  # E: bool_
    214. 

  214. reveal_type(np.amin(AR_f4))  # E: {float32}
    215. 

  215. reveal_type(np.amin(AR_b, axis=0))  # E: Any
    216. 

  216. reveal_type(np.amin(AR_f4, axis=0))  # E: Any
    217. 

  217. reveal_type(np.amin(AR_b, keepdims=True))  # E: Any
    218. 

  218. reveal_type(np.amin(AR_f4, keepdims=True))  # E: Any
    219. 

  219. reveal_type(np.amin(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    220. 

  220. 

  221. reveal_type(np.prod(AR_b))  # E: {int_}
    222. 

  222. reveal_type(np.prod(AR_u8))  # E: {uint64}
    223. 

  223. reveal_type(np.prod(AR_i8))  # E: {int64}
    224. 

  224. reveal_type(np.prod(AR_f4))  # E: floating[Any]
    225. 

  225. reveal_type(np.prod(AR_c16))  # E: complexfloating[Any, Any]
    226. 

  226. reveal_type(np.prod(AR_O))  # E: Any
    227. 

  227. reveal_type(np.prod(AR_f4, axis=0))  # E: Any
    228. 

  228. reveal_type(np.prod(AR_f4, keepdims=True))  # E: Any
    229. 

  229. reveal_type(np.prod(AR_f4, dtype=np.float64))  # E: {float64}
    230. 

  230. reveal_type(np.prod(AR_f4, dtype=float))  # E: Any
    231. 

  231. reveal_type(np.prod(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    232. 

  232. 

  233. reveal_type(np.cumprod(AR_b))  # E: ndarray[Any, dtype[{int_}]]
    234. 

  234. reveal_type(np.cumprod(AR_u8))  # E: ndarray[Any, dtype[{uint64}]]
    235. 

  235. reveal_type(np.cumprod(AR_i8))  # E: ndarray[Any, dtype[{int64}]]
    236. 

  236. reveal_type(np.cumprod(AR_f4))  # E: ndarray[Any, dtype[floating[Any]]]
    237. 

  237. reveal_type(np.cumprod(AR_c16))  # E: ndarray[Any, dtype[complexfloating[Any, Any]]]
    238. 

  238. reveal_type(np.cumprod(AR_O))  # E: ndarray[Any, dtype[object_]]
    239. 

  239. reveal_type(np.cumprod(AR_f4, axis=0))  # E: ndarray[Any, dtype[floating[Any]]]
    240. 

  240. reveal_type(np.cumprod(AR_f4, dtype=np.float64))  # E: ndarray[Any, dtype[{float64}]]
    241. 

  241. reveal_type(np.cumprod(AR_f4, dtype=float))  # E: ndarray[Any, dtype[Any]]
    242. 

  242. reveal_type(np.cumprod(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    243. 

  243. 

  244. reveal_type(np.ndim(b))  # E: int
    245. 

  245. reveal_type(np.ndim(f4))  # E: int
    246. 

  246. reveal_type(np.ndim(f))  # E: int
    247. 

  247. reveal_type(np.ndim(AR_b))  # E: int
    248. 

  248. reveal_type(np.ndim(AR_f4))  # E: int
    249. 

  249. 

  250. reveal_type(np.size(b))  # E: int
    251. 

  251. reveal_type(np.size(f4))  # E: int
    252. 

  252. reveal_type(np.size(f))  # E: int
    253. 

  253. reveal_type(np.size(AR_b))  # E: int
    254. 

  254. reveal_type(np.size(AR_f4))  # E: int
    255. 

  255. 

  256. reveal_type(np.around(b))  # E: {float16}
    257. 

  257. reveal_type(np.around(f))  # E: Any
    258. 

  258. reveal_type(np.around(i8))  # E: {int64}
    259. 

  259. reveal_type(np.around(f4))  # E: {float32}
    260. 

  260. reveal_type(np.around(AR_b))  # E: ndarray[Any, dtype[{float16}]]
    261. 

  261. reveal_type(np.around(AR_i8))  # E: ndarray[Any, dtype[{int64}]]
    262. 

  262. reveal_type(np.around(AR_f4))  # E: ndarray[Any, dtype[{float32}]]
    263. 

  263. reveal_type(np.around([1.5]))  # E: ndarray[Any, dtype[Any]]
    264. 

  264. reveal_type(np.around(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    265. 

  265. 

  266. reveal_type(np.mean(AR_b))  # E: floating[Any]
    267. 

  267. reveal_type(np.mean(AR_i8))  # E: floating[Any]
    268. 

  268. reveal_type(np.mean(AR_f4))  # E: floating[Any]
    269. 

  269. reveal_type(np.mean(AR_c16))  # E: complexfloating[Any, Any]
    270. 

  270. reveal_type(np.mean(AR_O))  # E: Any
    271. 

  271. reveal_type(np.mean(AR_f4, axis=0))  # E: Any
    272. 

  272. reveal_type(np.mean(AR_f4, keepdims=True))  # E: Any
    273. 

  273. reveal_type(np.mean(AR_f4, dtype=float))  # E: Any
    274. 

  274. reveal_type(np.mean(AR_f4, dtype=np.float64))  # E: {float64}
    275. 

  275. reveal_type(np.mean(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    276. 

  276. 

  277. reveal_type(np.std(AR_b))  # E: floating[Any]
    278. 

  278. reveal_type(np.std(AR_i8))  # E: floating[Any]
    279. 

  279. reveal_type(np.std(AR_f4))  # E: floating[Any]
    280. 

  280. reveal_type(np.std(AR_c16))  # E: floating[Any]
    281. 

  281. reveal_type(np.std(AR_O))  # E: Any
    282. 

  282. reveal_type(np.std(AR_f4, axis=0))  # E: Any
    283. 

  283. reveal_type(np.std(AR_f4, keepdims=True))  # E: Any
    284. 

  284. reveal_type(np.std(AR_f4, dtype=float))  # E: Any
    285. 

  285. reveal_type(np.std(AR_f4, dtype=np.float64))  # E: {float64}
    286. 

  286. reveal_type(np.std(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    287. 

  287. 

  288. reveal_type(np.var(AR_b))  # E: floating[Any]
    289. 

  289. reveal_type(np.var(AR_i8))  # E: floating[Any]
    290. 

  290. reveal_type(np.var(AR_f4))  # E: floating[Any]
    291. 

  291. reveal_type(np.var(AR_c16))  # E: floating[Any]
    292. 

  292. reveal_type(np.var(AR_O))  # E: Any
    293. 

  293. reveal_type(np.var(AR_f4, axis=0))  # E: Any
    294. 

  294. reveal_type(np.var(AR_f4, keepdims=True))  # E: Any
    295. 

  295. reveal_type(np.var(AR_f4, dtype=float))  # E: Any
    296. 

  296. reveal_type(np.var(AR_f4, dtype=np.float64))  # E: {float64}
    297. 

  297. reveal_type(np.var(AR_f4, out=AR_subclass))  # E: NDArraySubclass
    298.