numpy 2.5.2__cp315-cp315-win32.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (942) hide show
  1. numpy/__config__.py +170 -0
  2. numpy/__config__.pyi +108 -0
  3. numpy/__init__.cython-30.pxd +1312 -0
  4. numpy/__init__.pxd +12 -0
  5. numpy/__init__.py +926 -0
  6. numpy/__init__.pyi +7691 -0
  7. numpy/_array_api_info.py +349 -0
  8. numpy/_array_api_info.pyi +177 -0
  9. numpy/_configtool.py +39 -0
  10. numpy/_configtool.pyi +1 -0
  11. numpy/_core/__init__.py +203 -0
  12. numpy/_core/__init__.pyi +666 -0
  13. numpy/_core/_add_newdocs.py +7131 -0
  14. numpy/_core/_add_newdocs.pyi +2 -0
  15. numpy/_core/_add_newdocs_scalars.py +381 -0
  16. numpy/_core/_add_newdocs_scalars.pyi +16 -0
  17. numpy/_core/_asarray.py +130 -0
  18. numpy/_core/_asarray.pyi +41 -0
  19. numpy/_core/_dtype.py +366 -0
  20. numpy/_core/_dtype.pyi +54 -0
  21. numpy/_core/_dtype_ctypes.py +120 -0
  22. numpy/_core/_dtype_ctypes.pyi +83 -0
  23. numpy/_core/_exceptions.py +162 -0
  24. numpy/_core/_exceptions.pyi +48 -0
  25. numpy/_core/_internal.py +964 -0
  26. numpy/_core/_internal.pyi +56 -0
  27. numpy/_core/_methods.py +252 -0
  28. numpy/_core/_methods.pyi +22 -0
  29. numpy/_core/_multiarray_tests.cp315-win32.lib +0 -0
  30. numpy/_core/_multiarray_tests.cp315-win32.pyd +0 -0
  31. numpy/_core/_multiarray_umath.cp315-win32.lib +0 -0
  32. numpy/_core/_multiarray_umath.cp315-win32.pyd +0 -0
  33. numpy/_core/_operand_flag_tests.cp315-win32.lib +0 -0
  34. numpy/_core/_operand_flag_tests.cp315-win32.pyd +0 -0
  35. numpy/_core/_rational_tests.cp315-win32.lib +0 -0
  36. numpy/_core/_rational_tests.cp315-win32.pyd +0 -0
  37. numpy/_core/_simd.cp315-win32.lib +0 -0
  38. numpy/_core/_simd.cp315-win32.pyd +0 -0
  39. numpy/_core/_simd.pyi +35 -0
  40. numpy/_core/_string_helpers.py +100 -0
  41. numpy/_core/_string_helpers.pyi +12 -0
  42. numpy/_core/_struct_ufunc_tests.cp315-win32.lib +0 -0
  43. numpy/_core/_struct_ufunc_tests.cp315-win32.pyd +0 -0
  44. numpy/_core/_type_aliases.py +130 -0
  45. numpy/_core/_type_aliases.pyi +86 -0
  46. numpy/_core/_ufunc_config.py +515 -0
  47. numpy/_core/_ufunc_config.pyi +67 -0
  48. numpy/_core/_umath_tests.cp315-win32.lib +0 -0
  49. numpy/_core/_umath_tests.cp315-win32.pyd +0 -0
  50. numpy/_core/_umath_tests.pyi +51 -0
  51. numpy/_core/arrayprint.py +1788 -0
  52. numpy/_core/arrayprint.pyi +152 -0
  53. numpy/_core/cversions.py +13 -0
  54. numpy/_core/defchararray.py +1429 -0
  55. numpy/_core/defchararray.pyi +778 -0
  56. numpy/_core/einsumfunc.py +1647 -0
  57. numpy/_core/einsumfunc.pyi +179 -0
  58. numpy/_core/fromnumeric.py +4271 -0
  59. numpy/_core/fromnumeric.pyi +3144 -0
  60. numpy/_core/function_base.py +547 -0
  61. numpy/_core/function_base.pyi +444 -0
  62. numpy/_core/getlimits.py +449 -0
  63. numpy/_core/getlimits.pyi +124 -0
  64. numpy/_core/include/numpy/__multiarray_api.c +386 -0
  65. numpy/_core/include/numpy/__multiarray_api.h +1708 -0
  66. numpy/_core/include/numpy/__ufunc_api.c +56 -0
  67. numpy/_core/include/numpy/__ufunc_api.h +357 -0
  68. numpy/_core/include/numpy/_neighborhood_iterator_imp.h +90 -0
  69. numpy/_core/include/numpy/_numpyconfig.h +33 -0
  70. numpy/_core/include/numpy/_public_dtype_api_table.h +86 -0
  71. numpy/_core/include/numpy/arrayobject.h +7 -0
  72. numpy/_core/include/numpy/arrayscalars.h +228 -0
  73. numpy/_core/include/numpy/dtype_api.h +557 -0
  74. numpy/_core/include/numpy/halffloat.h +70 -0
  75. numpy/_core/include/numpy/ndarrayobject.h +288 -0
  76. numpy/_core/include/numpy/ndarraytypes.h +2075 -0
  77. numpy/_core/include/numpy/npy_2_compat.h +430 -0
  78. numpy/_core/include/numpy/npy_2_complexcompat.h +28 -0
  79. numpy/_core/include/numpy/npy_3kcompat.h +374 -0
  80. numpy/_core/include/numpy/npy_common.h +989 -0
  81. numpy/_core/include/numpy/npy_cpu.h +126 -0
  82. numpy/_core/include/numpy/npy_endian.h +79 -0
  83. numpy/_core/include/numpy/npy_math.h +602 -0
  84. numpy/_core/include/numpy/npy_no_deprecated_api.h +20 -0
  85. numpy/_core/include/numpy/npy_os.h +42 -0
  86. numpy/_core/include/numpy/numpyconfig.h +187 -0
  87. numpy/_core/include/numpy/random/LICENSE.txt +21 -0
  88. numpy/_core/include/numpy/random/bitgen.h +20 -0
  89. numpy/_core/include/numpy/random/distributions.h +209 -0
  90. numpy/_core/include/numpy/random/libdivide.h +2079 -0
  91. numpy/_core/include/numpy/ufuncobject.h +368 -0
  92. numpy/_core/include/numpy/utils.h +99 -0
  93. numpy/_core/lib/npymath.lib +0 -0
  94. numpy/_core/lib/pkgconfig/numpy.pc +7 -0
  95. numpy/_core/memmap.py +362 -0
  96. numpy/_core/memmap.pyi +94 -0
  97. numpy/_core/multiarray.py +1743 -0
  98. numpy/_core/multiarray.pyi +1892 -0
  99. numpy/_core/numeric.py +2707 -0
  100. numpy/_core/numeric.pyi +1366 -0
  101. numpy/_core/numerictypes.py +576 -0
  102. numpy/_core/numerictypes.pyi +196 -0
  103. numpy/_core/overrides.py +188 -0
  104. numpy/_core/overrides.pyi +44 -0
  105. numpy/_core/printoptions.py +32 -0
  106. numpy/_core/printoptions.pyi +28 -0
  107. numpy/_core/records.py +1089 -0
  108. numpy/_core/records.pyi +336 -0
  109. numpy/_core/shape_base.py +996 -0
  110. numpy/_core/shape_base.pyi +210 -0
  111. numpy/_core/strings.py +1813 -0
  112. numpy/_core/strings.pyi +481 -0
  113. numpy/_core/tests/_locales.py +72 -0
  114. numpy/_core/tests/_natype.py +144 -0
  115. numpy/_core/tests/data/astype_copy.pkl +0 -0
  116. numpy/_core/tests/data/generate_umath_validation_data.cpp +170 -0
  117. numpy/_core/tests/data/recarray_from_file.fits +0 -0
  118. numpy/_core/tests/data/umath-validation-set-README.txt +15 -0
  119. numpy/_core/tests/data/umath-validation-set-arccos.csv +1429 -0
  120. numpy/_core/tests/data/umath-validation-set-arccosh.csv +1429 -0
  121. numpy/_core/tests/data/umath-validation-set-arcsin.csv +1429 -0
  122. numpy/_core/tests/data/umath-validation-set-arcsinh.csv +1429 -0
  123. numpy/_core/tests/data/umath-validation-set-arctan.csv +1429 -0
  124. numpy/_core/tests/data/umath-validation-set-arctanh.csv +1429 -0
  125. numpy/_core/tests/data/umath-validation-set-cbrt.csv +1429 -0
  126. numpy/_core/tests/data/umath-validation-set-cos.csv +1375 -0
  127. numpy/_core/tests/data/umath-validation-set-cosh.csv +1429 -0
  128. numpy/_core/tests/data/umath-validation-set-exp.csv +412 -0
  129. numpy/_core/tests/data/umath-validation-set-exp2.csv +1429 -0
  130. numpy/_core/tests/data/umath-validation-set-expm1.csv +1429 -0
  131. numpy/_core/tests/data/umath-validation-set-log.csv +271 -0
  132. numpy/_core/tests/data/umath-validation-set-log10.csv +1629 -0
  133. numpy/_core/tests/data/umath-validation-set-log1p.csv +1429 -0
  134. numpy/_core/tests/data/umath-validation-set-log2.csv +1629 -0
  135. numpy/_core/tests/data/umath-validation-set-sin.csv +1370 -0
  136. numpy/_core/tests/data/umath-validation-set-sinh.csv +1429 -0
  137. numpy/_core/tests/data/umath-validation-set-tan.csv +1429 -0
  138. numpy/_core/tests/data/umath-validation-set-tanh.csv +1429 -0
  139. numpy/_core/tests/examples/cython/checks.pyx +381 -0
  140. numpy/_core/tests/examples/cython/meson.build +52 -0
  141. numpy/_core/tests/examples/cython/setup.py +39 -0
  142. numpy/_core/tests/examples/limited_api/limited_api.c +455 -0
  143. numpy/_core/tests/examples/limited_api/limited_api_cython.pyx +155 -0
  144. numpy/_core/tests/examples/limited_api/meson.build +94 -0
  145. numpy/_core/tests/examples/limited_api/setup.py +24 -0
  146. numpy/_core/tests/test__exceptions.py +90 -0
  147. numpy/_core/tests/test_abc.py +54 -0
  148. numpy/_core/tests/test_api.py +668 -0
  149. numpy/_core/tests/test_argparse.py +90 -0
  150. numpy/_core/tests/test_array_api_info.py +113 -0
  151. numpy/_core/tests/test_array_coercion.py +943 -0
  152. numpy/_core/tests/test_array_interface.py +222 -0
  153. numpy/_core/tests/test_arraymethod.py +85 -0
  154. numpy/_core/tests/test_arrayobject.py +198 -0
  155. numpy/_core/tests/test_arrayprint.py +1363 -0
  156. numpy/_core/tests/test_casting_floatingpoint_errors.py +154 -0
  157. numpy/_core/tests/test_casting_unittests.py +970 -0
  158. numpy/_core/tests/test_conversion_utils.py +209 -0
  159. numpy/_core/tests/test_cpu_dispatcher.py +48 -0
  160. numpy/_core/tests/test_cpu_features.py +533 -0
  161. numpy/_core/tests/test_custom_dtypes.py +511 -0
  162. numpy/_core/tests/test_cython.py +377 -0
  163. numpy/_core/tests/test_datetime.py +3220 -0
  164. numpy/_core/tests/test_defchararray.py +879 -0
  165. numpy/_core/tests/test_deprecations.py +511 -0
  166. numpy/_core/tests/test_dlpack.py +262 -0
  167. numpy/_core/tests/test_dtype.py +2107 -0
  168. numpy/_core/tests/test_einsum.py +1368 -0
  169. numpy/_core/tests/test_errstate.py +131 -0
  170. numpy/_core/tests/test_extint128.py +217 -0
  171. numpy/_core/tests/test_finfo.py +86 -0
  172. numpy/_core/tests/test_function_base.py +502 -0
  173. numpy/_core/tests/test_getlimits.py +188 -0
  174. numpy/_core/tests/test_half.py +589 -0
  175. numpy/_core/tests/test_hashtable.py +156 -0
  176. numpy/_core/tests/test_indexerrors.py +122 -0
  177. numpy/_core/tests/test_indexing.py +1717 -0
  178. numpy/_core/tests/test_item_selection.py +178 -0
  179. numpy/_core/tests/test_limited_api.py +254 -0
  180. numpy/_core/tests/test_longdouble.py +370 -0
  181. numpy/_core/tests/test_mem_overlap.py +933 -0
  182. numpy/_core/tests/test_mem_policy.py +448 -0
  183. numpy/_core/tests/test_memmap.py +286 -0
  184. numpy/_core/tests/test_multiarray.py +11569 -0
  185. numpy/_core/tests/test_multiprocessing.py +55 -0
  186. numpy/_core/tests/test_multithreading.py +746 -0
  187. numpy/_core/tests/test_nditer.py +3690 -0
  188. numpy/_core/tests/test_nep50_promotions.py +287 -0
  189. numpy/_core/tests/test_numeric.py +4278 -0
  190. numpy/_core/tests/test_numerictypes.py +640 -0
  191. numpy/_core/tests/test_overrides.py +800 -0
  192. numpy/_core/tests/test_print.py +202 -0
  193. numpy/_core/tests/test_protocols.py +46 -0
  194. numpy/_core/tests/test_records.py +595 -0
  195. numpy/_core/tests/test_regression.py +2672 -0
  196. numpy/_core/tests/test_scalar_ctors.py +203 -0
  197. numpy/_core/tests/test_scalar_methods.py +327 -0
  198. numpy/_core/tests/test_scalarbuffer.py +154 -0
  199. numpy/_core/tests/test_scalarinherit.py +105 -0
  200. numpy/_core/tests/test_scalarmath.py +1167 -0
  201. numpy/_core/tests/test_scalarprint.py +403 -0
  202. numpy/_core/tests/test_shape_base.py +899 -0
  203. numpy/_core/tests/test_simd.py +1345 -0
  204. numpy/_core/tests/test_simd_module.py +105 -0
  205. numpy/_core/tests/test_stringdtype.py +2573 -0
  206. numpy/_core/tests/test_strings.py +1506 -0
  207. numpy/_core/tests/test_ufunc.py +3452 -0
  208. numpy/_core/tests/test_umath.py +5231 -0
  209. numpy/_core/tests/test_umath_accuracy.py +92 -0
  210. numpy/_core/tests/test_umath_complex.py +631 -0
  211. numpy/_core/tests/test_unicode.py +369 -0
  212. numpy/_core/umath.py +59 -0
  213. numpy/_core/umath.pyi +232 -0
  214. numpy/_distributor_init.py +15 -0
  215. numpy/_distributor_init.pyi +1 -0
  216. numpy/_expired_attrs_2_0.py +78 -0
  217. numpy/_expired_attrs_2_0.pyi +61 -0
  218. numpy/_globals.py +121 -0
  219. numpy/_globals.pyi +17 -0
  220. numpy/_pyinstaller/__init__.py +0 -0
  221. numpy/_pyinstaller/__init__.pyi +0 -0
  222. numpy/_pyinstaller/hook-numpy.py +35 -0
  223. numpy/_pyinstaller/hook-numpy.pyi +6 -0
  224. numpy/_pyinstaller/tests/__init__.py +16 -0
  225. numpy/_pyinstaller/tests/pyinstaller-smoke.py +32 -0
  226. numpy/_pyinstaller/tests/test_pyinstaller.py +35 -0
  227. numpy/_pytesttester.py +186 -0
  228. numpy/_pytesttester.pyi +18 -0
  229. numpy/_typing/__init__.py +147 -0
  230. numpy/_typing/_add_docstring.py +153 -0
  231. numpy/_typing/_array_like.py +92 -0
  232. numpy/_typing/_char_codes.py +156 -0
  233. numpy/_typing/_dtype_like.py +108 -0
  234. numpy/_typing/_extended_precision.py +15 -0
  235. numpy/_typing/_nbit.py +17 -0
  236. numpy/_typing/_nbit_base.py +93 -0
  237. numpy/_typing/_nbit_base.pyi +39 -0
  238. numpy/_typing/_nested_sequence.py +85 -0
  239. numpy/_typing/_scalars.py +20 -0
  240. numpy/_typing/_shape.py +8 -0
  241. numpy/_typing/_ufunc.py +7 -0
  242. numpy/_typing/_ufunc.pyi +970 -0
  243. numpy/_utils/__init__.py +95 -0
  244. numpy/_utils/__init__.pyi +25 -0
  245. numpy/_utils/_conversions.py +18 -0
  246. numpy/_utils/_conversions.pyi +4 -0
  247. numpy/_utils/_inspect.py +192 -0
  248. numpy/_utils/_inspect.pyi +67 -0
  249. numpy/_utils/_pep440.py +486 -0
  250. numpy/_utils/_pep440.pyi +121 -0
  251. numpy/char/__init__.py +31 -0
  252. numpy/char/__init__.pyi +111 -0
  253. numpy/conftest.py +249 -0
  254. numpy/core/__init__.py +33 -0
  255. numpy/core/__init__.pyi +45 -0
  256. numpy/core/_dtype.py +10 -0
  257. numpy/core/_dtype.pyi +0 -0
  258. numpy/core/_dtype_ctypes.py +10 -0
  259. numpy/core/_dtype_ctypes.pyi +0 -0
  260. numpy/core/_internal.py +27 -0
  261. numpy/core/_internal.pyi +1 -0
  262. numpy/core/_multiarray_umath.py +57 -0
  263. numpy/core/_utils.py +21 -0
  264. numpy/core/arrayprint.py +10 -0
  265. numpy/core/arrayprint.pyi +4 -0
  266. numpy/core/defchararray.py +10 -0
  267. numpy/core/defchararray.pyi +4 -0
  268. numpy/core/einsumfunc.py +10 -0
  269. numpy/core/einsumfunc.pyi +4 -0
  270. numpy/core/fromnumeric.py +10 -0
  271. numpy/core/fromnumeric.pyi +4 -0
  272. numpy/core/function_base.py +10 -0
  273. numpy/core/function_base.pyi +4 -0
  274. numpy/core/getlimits.py +10 -0
  275. numpy/core/getlimits.pyi +4 -0
  276. numpy/core/multiarray.py +25 -0
  277. numpy/core/multiarray.pyi +4 -0
  278. numpy/core/numeric.py +12 -0
  279. numpy/core/numeric.pyi +4 -0
  280. numpy/core/numerictypes.py +10 -0
  281. numpy/core/numerictypes.pyi +4 -0
  282. numpy/core/overrides.py +10 -0
  283. numpy/core/overrides.pyi +7 -0
  284. numpy/core/records.py +10 -0
  285. numpy/core/records.pyi +4 -0
  286. numpy/core/shape_base.py +10 -0
  287. numpy/core/shape_base.pyi +4 -0
  288. numpy/core/umath.py +10 -0
  289. numpy/core/umath.pyi +4 -0
  290. numpy/ctypeslib/__init__.py +13 -0
  291. numpy/ctypeslib/__init__.pyi +15 -0
  292. numpy/ctypeslib/_ctypeslib.py +603 -0
  293. numpy/ctypeslib/_ctypeslib.pyi +222 -0
  294. numpy/doc/ufuncs.py +138 -0
  295. numpy/dtypes.py +86 -0
  296. numpy/dtypes.pyi +627 -0
  297. numpy/exceptions.py +246 -0
  298. numpy/exceptions.pyi +27 -0
  299. numpy/f2py/__init__.py +80 -0
  300. numpy/f2py/__init__.pyi +5 -0
  301. numpy/f2py/__main__.py +5 -0
  302. numpy/f2py/__version__.py +1 -0
  303. numpy/f2py/__version__.pyi +1 -0
  304. numpy/f2py/_backends/__init__.py +6 -0
  305. numpy/f2py/_backends/__init__.pyi +5 -0
  306. numpy/f2py/_backends/_backend.py +44 -0
  307. numpy/f2py/_backends/_backend.pyi +46 -0
  308. numpy/f2py/_backends/_meson.py +244 -0
  309. numpy/f2py/_backends/_meson.pyi +61 -0
  310. numpy/f2py/_backends/meson.build.template +63 -0
  311. numpy/f2py/_isocbind.py +62 -0
  312. numpy/f2py/_isocbind.pyi +13 -0
  313. numpy/f2py/_src_pyf.py +247 -0
  314. numpy/f2py/_src_pyf.pyi +28 -0
  315. numpy/f2py/auxfuncs.py +1005 -0
  316. numpy/f2py/auxfuncs.pyi +259 -0
  317. numpy/f2py/capi_maps.py +811 -0
  318. numpy/f2py/capi_maps.pyi +33 -0
  319. numpy/f2py/cb_rules.py +649 -0
  320. numpy/f2py/cb_rules.pyi +17 -0
  321. numpy/f2py/cfuncs.py +1579 -0
  322. numpy/f2py/cfuncs.pyi +31 -0
  323. numpy/f2py/common_rules.py +145 -0
  324. numpy/f2py/common_rules.pyi +9 -0
  325. numpy/f2py/crackfortran.py +3727 -0
  326. numpy/f2py/crackfortran.pyi +254 -0
  327. numpy/f2py/diagnose.py +57 -0
  328. numpy/f2py/diagnose.pyi +1 -0
  329. numpy/f2py/f2py2e.py +755 -0
  330. numpy/f2py/f2py2e.pyi +69 -0
  331. numpy/f2py/f90mod_rules.py +281 -0
  332. numpy/f2py/f90mod_rules.pyi +16 -0
  333. numpy/f2py/func2subr.py +329 -0
  334. numpy/f2py/func2subr.pyi +7 -0
  335. numpy/f2py/rules.py +1641 -0
  336. numpy/f2py/rules.pyi +36 -0
  337. numpy/f2py/setup.cfg +3 -0
  338. numpy/f2py/src/fortranobject.c +1471 -0
  339. numpy/f2py/src/fortranobject.h +173 -0
  340. numpy/f2py/symbolic.py +1518 -0
  341. numpy/f2py/symbolic.pyi +220 -0
  342. numpy/f2py/tests/__init__.py +16 -0
  343. numpy/f2py/tests/src/abstract_interface/foo.f90 +34 -0
  344. numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90 +6 -0
  345. numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c +262 -0
  346. numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap +1 -0
  347. numpy/f2py/tests/src/assumed_shape/foo_free.f90 +34 -0
  348. numpy/f2py/tests/src/assumed_shape/foo_mod.f90 +41 -0
  349. numpy/f2py/tests/src/assumed_shape/foo_use.f90 +19 -0
  350. numpy/f2py/tests/src/assumed_shape/precision.f90 +4 -0
  351. numpy/f2py/tests/src/block_docstring/foo.f +6 -0
  352. numpy/f2py/tests/src/callback/foo.f +62 -0
  353. numpy/f2py/tests/src/callback/gh17797.f90 +7 -0
  354. numpy/f2py/tests/src/callback/gh18335.f90 +17 -0
  355. numpy/f2py/tests/src/callback/gh25211.f +10 -0
  356. numpy/f2py/tests/src/callback/gh25211.pyf +18 -0
  357. numpy/f2py/tests/src/callback/gh26681.f90 +18 -0
  358. numpy/f2py/tests/src/cli/gh_22819.pyf +6 -0
  359. numpy/f2py/tests/src/cli/hi77.f +3 -0
  360. numpy/f2py/tests/src/cli/hiworld.f90 +3 -0
  361. numpy/f2py/tests/src/common/block.f +11 -0
  362. numpy/f2py/tests/src/common/gh19161.f90 +10 -0
  363. numpy/f2py/tests/src/crackfortran/accesstype.f90 +13 -0
  364. numpy/f2py/tests/src/crackfortran/common_with_division.f +17 -0
  365. numpy/f2py/tests/src/crackfortran/data_common.f +8 -0
  366. numpy/f2py/tests/src/crackfortran/data_multiplier.f +5 -0
  367. numpy/f2py/tests/src/crackfortran/data_stmts.f90 +20 -0
  368. numpy/f2py/tests/src/crackfortran/data_with_comments.f +8 -0
  369. numpy/f2py/tests/src/crackfortran/foo_deps.f90 +6 -0
  370. numpy/f2py/tests/src/crackfortran/gh15035.f +16 -0
  371. numpy/f2py/tests/src/crackfortran/gh17859.f +12 -0
  372. numpy/f2py/tests/src/crackfortran/gh22648.pyf +7 -0
  373. numpy/f2py/tests/src/crackfortran/gh23533.f +5 -0
  374. numpy/f2py/tests/src/crackfortran/gh23598.f90 +4 -0
  375. numpy/f2py/tests/src/crackfortran/gh23598Warn.f90 +11 -0
  376. numpy/f2py/tests/src/crackfortran/gh23879.f90 +20 -0
  377. numpy/f2py/tests/src/crackfortran/gh27697.f90 +12 -0
  378. numpy/f2py/tests/src/crackfortran/gh2848.f90 +13 -0
  379. numpy/f2py/tests/src/crackfortran/operators.f90 +49 -0
  380. numpy/f2py/tests/src/crackfortran/privatemod.f90 +11 -0
  381. numpy/f2py/tests/src/crackfortran/publicmod.f90 +10 -0
  382. numpy/f2py/tests/src/crackfortran/pubprivmod.f90 +10 -0
  383. numpy/f2py/tests/src/crackfortran/unicode_comment.f90 +4 -0
  384. numpy/f2py/tests/src/f2cmap/.f2py_f2cmap +1 -0
  385. numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90 +9 -0
  386. numpy/f2py/tests/src/inplace/foo.f +31 -0
  387. numpy/f2py/tests/src/isocintrin/isoCtests.f90 +34 -0
  388. numpy/f2py/tests/src/kind/foo.f90 +20 -0
  389. numpy/f2py/tests/src/mixed/foo.f +5 -0
  390. numpy/f2py/tests/src/mixed/foo_fixed.f90 +8 -0
  391. numpy/f2py/tests/src/mixed/foo_free.f90 +8 -0
  392. numpy/f2py/tests/src/modules/gh25337/data.f90 +8 -0
  393. numpy/f2py/tests/src/modules/gh25337/use_data.f90 +6 -0
  394. numpy/f2py/tests/src/modules/gh26920/two_mods_with_no_public_entities.f90 +21 -0
  395. numpy/f2py/tests/src/modules/gh26920/two_mods_with_one_public_routine.f90 +21 -0
  396. numpy/f2py/tests/src/modules/module_data_docstring.f90 +12 -0
  397. numpy/f2py/tests/src/modules/use_modules.f90 +20 -0
  398. numpy/f2py/tests/src/negative_bounds/issue_20853.f90 +7 -0
  399. numpy/f2py/tests/src/parameter/constant_array.f90 +45 -0
  400. numpy/f2py/tests/src/parameter/constant_both.f90 +57 -0
  401. numpy/f2py/tests/src/parameter/constant_compound.f90 +15 -0
  402. numpy/f2py/tests/src/parameter/constant_integer.f90 +22 -0
  403. numpy/f2py/tests/src/parameter/constant_non_compound.f90 +23 -0
  404. numpy/f2py/tests/src/parameter/constant_real.f90 +23 -0
  405. numpy/f2py/tests/src/quoted_character/foo.f +14 -0
  406. numpy/f2py/tests/src/regression/AB.inc +1 -0
  407. numpy/f2py/tests/src/regression/assignOnlyModule.f90 +25 -0
  408. numpy/f2py/tests/src/regression/complex_struct_compat.f90 +8 -0
  409. numpy/f2py/tests/src/regression/complex_struct_compat.pyf +12 -0
  410. numpy/f2py/tests/src/regression/datonly.f90 +17 -0
  411. numpy/f2py/tests/src/regression/f77comments.f +26 -0
  412. numpy/f2py/tests/src/regression/f77fixedform.f95 +5 -0
  413. numpy/f2py/tests/src/regression/f90continuation.f90 +9 -0
  414. numpy/f2py/tests/src/regression/incfile.f90 +5 -0
  415. numpy/f2py/tests/src/regression/inout.f90 +9 -0
  416. numpy/f2py/tests/src/regression/lower_f2py_fortran.f90 +5 -0
  417. numpy/f2py/tests/src/regression/mod_derived_types.f90 +23 -0
  418. numpy/f2py/tests/src/return_character/foo77.f +45 -0
  419. numpy/f2py/tests/src/return_character/foo90.f90 +48 -0
  420. numpy/f2py/tests/src/return_complex/foo77.f +45 -0
  421. numpy/f2py/tests/src/return_complex/foo90.f90 +48 -0
  422. numpy/f2py/tests/src/return_integer/foo77.f +56 -0
  423. numpy/f2py/tests/src/return_integer/foo90.f90 +59 -0
  424. numpy/f2py/tests/src/return_logical/foo77.f +56 -0
  425. numpy/f2py/tests/src/return_logical/foo90.f90 +59 -0
  426. numpy/f2py/tests/src/return_real/foo77.f +45 -0
  427. numpy/f2py/tests/src/return_real/foo90.f90 +48 -0
  428. numpy/f2py/tests/src/routines/funcfortranname.f +5 -0
  429. numpy/f2py/tests/src/routines/funcfortranname.pyf +11 -0
  430. numpy/f2py/tests/src/routines/subrout.f +4 -0
  431. numpy/f2py/tests/src/routines/subrout.pyf +10 -0
  432. numpy/f2py/tests/src/size/foo.f90 +44 -0
  433. numpy/f2py/tests/src/string/char.f90 +29 -0
  434. numpy/f2py/tests/src/string/fixed_string.f90 +34 -0
  435. numpy/f2py/tests/src/string/gh24008.f +8 -0
  436. numpy/f2py/tests/src/string/gh24662.f90 +7 -0
  437. numpy/f2py/tests/src/string/gh25286.f90 +14 -0
  438. numpy/f2py/tests/src/string/gh25286.pyf +12 -0
  439. numpy/f2py/tests/src/string/gh25286_bc.pyf +12 -0
  440. numpy/f2py/tests/src/string/scalar_string.f90 +9 -0
  441. numpy/f2py/tests/src/string/string.f +12 -0
  442. numpy/f2py/tests/src/value_attrspec/gh21665.f90 +9 -0
  443. numpy/f2py/tests/test_abstract_interface.py +26 -0
  444. numpy/f2py/tests/test_array_from_pyobj.py +732 -0
  445. numpy/f2py/tests/test_assumed_shape.py +52 -0
  446. numpy/f2py/tests/test_block_docstring.py +16 -0
  447. numpy/f2py/tests/test_callback.py +262 -0
  448. numpy/f2py/tests/test_capi_maps.py +10 -0
  449. numpy/f2py/tests/test_character.py +644 -0
  450. numpy/f2py/tests/test_common.py +24 -0
  451. numpy/f2py/tests/test_crackfortran.py +427 -0
  452. numpy/f2py/tests/test_data.py +74 -0
  453. numpy/f2py/tests/test_docs.py +66 -0
  454. numpy/f2py/tests/test_f2cmap.py +20 -0
  455. numpy/f2py/tests/test_f2py2e.py +1006 -0
  456. numpy/f2py/tests/test_inplace.py +49 -0
  457. numpy/f2py/tests/test_isoc.py +56 -0
  458. numpy/f2py/tests/test_kind.py +53 -0
  459. numpy/f2py/tests/test_mixed.py +31 -0
  460. numpy/f2py/tests/test_modules.py +87 -0
  461. numpy/f2py/tests/test_parameter.py +121 -0
  462. numpy/f2py/tests/test_pyf_src.py +43 -0
  463. numpy/f2py/tests/test_quoted_character.py +19 -0
  464. numpy/f2py/tests/test_regression.py +202 -0
  465. numpy/f2py/tests/test_return_character.py +48 -0
  466. numpy/f2py/tests/test_return_complex.py +67 -0
  467. numpy/f2py/tests/test_return_integer.py +55 -0
  468. numpy/f2py/tests/test_return_logical.py +66 -0
  469. numpy/f2py/tests/test_return_real.py +109 -0
  470. numpy/f2py/tests/test_routines.py +29 -0
  471. numpy/f2py/tests/test_semicolon_split.py +76 -0
  472. numpy/f2py/tests/test_size.py +42 -0
  473. numpy/f2py/tests/test_string.py +102 -0
  474. numpy/f2py/tests/test_symbolic.py +501 -0
  475. numpy/f2py/tests/test_value_attrspec.py +15 -0
  476. numpy/f2py/tests/util.py +442 -0
  477. numpy/f2py/use_rules.py +100 -0
  478. numpy/f2py/use_rules.pyi +9 -0
  479. numpy/fft/__init__.py +213 -0
  480. numpy/fft/__init__.pyi +38 -0
  481. numpy/fft/_helper.py +235 -0
  482. numpy/fft/_helper.pyi +145 -0
  483. numpy/fft/_pocketfft.py +1693 -0
  484. numpy/fft/_pocketfft.pyi +1131 -0
  485. numpy/fft/_pocketfft_umath.cp315-win32.lib +0 -0
  486. numpy/fft/_pocketfft_umath.cp315-win32.pyd +0 -0
  487. numpy/fft/tests/__init__.py +0 -0
  488. numpy/fft/tests/test_helper.py +167 -0
  489. numpy/fft/tests/test_pocketfft.py +609 -0
  490. numpy/lib/__init__.py +90 -0
  491. numpy/lib/__init__.pyi +52 -0
  492. numpy/lib/_array_utils_impl.py +62 -0
  493. numpy/lib/_array_utils_impl.pyi +10 -0
  494. numpy/lib/_arraypad_impl.py +926 -0
  495. numpy/lib/_arraypad_impl.pyi +99 -0
  496. numpy/lib/_arraysetops_impl.py +1158 -0
  497. numpy/lib/_arraysetops_impl.pyi +460 -0
  498. numpy/lib/_arrayterator_impl.py +224 -0
  499. numpy/lib/_arrayterator_impl.pyi +45 -0
  500. numpy/lib/_datasource.py +700 -0
  501. numpy/lib/_datasource.pyi +30 -0
  502. numpy/lib/_format_impl.py +1038 -0
  503. numpy/lib/_format_impl.pyi +56 -0
  504. numpy/lib/_function_base_impl.py +5775 -0
  505. numpy/lib/_function_base_impl.pyi +2315 -0
  506. numpy/lib/_histograms_impl.py +1085 -0
  507. numpy/lib/_histograms_impl.pyi +273 -0
  508. numpy/lib/_index_tricks_impl.py +1048 -0
  509. numpy/lib/_index_tricks_impl.pyi +350 -0
  510. numpy/lib/_iotools.py +900 -0
  511. numpy/lib/_iotools.pyi +113 -0
  512. numpy/lib/_nanfunctions_impl.py +2006 -0
  513. numpy/lib/_nanfunctions_impl.pyi +48 -0
  514. numpy/lib/_npyio_impl.py +2491 -0
  515. numpy/lib/_npyio_impl.pyi +288 -0
  516. numpy/lib/_polynomial_impl.py +1467 -0
  517. numpy/lib/_polynomial_impl.pyi +435 -0
  518. numpy/lib/_scimath_impl.py +642 -0
  519. numpy/lib/_scimath_impl.pyi +93 -0
  520. numpy/lib/_shape_base_impl.py +1247 -0
  521. numpy/lib/_shape_base_impl.pyi +256 -0
  522. numpy/lib/_stride_tricks_impl.py +656 -0
  523. numpy/lib/_stride_tricks_impl.pyi +75 -0
  524. numpy/lib/_twodim_base_impl.py +1242 -0
  525. numpy/lib/_twodim_base_impl.pyi +397 -0
  526. numpy/lib/_type_check_impl.py +714 -0
  527. numpy/lib/_type_check_impl.pyi +450 -0
  528. numpy/lib/_ufunclike_impl.py +212 -0
  529. numpy/lib/_ufunclike_impl.pyi +41 -0
  530. numpy/lib/_user_array_impl.py +310 -0
  531. numpy/lib/_user_array_impl.pyi +229 -0
  532. numpy/lib/_utils_impl.py +541 -0
  533. numpy/lib/_utils_impl.pyi +18 -0
  534. numpy/lib/_version.py +153 -0
  535. numpy/lib/_version.pyi +22 -0
  536. numpy/lib/array_utils.py +7 -0
  537. numpy/lib/array_utils.pyi +6 -0
  538. numpy/lib/format.py +24 -0
  539. numpy/lib/format.pyi +24 -0
  540. numpy/lib/introspect.py +94 -0
  541. numpy/lib/introspect.pyi +3 -0
  542. numpy/lib/mixins.py +180 -0
  543. numpy/lib/mixins.pyi +78 -0
  544. numpy/lib/npyio.py +1 -0
  545. numpy/lib/npyio.pyi +5 -0
  546. numpy/lib/recfunctions.py +1681 -0
  547. numpy/lib/recfunctions.pyi +436 -0
  548. numpy/lib/scimath.py +13 -0
  549. numpy/lib/scimath.pyi +12 -0
  550. numpy/lib/stride_tricks.py +1 -0
  551. numpy/lib/stride_tricks.pyi +4 -0
  552. numpy/lib/tests/__init__.py +0 -0
  553. numpy/lib/tests/data/py2-np0-objarr.npy +0 -0
  554. numpy/lib/tests/data/py2-objarr.npy +0 -0
  555. numpy/lib/tests/data/py2-objarr.npz +0 -0
  556. numpy/lib/tests/data/py3-objarr.npy +0 -0
  557. numpy/lib/tests/data/py3-objarr.npz +0 -0
  558. numpy/lib/tests/data/python3.npy +0 -0
  559. numpy/lib/tests/data/win64python2.npy +0 -0
  560. numpy/lib/tests/test__datasource.py +328 -0
  561. numpy/lib/tests/test__iotools.py +358 -0
  562. numpy/lib/tests/test__version.py +64 -0
  563. numpy/lib/tests/test_array_utils.py +32 -0
  564. numpy/lib/tests/test_arraypad.py +1427 -0
  565. numpy/lib/tests/test_arraysetops.py +1304 -0
  566. numpy/lib/tests/test_arrayterator.py +45 -0
  567. numpy/lib/tests/test_format.py +1043 -0
  568. numpy/lib/tests/test_function_base.py +4787 -0
  569. numpy/lib/tests/test_histograms.py +855 -0
  570. numpy/lib/tests/test_index_tricks.py +703 -0
  571. numpy/lib/tests/test_io.py +2733 -0
  572. numpy/lib/tests/test_loadtxt.py +1077 -0
  573. numpy/lib/tests/test_mixins.py +215 -0
  574. numpy/lib/tests/test_nanfunctions.py +1449 -0
  575. numpy/lib/tests/test_packbits.py +374 -0
  576. numpy/lib/tests/test_polynomial.py +333 -0
  577. numpy/lib/tests/test_recfunctions.py +1042 -0
  578. numpy/lib/tests/test_regression.py +231 -0
  579. numpy/lib/tests/test_shape_base.py +813 -0
  580. numpy/lib/tests/test_stride_tricks.py +890 -0
  581. numpy/lib/tests/test_twodim_base.py +564 -0
  582. numpy/lib/tests/test_type_check.py +473 -0
  583. numpy/lib/tests/test_ufunclike.py +121 -0
  584. numpy/lib/tests/test_utils.py +80 -0
  585. numpy/lib/user_array.py +1 -0
  586. numpy/lib/user_array.pyi +1 -0
  587. numpy/linalg/__init__.py +95 -0
  588. numpy/linalg/__init__.pyi +71 -0
  589. numpy/linalg/_linalg.py +3649 -0
  590. numpy/linalg/_linalg.pyi +1230 -0
  591. numpy/linalg/_umath_linalg.cp315-win32.lib +0 -0
  592. numpy/linalg/_umath_linalg.cp315-win32.pyd +0 -0
  593. numpy/linalg/_umath_linalg.pyi +60 -0
  594. numpy/linalg/lapack_lite.cp315-win32.lib +0 -0
  595. numpy/linalg/lapack_lite.cp315-win32.pyd +0 -0
  596. numpy/linalg/lapack_lite.pyi +143 -0
  597. numpy/linalg/tests/__init__.py +0 -0
  598. numpy/linalg/tests/test_deprecations.py +21 -0
  599. numpy/linalg/tests/test_linalg.py +2492 -0
  600. numpy/linalg/tests/test_regression.py +191 -0
  601. numpy/ma/API_CHANGES.txt +135 -0
  602. numpy/ma/LICENSE +24 -0
  603. numpy/ma/README.rst +236 -0
  604. numpy/ma/__init__.py +53 -0
  605. numpy/ma/__init__.pyi +458 -0
  606. numpy/ma/core.py +9000 -0
  607. numpy/ma/core.pyi +4767 -0
  608. numpy/ma/extras.py +2266 -0
  609. numpy/ma/extras.pyi +770 -0
  610. numpy/ma/mrecords.py +739 -0
  611. numpy/ma/mrecords.pyi +313 -0
  612. numpy/ma/tests/__init__.py +0 -0
  613. numpy/ma/tests/test_arrayobject.py +40 -0
  614. numpy/ma/tests/test_core.py +6112 -0
  615. numpy/ma/tests/test_deprecations.py +73 -0
  616. numpy/ma/tests/test_extras.py +1945 -0
  617. numpy/ma/tests/test_mrecords.py +495 -0
  618. numpy/ma/tests/test_old_ma.py +939 -0
  619. numpy/ma/tests/test_regression.py +83 -0
  620. numpy/ma/tests/test_subclassing.py +469 -0
  621. numpy/ma/testutils.py +294 -0
  622. numpy/ma/testutils.pyi +69 -0
  623. numpy/matlib.py +380 -0
  624. numpy/matlib.pyi +580 -0
  625. numpy/matrixlib/__init__.py +12 -0
  626. numpy/matrixlib/__init__.pyi +3 -0
  627. numpy/matrixlib/defmatrix.py +1117 -0
  628. numpy/matrixlib/defmatrix.pyi +211 -0
  629. numpy/matrixlib/tests/__init__.py +0 -0
  630. numpy/matrixlib/tests/test_defmatrix.py +475 -0
  631. numpy/matrixlib/tests/test_interaction.py +360 -0
  632. numpy/matrixlib/tests/test_masked_matrix.py +240 -0
  633. numpy/matrixlib/tests/test_matrix_linalg.py +110 -0
  634. numpy/matrixlib/tests/test_multiarray.py +17 -0
  635. numpy/matrixlib/tests/test_numeric.py +18 -0
  636. numpy/matrixlib/tests/test_regression.py +31 -0
  637. numpy/polynomial/__init__.py +187 -0
  638. numpy/polynomial/__init__.pyi +31 -0
  639. numpy/polynomial/_polybase.py +1191 -0
  640. numpy/polynomial/_polybase.pyi +255 -0
  641. numpy/polynomial/_polytypes.pyi +536 -0
  642. numpy/polynomial/chebyshev.py +2053 -0
  643. numpy/polynomial/chebyshev.pyi +173 -0
  644. numpy/polynomial/hermite.py +1794 -0
  645. numpy/polynomial/hermite.pyi +110 -0
  646. numpy/polynomial/hermite_e.py +1692 -0
  647. numpy/polynomial/hermite_e.pyi +110 -0
  648. numpy/polynomial/laguerre.py +1729 -0
  649. numpy/polynomial/laguerre.pyi +103 -0
  650. numpy/polynomial/legendre.py +1655 -0
  651. numpy/polynomial/legendre.pyi +103 -0
  652. numpy/polynomial/polynomial.py +1683 -0
  653. numpy/polynomial/polynomial.pyi +112 -0
  654. numpy/polynomial/polyutils.py +759 -0
  655. numpy/polynomial/polyutils.pyi +295 -0
  656. numpy/polynomial/tests/__init__.py +0 -0
  657. numpy/polynomial/tests/test_chebyshev.py +639 -0
  658. numpy/polynomial/tests/test_classes.py +625 -0
  659. numpy/polynomial/tests/test_hermite.py +574 -0
  660. numpy/polynomial/tests/test_hermite_e.py +575 -0
  661. numpy/polynomial/tests/test_laguerre.py +556 -0
  662. numpy/polynomial/tests/test_legendre.py +587 -0
  663. numpy/polynomial/tests/test_polynomial.py +713 -0
  664. numpy/polynomial/tests/test_polyutils.py +123 -0
  665. numpy/polynomial/tests/test_printing.py +562 -0
  666. numpy/polynomial/tests/test_symbol.py +217 -0
  667. numpy/py.typed +0 -0
  668. numpy/random/LICENSE.md +71 -0
  669. numpy/random/__init__.pxd +14 -0
  670. numpy/random/__init__.py +213 -0
  671. numpy/random/__init__.pyi +124 -0
  672. numpy/random/_bounded_integers.cp315-win32.lib +0 -0
  673. numpy/random/_bounded_integers.cp315-win32.pyd +0 -0
  674. numpy/random/_bounded_integers.pxd +38 -0
  675. numpy/random/_bounded_integers.pyi +1 -0
  676. numpy/random/_common.cp315-win32.lib +0 -0
  677. numpy/random/_common.cp315-win32.pyd +0 -0
  678. numpy/random/_common.pxd +110 -0
  679. numpy/random/_common.pyi +17 -0
  680. numpy/random/_examples/cffi/extending.py +44 -0
  681. numpy/random/_examples/cffi/parse.py +53 -0
  682. numpy/random/_examples/cython/extending.pyx +77 -0
  683. numpy/random/_examples/cython/extending_distributions.pyx +117 -0
  684. numpy/random/_examples/cython/meson.build +53 -0
  685. numpy/random/_examples/numba/extending.py +86 -0
  686. numpy/random/_examples/numba/extending_distributions.py +67 -0
  687. numpy/random/_generator.cp315-win32.lib +0 -0
  688. numpy/random/_generator.cp315-win32.pyd +0 -0
  689. numpy/random/_generator.pyi +769 -0
  690. numpy/random/_mt19937.cp315-win32.lib +0 -0
  691. numpy/random/_mt19937.cp315-win32.pyd +0 -0
  692. numpy/random/_mt19937.pyi +27 -0
  693. numpy/random/_pcg64.cp315-win32.lib +0 -0
  694. numpy/random/_pcg64.cp315-win32.pyd +0 -0
  695. numpy/random/_pcg64.pyi +36 -0
  696. numpy/random/_philox.cp315-win32.lib +0 -0
  697. numpy/random/_philox.cp315-win32.pyd +0 -0
  698. numpy/random/_philox.pyi +36 -0
  699. numpy/random/_pickle.py +88 -0
  700. numpy/random/_pickle.pyi +43 -0
  701. numpy/random/_sfc64.cp315-win32.lib +0 -0
  702. numpy/random/_sfc64.cp315-win32.pyd +0 -0
  703. numpy/random/_sfc64.pyi +25 -0
  704. numpy/random/bit_generator.cp315-win32.lib +0 -0
  705. numpy/random/bit_generator.cp315-win32.pyd +0 -0
  706. numpy/random/bit_generator.pxd +35 -0
  707. numpy/random/bit_generator.pyi +122 -0
  708. numpy/random/c_distributions.pxd +119 -0
  709. numpy/random/lib/npyrandom.lib +0 -0
  710. numpy/random/mtrand.cp315-win32.lib +0 -0
  711. numpy/random/mtrand.cp315-win32.pyd +0 -0
  712. numpy/random/mtrand.pyi +996 -0
  713. numpy/random/tests/__init__.py +0 -0
  714. numpy/random/tests/data/__init__.py +0 -0
  715. numpy/random/tests/data/generator_pcg64_np121.pkl.gz +0 -0
  716. numpy/random/tests/data/generator_pcg64_np126.pkl.gz +0 -0
  717. numpy/random/tests/data/mt19937-testset-1.csv +1001 -0
  718. numpy/random/tests/data/mt19937-testset-2.csv +1001 -0
  719. numpy/random/tests/data/pcg64-testset-1.csv +1001 -0
  720. numpy/random/tests/data/pcg64-testset-2.csv +1001 -0
  721. numpy/random/tests/data/pcg64dxsm-testset-1.csv +1001 -0
  722. numpy/random/tests/data/pcg64dxsm-testset-2.csv +1001 -0
  723. numpy/random/tests/data/philox-testset-1.csv +1001 -0
  724. numpy/random/tests/data/philox-testset-2.csv +1001 -0
  725. numpy/random/tests/data/sfc64-testset-1.csv +1001 -0
  726. numpy/random/tests/data/sfc64-testset-2.csv +1001 -0
  727. numpy/random/tests/data/sfc64_np126.pkl.gz +0 -0
  728. numpy/random/tests/test_direct.py +620 -0
  729. numpy/random/tests/test_extending.py +129 -0
  730. numpy/random/tests/test_generator_mt19937.py +2830 -0
  731. numpy/random/tests/test_generator_mt19937_regressions.py +240 -0
  732. numpy/random/tests/test_random.py +1723 -0
  733. numpy/random/tests/test_randomstate.py +2107 -0
  734. numpy/random/tests/test_randomstate_regression.py +249 -0
  735. numpy/random/tests/test_regression.py +174 -0
  736. numpy/random/tests/test_seed_sequence.py +103 -0
  737. numpy/random/tests/test_smoke.py +882 -0
  738. numpy/rec/__init__.py +2 -0
  739. numpy/rec/__init__.pyi +23 -0
  740. numpy/strings/__init__.py +2 -0
  741. numpy/strings/__init__.pyi +97 -0
  742. numpy/testing/__init__.py +22 -0
  743. numpy/testing/__init__.pyi +107 -0
  744. numpy/testing/_private/__init__.py +0 -0
  745. numpy/testing/_private/__init__.pyi +0 -0
  746. numpy/testing/_private/extbuild.py +247 -0
  747. numpy/testing/_private/extbuild.pyi +25 -0
  748. numpy/testing/_private/utils.py +2899 -0
  749. numpy/testing/_private/utils.pyi +501 -0
  750. numpy/testing/overrides.py +84 -0
  751. numpy/testing/overrides.pyi +10 -0
  752. numpy/testing/print_coercion_tables.py +207 -0
  753. numpy/testing/print_coercion_tables.pyi +26 -0
  754. numpy/testing/tests/__init__.py +0 -0
  755. numpy/testing/tests/test_utils.py +2147 -0
  756. numpy/tests/__init__.py +0 -0
  757. numpy/tests/test__all__.py +10 -0
  758. numpy/tests/test_configtool.py +51 -0
  759. numpy/tests/test_ctypeslib.py +406 -0
  760. numpy/tests/test_lazyloading.py +35 -0
  761. numpy/tests/test_matlib.py +59 -0
  762. numpy/tests/test_numpy_config.py +47 -0
  763. numpy/tests/test_numpy_version.py +54 -0
  764. numpy/tests/test_public_api.py +723 -0
  765. numpy/tests/test_reloading.py +69 -0
  766. numpy/tests/test_scripts.py +45 -0
  767. numpy/tests/test_warnings.py +81 -0
  768. numpy/typing/__init__.py +225 -0
  769. numpy/typing/__init__.pyi +8 -0
  770. numpy/typing/mypy_plugin.py +200 -0
  771. numpy/typing/tests/__init__.py +0 -0
  772. numpy/typing/tests/data/fail/arithmetic.pyi +126 -0
  773. numpy/typing/tests/data/fail/array_constructors.pyi +34 -0
  774. numpy/typing/tests/data/fail/array_like.pyi +15 -0
  775. numpy/typing/tests/data/fail/array_pad.pyi +6 -0
  776. numpy/typing/tests/data/fail/arrayprint.pyi +15 -0
  777. numpy/typing/tests/data/fail/arrayterator.pyi +14 -0
  778. numpy/typing/tests/data/fail/bitwise_ops.pyi +17 -0
  779. numpy/typing/tests/data/fail/char.pyi +60 -0
  780. numpy/typing/tests/data/fail/chararray.pyi +61 -0
  781. numpy/typing/tests/data/fail/comparisons.pyi +27 -0
  782. numpy/typing/tests/data/fail/constants.pyi +3 -0
  783. numpy/typing/tests/data/fail/datasource.pyi +16 -0
  784. numpy/typing/tests/data/fail/dtype.pyi +17 -0
  785. numpy/typing/tests/data/fail/einsumfunc.pyi +12 -0
  786. numpy/typing/tests/data/fail/flatiter.pyi +38 -0
  787. numpy/typing/tests/data/fail/fromnumeric.pyi +149 -0
  788. numpy/typing/tests/data/fail/histograms.pyi +12 -0
  789. numpy/typing/tests/data/fail/index_tricks.pyi +14 -0
  790. numpy/typing/tests/data/fail/lib_function_base.pyi +60 -0
  791. numpy/typing/tests/data/fail/lib_polynomial.pyi +29 -0
  792. numpy/typing/tests/data/fail/lib_utils.pyi +3 -0
  793. numpy/typing/tests/data/fail/lib_version.pyi +6 -0
  794. numpy/typing/tests/data/fail/linalg.pyi +48 -0
  795. numpy/typing/tests/data/fail/ma.pyi +152 -0
  796. numpy/typing/tests/data/fail/memmap.pyi +5 -0
  797. numpy/typing/tests/data/fail/modules.pyi +17 -0
  798. numpy/typing/tests/data/fail/multiarray.pyi +52 -0
  799. numpy/typing/tests/data/fail/ndarray.pyi +11 -0
  800. numpy/typing/tests/data/fail/ndarray_misc.pyi +49 -0
  801. numpy/typing/tests/data/fail/nditer.pyi +7 -0
  802. numpy/typing/tests/data/fail/nested_sequence.pyi +17 -0
  803. numpy/typing/tests/data/fail/npyio.pyi +24 -0
  804. numpy/typing/tests/data/fail/numerictypes.pyi +5 -0
  805. numpy/typing/tests/data/fail/random.pyi +62 -0
  806. numpy/typing/tests/data/fail/rec.pyi +17 -0
  807. numpy/typing/tests/data/fail/scalars.pyi +86 -0
  808. numpy/typing/tests/data/fail/shape.pyi +7 -0
  809. numpy/typing/tests/data/fail/shape_base.pyi +8 -0
  810. numpy/typing/tests/data/fail/stride_tricks.pyi +9 -0
  811. numpy/typing/tests/data/fail/strings.pyi +41 -0
  812. numpy/typing/tests/data/fail/testing.pyi +28 -0
  813. numpy/typing/tests/data/fail/twodim_base.pyi +39 -0
  814. numpy/typing/tests/data/fail/type_check.pyi +13 -0
  815. numpy/typing/tests/data/fail/ufunc_config.pyi +21 -0
  816. numpy/typing/tests/data/fail/ufunclike.pyi +21 -0
  817. numpy/typing/tests/data/fail/ufuncs.pyi +17 -0
  818. numpy/typing/tests/data/fail/warnings_and_errors.pyi +5 -0
  819. numpy/typing/tests/data/misc/extended_precision.pyi +9 -0
  820. numpy/typing/tests/data/mypy.ini +8 -0
  821. numpy/typing/tests/data/pass/arithmetic.py +614 -0
  822. numpy/typing/tests/data/pass/array_constructors.py +137 -0
  823. numpy/typing/tests/data/pass/array_like.py +37 -0
  824. numpy/typing/tests/data/pass/arrayprint.py +37 -0
  825. numpy/typing/tests/data/pass/arrayterator.py +28 -0
  826. numpy/typing/tests/data/pass/bitwise_ops.py +131 -0
  827. numpy/typing/tests/data/pass/comparisons.py +316 -0
  828. numpy/typing/tests/data/pass/dtype.py +57 -0
  829. numpy/typing/tests/data/pass/einsumfunc.py +36 -0
  830. numpy/typing/tests/data/pass/flatiter.py +26 -0
  831. numpy/typing/tests/data/pass/fromnumeric.py +272 -0
  832. numpy/typing/tests/data/pass/index_tricks.py +62 -0
  833. numpy/typing/tests/data/pass/lib_user_array.py +22 -0
  834. numpy/typing/tests/data/pass/lib_utils.py +19 -0
  835. numpy/typing/tests/data/pass/lib_version.py +18 -0
  836. numpy/typing/tests/data/pass/literal.py +52 -0
  837. numpy/typing/tests/data/pass/ma.py +199 -0
  838. numpy/typing/tests/data/pass/mod.py +149 -0
  839. numpy/typing/tests/data/pass/modules.py +45 -0
  840. numpy/typing/tests/data/pass/multiarray.py +77 -0
  841. numpy/typing/tests/data/pass/ndarray_conversion.py +81 -0
  842. numpy/typing/tests/data/pass/ndarray_misc.py +199 -0
  843. numpy/typing/tests/data/pass/ndarray_shape_manipulation.py +47 -0
  844. numpy/typing/tests/data/pass/nditer.py +4 -0
  845. numpy/typing/tests/data/pass/numeric.py +90 -0
  846. numpy/typing/tests/data/pass/numerictypes.py +17 -0
  847. numpy/typing/tests/data/pass/random.py +1498 -0
  848. numpy/typing/tests/data/pass/recfunctions.py +164 -0
  849. numpy/typing/tests/data/pass/scalars.py +262 -0
  850. numpy/typing/tests/data/pass/shape.py +19 -0
  851. numpy/typing/tests/data/pass/simple.py +170 -0
  852. numpy/typing/tests/data/pass/ufunc_config.py +64 -0
  853. numpy/typing/tests/data/pass/ufunclike.py +52 -0
  854. numpy/typing/tests/data/pass/ufuncs.py +16 -0
  855. numpy/typing/tests/data/pass/warnings_and_errors.py +6 -0
  856. numpy/typing/tests/data/reveal/arithmetic.pyi +726 -0
  857. numpy/typing/tests/data/reveal/array_api_info.pyi +70 -0
  858. numpy/typing/tests/data/reveal/array_constructors.pyi +331 -0
  859. numpy/typing/tests/data/reveal/arraypad.pyi +32 -0
  860. numpy/typing/tests/data/reveal/arrayprint.pyi +25 -0
  861. numpy/typing/tests/data/reveal/arraysetops.pyi +80 -0
  862. numpy/typing/tests/data/reveal/arrayterator.pyi +27 -0
  863. numpy/typing/tests/data/reveal/bitwise_ops.pyi +166 -0
  864. numpy/typing/tests/data/reveal/char.pyi +228 -0
  865. numpy/typing/tests/data/reveal/chararray.pyi +138 -0
  866. numpy/typing/tests/data/reveal/comparisons.pyi +264 -0
  867. numpy/typing/tests/data/reveal/constants.pyi +14 -0
  868. numpy/typing/tests/data/reveal/ctypeslib.pyi +86 -0
  869. numpy/typing/tests/data/reveal/datasource.pyi +23 -0
  870. numpy/typing/tests/data/reveal/dtype.pyi +166 -0
  871. numpy/typing/tests/data/reveal/einsumfunc.pyi +46 -0
  872. numpy/typing/tests/data/reveal/emath.pyi +54 -0
  873. numpy/typing/tests/data/reveal/fft.pyi +189 -0
  874. numpy/typing/tests/data/reveal/flatiter.pyi +86 -0
  875. numpy/typing/tests/data/reveal/fromnumeric.pyi +574 -0
  876. numpy/typing/tests/data/reveal/getlimits.pyi +53 -0
  877. numpy/typing/tests/data/reveal/histograms.pyi +69 -0
  878. numpy/typing/tests/data/reveal/index_tricks.pyi +148 -0
  879. numpy/typing/tests/data/reveal/lib_function_base.pyi +413 -0
  880. numpy/typing/tests/data/reveal/lib_polynomial.pyi +147 -0
  881. numpy/typing/tests/data/reveal/lib_utils.pyi +17 -0
  882. numpy/typing/tests/data/reveal/lib_version.pyi +20 -0
  883. numpy/typing/tests/data/reveal/linalg.pyi +517 -0
  884. numpy/typing/tests/data/reveal/ma.pyi +1103 -0
  885. numpy/typing/tests/data/reveal/matrix.pyi +73 -0
  886. numpy/typing/tests/data/reveal/memmap.pyi +21 -0
  887. numpy/typing/tests/data/reveal/mod.pyi +179 -0
  888. numpy/typing/tests/data/reveal/modules.pyi +51 -0
  889. numpy/typing/tests/data/reveal/multiarray.pyi +336 -0
  890. numpy/typing/tests/data/reveal/nbit_base_example.pyi +17 -0
  891. numpy/typing/tests/data/reveal/ndarray_assignability.pyi +79 -0
  892. numpy/typing/tests/data/reveal/ndarray_conversion.pyi +83 -0
  893. numpy/typing/tests/data/reveal/ndarray_misc.pyi +428 -0
  894. numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi +47 -0
  895. numpy/typing/tests/data/reveal/nditer.pyi +49 -0
  896. numpy/typing/tests/data/reveal/nested_sequence.pyi +25 -0
  897. numpy/typing/tests/data/reveal/npyio.pyi +85 -0
  898. numpy/typing/tests/data/reveal/numeric.pyi +176 -0
  899. numpy/typing/tests/data/reveal/numerictypes.pyi +16 -0
  900. numpy/typing/tests/data/reveal/polynomial_polybase.pyi +216 -0
  901. numpy/typing/tests/data/reveal/polynomial_polyutils.pyi +218 -0
  902. numpy/typing/tests/data/reveal/polynomial_series.pyi +138 -0
  903. numpy/typing/tests/data/reveal/random.pyi +1357 -0
  904. numpy/typing/tests/data/reveal/rec.pyi +177 -0
  905. numpy/typing/tests/data/reveal/scalars.pyi +288 -0
  906. numpy/typing/tests/data/reveal/shape.pyi +13 -0
  907. numpy/typing/tests/data/reveal/shape_base.pyi +84 -0
  908. numpy/typing/tests/data/reveal/stride_tricks.pyi +27 -0
  909. numpy/typing/tests/data/reveal/strings.pyi +198 -0
  910. numpy/typing/tests/data/reveal/testing.pyi +196 -0
  911. numpy/typing/tests/data/reveal/twodim_base.pyi +231 -0
  912. numpy/typing/tests/data/reveal/type_check.pyi +94 -0
  913. numpy/typing/tests/data/reveal/ufunc_config.pyi +30 -0
  914. numpy/typing/tests/data/reveal/ufunclike.pyi +31 -0
  915. numpy/typing/tests/data/reveal/ufuncs.pyi +142 -0
  916. numpy/typing/tests/data/reveal/warnings_and_errors.pyi +11 -0
  917. numpy/typing/tests/test_isfile.py +35 -0
  918. numpy/typing/tests/test_runtime.py +103 -0
  919. numpy/typing/tests/test_typing.py +207 -0
  920. numpy/version.py +11 -0
  921. numpy/version.pyi +9 -0
  922. numpy-2.5.2.dist-info/METADATA +139 -0
  923. numpy-2.5.2.dist-info/RECORD +942 -0
  924. numpy-2.5.2.dist-info/WHEEL +4 -0
  925. numpy-2.5.2.dist-info/entry_points.txt +13 -0
  926. numpy-2.5.2.dist-info/licenses/LICENSE.txt +914 -0
  927. numpy-2.5.2.dist-info/licenses/numpy/_core/include/numpy/libdivide/LICENSE.txt +21 -0
  928. numpy-2.5.2.dist-info/licenses/numpy/_core/src/common/pythoncapi-compat/COPYING +14 -0
  929. numpy-2.5.2.dist-info/licenses/numpy/_core/src/highway/LICENSE +371 -0
  930. numpy-2.5.2.dist-info/licenses/numpy/_core/src/multiarray/dragon4_LICENSE.txt +27 -0
  931. numpy-2.5.2.dist-info/licenses/numpy/_core/src/npysort/x86-simd-sort/LICENSE.md +28 -0
  932. numpy-2.5.2.dist-info/licenses/numpy/_core/src/umath/svml/LICENSE +30 -0
  933. numpy-2.5.2.dist-info/licenses/numpy/fft/pocketfft/LICENSE.md +25 -0
  934. numpy-2.5.2.dist-info/licenses/numpy/linalg/lapack_lite/LICENSE.txt +48 -0
  935. numpy-2.5.2.dist-info/licenses/numpy/ma/LICENSE +24 -0
  936. numpy-2.5.2.dist-info/licenses/numpy/random/LICENSE.md +71 -0
  937. numpy-2.5.2.dist-info/licenses/numpy/random/src/distributions/LICENSE.md +61 -0
  938. numpy-2.5.2.dist-info/licenses/numpy/random/src/mt19937/LICENSE.md +61 -0
  939. numpy-2.5.2.dist-info/licenses/numpy/random/src/pcg64/LICENSE.md +22 -0
  940. numpy-2.5.2.dist-info/licenses/numpy/random/src/philox/LICENSE.md +31 -0
  941. numpy-2.5.2.dist-info/licenses/numpy/random/src/sfc64/LICENSE.md +27 -0
  942. numpy-2.5.2.dist-info/licenses/numpy/random/src/splitmix64/LICENSE.md +9 -0
numpy/_core/numeric.py ADDED
@@ -0,0 +1,2707 @@
1
+ import builtins
2
+ import functools
3
+ import itertools
4
+ import math
5
+ import numbers
6
+ import operator
7
+ import sys
8
+ import warnings
9
+
10
+ import numpy as np
11
+ from numpy.exceptions import AxisError
12
+
13
+ from . import multiarray, numerictypes, numerictypes as nt, overrides, shape_base, umath
14
+ from ._ufunc_config import errstate
15
+ from .multiarray import ( # noqa: F401
16
+ ALLOW_THREADS,
17
+ BUFSIZE,
18
+ CLIP,
19
+ MAXDIMS,
20
+ MAY_SHARE_BOUNDS,
21
+ MAY_SHARE_EXACT,
22
+ RAISE,
23
+ WRAP,
24
+ arange,
25
+ array,
26
+ asanyarray,
27
+ asarray,
28
+ ascontiguousarray,
29
+ asfortranarray,
30
+ broadcast,
31
+ can_cast,
32
+ concatenate,
33
+ copyto,
34
+ dot,
35
+ dtype,
36
+ empty,
37
+ empty_like,
38
+ flatiter,
39
+ from_dlpack,
40
+ frombuffer,
41
+ fromfile,
42
+ fromiter,
43
+ fromstring,
44
+ inner,
45
+ lexsort,
46
+ matmul,
47
+ may_share_memory,
48
+ min_scalar_type,
49
+ ndarray,
50
+ nditer,
51
+ nested_iters,
52
+ normalize_axis_index,
53
+ promote_types,
54
+ putmask,
55
+ result_type,
56
+ shares_memory,
57
+ vdot,
58
+ vecdot,
59
+ where,
60
+ zeros,
61
+ )
62
+ from .overrides import finalize_array_function_like, set_module
63
+ from .umath import NAN, PINF, invert, multiply, sin
64
+
65
+ bitwise_not = invert
66
+ ufunc = type(sin)
67
+ newaxis = None
68
+
69
+ array_function_dispatch = functools.partial(
70
+ overrides.array_function_dispatch, module='numpy')
71
+
72
+
73
+ __all__ = [
74
+ 'newaxis', 'ndarray', 'flatiter', 'nditer', 'nested_iters', 'ufunc',
75
+ 'arange', 'array', 'asarray', 'asanyarray', 'ascontiguousarray',
76
+ 'asfortranarray', 'zeros', 'count_nonzero', 'empty', 'broadcast', 'dtype',
77
+ 'fromstring', 'fromfile', 'frombuffer', 'from_dlpack', 'where',
78
+ 'argwhere', 'copyto', 'concatenate', 'lexsort', 'astype',
79
+ 'can_cast', 'promote_types', 'min_scalar_type',
80
+ 'result_type', 'isfortran', 'empty_like', 'zeros_like', 'ones_like',
81
+ 'correlate', 'convolve', 'inner', 'dot', 'outer', 'vdot', 'roll',
82
+ 'rollaxis', 'moveaxis', 'cross', 'tensordot', 'little_endian',
83
+ 'fromiter', 'array_equal', 'array_equiv', 'indices', 'fromfunction',
84
+ 'isclose', 'isscalar', 'binary_repr', 'base_repr', 'ones',
85
+ 'identity', 'allclose', 'putmask',
86
+ 'flatnonzero', 'inf', 'nan', 'False_', 'True_', 'bitwise_not',
87
+ 'full', 'full_like', 'matmul', 'vecdot', 'shares_memory',
88
+ 'may_share_memory']
89
+
90
+
91
+ def _zeros_like_dispatcher(
92
+ a, dtype=None, order=None, subok=None, shape=None, *, device=None
93
+ ):
94
+ return (a,)
95
+
96
+
97
+ @array_function_dispatch(_zeros_like_dispatcher)
98
+ def zeros_like(
99
+ a, dtype=None, order='K', subok=True, shape=None, *, device=None
100
+ ):
101
+ """
102
+ Return an array of zeros with the same shape and type as a given array.
103
+
104
+ Parameters
105
+ ----------
106
+ a : array_like
107
+ The shape and data-type of `a` define these same attributes of
108
+ the returned array.
109
+ dtype : data-type, optional
110
+ Overrides the data type of the result.
111
+ order : {'C', 'F', 'A', or 'K'}, optional
112
+ Overrides the memory layout of the result. 'C' means C-order,
113
+ 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
114
+ 'C' otherwise. 'K' means match the layout of `a` as closely
115
+ as possible.
116
+ subok : bool, optional.
117
+ If True, then the newly created array will use the sub-class
118
+ type of `a`, otherwise it will be a base-class array. Defaults
119
+ to True.
120
+ shape : int or sequence of ints, optional.
121
+ Overrides the shape of the result. If order='K' and the number of
122
+ dimensions is unchanged, will try to keep order, otherwise,
123
+ order='C' is implied.
124
+ device : str, optional
125
+ The device on which to place the created array. Default: None.
126
+ For Array-API interoperability only, so must be ``"cpu"`` if passed.
127
+
128
+ .. versionadded:: 2.0.0
129
+
130
+ Returns
131
+ -------
132
+ out : ndarray
133
+ Array of zeros with the same shape and type as `a`.
134
+
135
+ See Also
136
+ --------
137
+ empty_like : Return an empty array with shape and type of input.
138
+ ones_like : Return an array of ones with shape and type of input.
139
+ full_like : Return a new array with shape of input filled with value.
140
+ zeros : Return a new array setting values to zero.
141
+
142
+ Examples
143
+ --------
144
+ >>> import numpy as np
145
+ >>> x = np.arange(6)
146
+ >>> x = x.reshape((2, 3))
147
+ >>> x
148
+ array([[0, 1, 2],
149
+ [3, 4, 5]])
150
+ >>> np.zeros_like(x)
151
+ array([[0, 0, 0],
152
+ [0, 0, 0]])
153
+
154
+ >>> y = np.arange(3, dtype=np.float64)
155
+ >>> y
156
+ array([0., 1., 2.])
157
+ >>> np.zeros_like(y)
158
+ array([0., 0., 0.])
159
+
160
+ """
161
+ res = empty_like(
162
+ a, dtype=dtype, order=order, subok=subok, shape=shape, device=device
163
+ )
164
+ # needed instead of a 0 to get same result as zeros for string dtypes
165
+ z = zeros(1, dtype=res.dtype)
166
+ multiarray.copyto(res, z, casting='unsafe')
167
+ return res
168
+
169
+
170
+ @finalize_array_function_like
171
+ @set_module('numpy')
172
+ def ones(shape, dtype=None, order='C', *, device=None, like=None):
173
+ """
174
+ Return a new array of given shape and type, filled with ones.
175
+
176
+ Parameters
177
+ ----------
178
+ shape : int or sequence of ints
179
+ Shape of the new array, e.g., ``(2, 3)`` or ``2``.
180
+ dtype : data-type, optional
181
+ The desired data-type for the array, e.g., `numpy.int8`. Default is
182
+ `numpy.float64`.
183
+ order : {'C', 'F'}, optional, default: C
184
+ Whether to store multi-dimensional data in row-major
185
+ (C-style) or column-major (Fortran-style) order in
186
+ memory.
187
+ device : str, optional
188
+ The device on which to place the created array. Default: None.
189
+ For Array-API interoperability only, so must be ``"cpu"`` if passed.
190
+
191
+ .. versionadded:: 2.0.0
192
+ ${ARRAY_FUNCTION_LIKE}
193
+
194
+ .. versionadded:: 1.20.0
195
+
196
+ Returns
197
+ -------
198
+ out : ndarray
199
+ Array of ones with the given shape, dtype, and order.
200
+
201
+ See Also
202
+ --------
203
+ ones_like : Return an array of ones with shape and type of input.
204
+ empty : Return a new uninitialized array.
205
+ zeros : Return a new array setting values to zero.
206
+ full : Return a new array of given shape filled with value.
207
+
208
+ Examples
209
+ --------
210
+ >>> import numpy as np
211
+ >>> np.ones(5)
212
+ array([1., 1., 1., 1., 1.])
213
+
214
+ >>> np.ones((5,), dtype=np.int_)
215
+ array([1, 1, 1, 1, 1])
216
+
217
+ >>> np.ones((2, 1))
218
+ array([[1.],
219
+ [1.]])
220
+
221
+ >>> s = (2,2)
222
+ >>> np.ones(s)
223
+ array([[1., 1.],
224
+ [1., 1.]])
225
+
226
+ """
227
+ if like is not None:
228
+ return _ones_with_like(
229
+ like, shape, dtype=dtype, order=order, device=device
230
+ )
231
+
232
+ a = empty(shape, dtype, order, device=device)
233
+ multiarray.copyto(a, 1, casting='unsafe')
234
+ return a
235
+
236
+
237
+ _ones_with_like = array_function_dispatch()(ones)
238
+
239
+
240
+ def _ones_like_dispatcher(
241
+ a, dtype=None, order=None, subok=None, shape=None, *, device=None
242
+ ):
243
+ return (a,)
244
+
245
+
246
+ @array_function_dispatch(_ones_like_dispatcher)
247
+ def ones_like(
248
+ a, dtype=None, order='K', subok=True, shape=None, *, device=None
249
+ ):
250
+ """
251
+ Return an array of ones with the same shape and type as a given array.
252
+
253
+ Parameters
254
+ ----------
255
+ a : array_like
256
+ The shape and data-type of `a` define these same attributes of
257
+ the returned array.
258
+ dtype : data-type, optional
259
+ Overrides the data type of the result.
260
+ order : {'C', 'F', 'A', or 'K'}, optional
261
+ Overrides the memory layout of the result. 'C' means C-order,
262
+ 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
263
+ 'C' otherwise. 'K' means match the layout of `a` as closely
264
+ as possible.
265
+ subok : bool, optional.
266
+ If True, then the newly created array will use the sub-class
267
+ type of `a`, otherwise it will be a base-class array. Defaults
268
+ to True.
269
+ shape : int or sequence of ints, optional.
270
+ Overrides the shape of the result. If order='K' and the number of
271
+ dimensions is unchanged, will try to keep order, otherwise,
272
+ order='C' is implied.
273
+ device : str, optional
274
+ The device on which to place the created array. Default: None.
275
+ For Array-API interoperability only, so must be ``"cpu"`` if passed.
276
+
277
+ .. versionadded:: 2.0.0
278
+
279
+ Returns
280
+ -------
281
+ out : ndarray
282
+ Array of ones with the same shape and type as `a`.
283
+
284
+ See Also
285
+ --------
286
+ empty_like : Return an empty array with shape and type of input.
287
+ zeros_like : Return an array of zeros with shape and type of input.
288
+ full_like : Return a new array with shape of input filled with value.
289
+ ones : Return a new array setting values to one.
290
+
291
+ Examples
292
+ --------
293
+ >>> import numpy as np
294
+ >>> x = np.arange(6)
295
+ >>> x = x.reshape((2, 3))
296
+ >>> x
297
+ array([[0, 1, 2],
298
+ [3, 4, 5]])
299
+ >>> np.ones_like(x)
300
+ array([[1, 1, 1],
301
+ [1, 1, 1]])
302
+
303
+ >>> y = np.arange(3, dtype=np.float64)
304
+ >>> y
305
+ array([0., 1., 2.])
306
+ >>> np.ones_like(y)
307
+ array([1., 1., 1.])
308
+
309
+ """
310
+ res = empty_like(
311
+ a, dtype=dtype, order=order, subok=subok, shape=shape, device=device
312
+ )
313
+ multiarray.copyto(res, 1, casting='unsafe')
314
+ return res
315
+
316
+
317
+ def _full_dispatcher(
318
+ shape, fill_value, dtype=None, order=None, *, device=None, like=None
319
+ ):
320
+ return (like,)
321
+
322
+
323
+ @finalize_array_function_like
324
+ @set_module('numpy')
325
+ def full(shape, fill_value, dtype=None, order='C', *, device=None, like=None):
326
+ """
327
+ Return a new array of given shape and type, filled with `fill_value`.
328
+
329
+ Parameters
330
+ ----------
331
+ shape : int or sequence of ints
332
+ Shape of the new array, e.g., ``(2, 3)`` or ``2``.
333
+ fill_value : scalar or array_like
334
+ Fill value.
335
+ dtype : data-type, optional
336
+ The desired data-type for the array The default, None, means
337
+ ``np.array(fill_value).dtype``.
338
+ order : {'C', 'F'}, optional
339
+ Whether to store multidimensional data in C- or Fortran-contiguous
340
+ (row- or column-wise) order in memory.
341
+ device : str, optional
342
+ The device on which to place the created array. Default: None.
343
+ For Array-API interoperability only, so must be ``"cpu"`` if passed.
344
+
345
+ .. versionadded:: 2.0.0
346
+ ${ARRAY_FUNCTION_LIKE}
347
+
348
+ .. versionadded:: 1.20.0
349
+
350
+ Returns
351
+ -------
352
+ out : ndarray
353
+ Array of `fill_value` with the given shape, dtype, and order.
354
+
355
+ See Also
356
+ --------
357
+ full_like : Return a new array with shape of input filled with value.
358
+ empty : Return a new uninitialized array.
359
+ ones : Return a new array setting values to one.
360
+ zeros : Return a new array setting values to zero.
361
+
362
+ Examples
363
+ --------
364
+ >>> import numpy as np
365
+ >>> np.full((2, 2), np.inf)
366
+ array([[inf, inf],
367
+ [inf, inf]])
368
+ >>> np.full((2, 2), 10)
369
+ array([[10, 10],
370
+ [10, 10]])
371
+
372
+ >>> np.full((2, 2), [1, 2])
373
+ array([[1, 2],
374
+ [1, 2]])
375
+
376
+ """
377
+ if like is not None:
378
+ return _full_with_like(
379
+ like, shape, fill_value, dtype=dtype, order=order, device=device
380
+ )
381
+
382
+ if dtype is None:
383
+ fill_value = asarray(fill_value)
384
+ dtype = fill_value.dtype
385
+ a = empty(shape, dtype, order, device=device)
386
+ multiarray.copyto(a, fill_value, casting='unsafe')
387
+ return a
388
+
389
+
390
+ _full_with_like = array_function_dispatch()(full)
391
+
392
+
393
+ def _full_like_dispatcher(
394
+ a, fill_value, dtype=None, order=None, subok=None, shape=None,
395
+ *, device=None
396
+ ):
397
+ return (a,)
398
+
399
+
400
+ @array_function_dispatch(_full_like_dispatcher)
401
+ def full_like(
402
+ a, fill_value, dtype=None, order='K', subok=True, shape=None,
403
+ *, device=None
404
+ ):
405
+ """
406
+ Return a full array with the same shape and type as a given array.
407
+
408
+ Parameters
409
+ ----------
410
+ a : array_like
411
+ The shape and data-type of `a` define these same attributes of
412
+ the returned array.
413
+ fill_value : array_like
414
+ Fill value.
415
+ dtype : data-type, optional
416
+ Overrides the data type of the result.
417
+ order : {'C', 'F', 'A', or 'K'}, optional
418
+ Overrides the memory layout of the result. 'C' means C-order,
419
+ 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
420
+ 'C' otherwise. 'K' means match the layout of `a` as closely
421
+ as possible.
422
+ subok : bool, optional.
423
+ If True, then the newly created array will use the sub-class
424
+ type of `a`, otherwise it will be a base-class array. Defaults
425
+ to True.
426
+ shape : int or sequence of ints, optional.
427
+ Overrides the shape of the result. If order='K' and the number of
428
+ dimensions is unchanged, will try to keep order, otherwise,
429
+ order='C' is implied.
430
+ device : str, optional
431
+ The device on which to place the created array. Default: None.
432
+ For Array-API interoperability only, so must be ``"cpu"`` if passed.
433
+
434
+ .. versionadded:: 2.0.0
435
+
436
+ Returns
437
+ -------
438
+ out : ndarray
439
+ Array of `fill_value` with the same shape and type as `a`.
440
+
441
+ See Also
442
+ --------
443
+ empty_like : Return an empty array with shape and type of input.
444
+ ones_like : Return an array of ones with shape and type of input.
445
+ zeros_like : Return an array of zeros with shape and type of input.
446
+ full : Return a new array of given shape filled with value.
447
+
448
+ Examples
449
+ --------
450
+ >>> import numpy as np
451
+ >>> x = np.arange(6, dtype=np.int_)
452
+ >>> np.full_like(x, 1)
453
+ array([1, 1, 1, 1, 1, 1])
454
+ >>> np.full_like(x, 0.1)
455
+ array([0, 0, 0, 0, 0, 0])
456
+ >>> np.full_like(x, 0.1, dtype=np.float64)
457
+ array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
458
+ >>> np.full_like(x, np.nan, dtype=np.float64)
459
+ array([nan, nan, nan, nan, nan, nan])
460
+
461
+ >>> y = np.arange(6, dtype=np.float64)
462
+ >>> np.full_like(y, 0.1)
463
+ array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
464
+
465
+ >>> y = np.zeros([2, 2, 3], dtype=np.int_)
466
+ >>> np.full_like(y, [0, 0, 255])
467
+ array([[[ 0, 0, 255],
468
+ [ 0, 0, 255]],
469
+ [[ 0, 0, 255],
470
+ [ 0, 0, 255]]])
471
+ """
472
+ res = empty_like(
473
+ a, dtype=dtype, order=order, subok=subok, shape=shape, device=device
474
+ )
475
+ multiarray.copyto(res, fill_value, casting='unsafe')
476
+ return res
477
+
478
+
479
+ def _count_nonzero_dispatcher(a, axis=None, *, keepdims=None):
480
+ return (a,)
481
+
482
+
483
+ @array_function_dispatch(_count_nonzero_dispatcher)
484
+ def count_nonzero(a, axis=None, *, keepdims=False):
485
+ """
486
+ Counts the number of non-zero values in the array ``a``.
487
+
488
+ A non-zero value is one that evaluates to truthful in a boolean
489
+ context, including any non-zero number and any string that
490
+ is not empty. This function recursively counts how many elements
491
+ in ``a`` (and its sub-arrays) are non-zero values.
492
+
493
+ Parameters
494
+ ----------
495
+ a : array_like
496
+ The array for which to count non-zeros.
497
+ axis : int or tuple, optional
498
+ Axis or tuple of axes along which to count non-zeros.
499
+ Default is None, meaning that non-zeros will be counted
500
+ along a flattened version of ``a``.
501
+ keepdims : bool, optional
502
+ If this is set to True, the axes that are counted are left
503
+ in the result as dimensions with size one. With this option,
504
+ the result will broadcast correctly against the input array.
505
+
506
+ Returns
507
+ -------
508
+ count : int or array of int
509
+ Number of non-zero values in the array along a given axis.
510
+ Otherwise, the total number of non-zero values in the array
511
+ is returned.
512
+
513
+ See Also
514
+ --------
515
+ nonzero : Return the coordinates of all the non-zero values.
516
+
517
+ Examples
518
+ --------
519
+ >>> import numpy as np
520
+ >>> np.count_nonzero(np.eye(4))
521
+ np.int64(4)
522
+ >>> a = np.array([[0, 1, 7, 0],
523
+ ... [3, 0, 2, 19]])
524
+ >>> np.count_nonzero(a)
525
+ np.int64(5)
526
+ >>> np.count_nonzero(a, axis=0)
527
+ array([1, 1, 2, 1])
528
+ >>> np.count_nonzero(a, axis=1)
529
+ array([2, 3])
530
+ >>> np.count_nonzero(a, axis=1, keepdims=True)
531
+ array([[2],
532
+ [3]])
533
+ """
534
+ if axis is None and not keepdims:
535
+ return multiarray.count_nonzero(a)
536
+
537
+ a = asanyarray(a)
538
+
539
+ # This is a performance optimization for character dtypes
540
+ # TODO: this can be removed if the legacy fixed-width string dtypes are ever removed
541
+ if np.issubdtype(a.dtype, np.character):
542
+ a_bool = a != a.dtype.type()
543
+ else:
544
+ a_bool = a.astype(np.bool, copy=False)
545
+
546
+ return a_bool.sum(axis=axis, dtype=np.intp, keepdims=keepdims)
547
+
548
+
549
+ @set_module('numpy')
550
+ def isfortran(a):
551
+ """
552
+ Check if the array is Fortran contiguous but *not* C contiguous.
553
+
554
+ This function is obsolete. If you only want to check if an array is Fortran
555
+ contiguous use ``a.flags.f_contiguous`` instead.
556
+
557
+ Parameters
558
+ ----------
559
+ a : ndarray
560
+ Input array.
561
+
562
+ Returns
563
+ -------
564
+ isfortran : bool
565
+ Returns True if the array is Fortran contiguous but *not* C contiguous.
566
+
567
+
568
+ Examples
569
+ --------
570
+
571
+ np.array allows to specify whether the array is written in C-contiguous
572
+ order (last index varies the fastest), or FORTRAN-contiguous order in
573
+ memory (first index varies the fastest).
574
+
575
+ >>> import numpy as np
576
+ >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
577
+ >>> a
578
+ array([[1, 2, 3],
579
+ [4, 5, 6]])
580
+ >>> np.isfortran(a)
581
+ False
582
+
583
+ >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
584
+ >>> b
585
+ array([[1, 2, 3],
586
+ [4, 5, 6]])
587
+ >>> np.isfortran(b)
588
+ True
589
+
590
+
591
+ The transpose of a C-ordered array is a FORTRAN-ordered array.
592
+
593
+ >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
594
+ >>> a
595
+ array([[1, 2, 3],
596
+ [4, 5, 6]])
597
+ >>> np.isfortran(a)
598
+ False
599
+ >>> b = a.T
600
+ >>> b
601
+ array([[1, 4],
602
+ [2, 5],
603
+ [3, 6]])
604
+ >>> np.isfortran(b)
605
+ True
606
+
607
+ C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.
608
+
609
+ >>> np.isfortran(np.array([1, 2], order='F'))
610
+ False
611
+
612
+ """
613
+ return a.flags.fnc
614
+
615
+
616
+ def _argwhere_dispatcher(a):
617
+ return (a,)
618
+
619
+
620
+ @array_function_dispatch(_argwhere_dispatcher)
621
+ def argwhere(a):
622
+ """
623
+ Find the indices of array elements that are non-zero, grouped by element.
624
+
625
+ Parameters
626
+ ----------
627
+ a : array_like
628
+ Input data.
629
+
630
+ Returns
631
+ -------
632
+ index_array : (N, a.ndim) ndarray
633
+ Indices of elements that are non-zero. Indices are grouped by element.
634
+ This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
635
+ non-zero items.
636
+
637
+ See Also
638
+ --------
639
+ where, nonzero
640
+
641
+ Notes
642
+ -----
643
+ ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
644
+ but produces a result of the correct shape for a 0D array.
645
+
646
+ The output of ``argwhere`` is not suitable for indexing arrays.
647
+ For this purpose use ``nonzero(a)`` instead.
648
+
649
+ Examples
650
+ --------
651
+ >>> import numpy as np
652
+ >>> x = np.arange(6).reshape(2,3)
653
+ >>> x
654
+ array([[0, 1, 2],
655
+ [3, 4, 5]])
656
+ >>> np.argwhere(x>1)
657
+ array([[0, 2],
658
+ [1, 0],
659
+ [1, 1],
660
+ [1, 2]])
661
+
662
+ """
663
+ # nonzero does not behave well on 0d, so promote to 1d
664
+ if np.ndim(a) == 0:
665
+ a = shape_base.atleast_1d(a)
666
+ # then remove the added dimension
667
+ return argwhere(a)[:, :0]
668
+ return transpose(nonzero(a))
669
+
670
+
671
+ def _flatnonzero_dispatcher(a):
672
+ return (a,)
673
+
674
+
675
+ @array_function_dispatch(_flatnonzero_dispatcher)
676
+ def flatnonzero(a):
677
+ """
678
+ Return indices that are non-zero in the flattened version of a.
679
+
680
+ This is equivalent to ``np.nonzero(np.ravel(a))[0]``.
681
+
682
+ Parameters
683
+ ----------
684
+ a : array_like
685
+ Input data.
686
+
687
+ Returns
688
+ -------
689
+ res : ndarray
690
+ Output array, containing the indices of the elements of ``a.ravel()``
691
+ that are non-zero.
692
+
693
+ See Also
694
+ --------
695
+ nonzero : Return the indices of the non-zero elements of the input array.
696
+ ravel : Return a 1-D array containing the elements of the input array.
697
+
698
+ Examples
699
+ --------
700
+ >>> import numpy as np
701
+ >>> x = np.arange(-2, 3)
702
+ >>> x
703
+ array([-2, -1, 0, 1, 2])
704
+ >>> np.flatnonzero(x)
705
+ array([0, 1, 3, 4])
706
+
707
+ Use the indices of the non-zero elements as an index array to extract
708
+ these elements:
709
+
710
+ >>> x.ravel()[np.flatnonzero(x)]
711
+ array([-2, -1, 1, 2])
712
+
713
+ """
714
+ return np.nonzero(np.ravel(a))[0]
715
+
716
+
717
+ def _correlate_dispatcher(a, v, mode=None):
718
+ return (a, v)
719
+
720
+
721
+ @array_function_dispatch(_correlate_dispatcher)
722
+ def correlate(a, v, mode='valid'):
723
+ r"""
724
+ Cross-correlation of two 1-dimensional sequences.
725
+
726
+ This function computes the correlation as generally defined in signal
727
+ processing texts [1]_:
728
+
729
+ .. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n
730
+
731
+ with a and v sequences being zero-padded where necessary and
732
+ :math:`\overline v` denoting complex conjugation.
733
+
734
+ Parameters
735
+ ----------
736
+ a, v : array_like
737
+ Input sequences.
738
+ mode : {'valid', 'same', 'full'}, optional
739
+ Refer to the `convolve` docstring. Note that the default
740
+ is 'valid', unlike `convolve`, which uses 'full'.
741
+
742
+ Returns
743
+ -------
744
+ out : ndarray
745
+ Discrete cross-correlation of `a` and `v`.
746
+
747
+ See Also
748
+ --------
749
+ convolve : Discrete, linear convolution of two one-dimensional sequences.
750
+ scipy.signal.correlate : uses FFT which has superior performance
751
+ on large arrays.
752
+
753
+ Notes
754
+ -----
755
+ The definition of correlation above is not unique and sometimes
756
+ correlation may be defined differently. Another common definition is [1]_:
757
+
758
+ .. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}}
759
+
760
+ which is related to :math:`c_k` by :math:`c'_k = c_{-k}`.
761
+
762
+ `numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5)
763
+ because it does not use the FFT to compute the convolution; in that case,
764
+ `scipy.signal.correlate` might be preferable.
765
+
766
+ References
767
+ ----------
768
+ .. [1] Wikipedia, "Cross-correlation",
769
+ https://en.wikipedia.org/wiki/Cross-correlation
770
+
771
+ Examples
772
+ --------
773
+ >>> import numpy as np
774
+ >>> np.correlate([1, 2, 3], [0, 1, 0.5])
775
+ array([3.5])
776
+ >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
777
+ array([2. , 3.5, 3. ])
778
+ >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
779
+ array([0.5, 2. , 3.5, 3. , 0. ])
780
+
781
+ Using complex sequences:
782
+
783
+ >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
784
+ array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])
785
+
786
+ Note that you get the time reversed, complex conjugated result
787
+ (:math:`\overline{c_{-k}}`) when the two input sequences a and v change
788
+ places:
789
+
790
+ >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
791
+ array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])
792
+
793
+ """
794
+ return multiarray.correlate2(a, v, mode)
795
+
796
+
797
+ def _convolve_dispatcher(a, v, mode=None):
798
+ return (a, v)
799
+
800
+
801
+ @array_function_dispatch(_convolve_dispatcher)
802
+ def convolve(a, v, mode='full'):
803
+ """
804
+ Returns the discrete, linear convolution of two one-dimensional sequences.
805
+
806
+ The convolution operator is often seen in signal processing, where it
807
+ models the effect of a linear time-invariant system on a signal [1]_. In
808
+ probability theory, the sum of two independent random variables is
809
+ distributed according to the convolution of their individual
810
+ distributions.
811
+
812
+ If `v` is longer than `a`, the arrays are swapped before computation.
813
+
814
+ Parameters
815
+ ----------
816
+ a : (N,) array_like
817
+ First one-dimensional input array.
818
+ v : (M,) array_like
819
+ Second one-dimensional input array.
820
+ mode : {'full', 'valid', 'same'}, optional
821
+ 'full':
822
+ By default, mode is 'full'. This returns the convolution
823
+ at each point of overlap, with an output shape of (N+M-1,). At
824
+ the end-points of the convolution, the signals do not overlap
825
+ completely, and boundary effects may be seen.
826
+
827
+ 'same':
828
+ Mode 'same' returns output of length ``max(M, N)``. Boundary
829
+ effects are still visible.
830
+
831
+ 'valid':
832
+ Mode 'valid' returns output of length
833
+ ``max(M, N) - min(M, N) + 1``. The convolution product is only given
834
+ for points where the signals overlap completely. Values outside
835
+ the signal boundary have no effect.
836
+
837
+ Returns
838
+ -------
839
+ out : ndarray
840
+ Discrete, linear convolution of `a` and `v`.
841
+
842
+ See Also
843
+ --------
844
+ scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
845
+ Transform.
846
+ scipy.linalg.toeplitz : Used to construct the convolution operator.
847
+ polymul : Polynomial multiplication. Same output as convolve, but also
848
+ accepts poly1d objects as input.
849
+
850
+ Notes
851
+ -----
852
+ The discrete convolution operation is defined as
853
+
854
+ .. math:: (a * v)_n = \\sum_{m = -\\infty}^{\\infty} a_m v_{n - m}
855
+
856
+ It can be shown that a convolution :math:`x(t) * y(t)` in time/space
857
+ is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
858
+ domain, after appropriate padding (padding is necessary to prevent
859
+ circular convolution). Since multiplication is more efficient (faster)
860
+ than convolution, the function `scipy.signal.fftconvolve` exploits the
861
+ FFT to calculate the convolution of large data-sets.
862
+
863
+ References
864
+ ----------
865
+ .. [1] Wikipedia, "Convolution",
866
+ https://en.wikipedia.org/wiki/Convolution
867
+
868
+ Examples
869
+ --------
870
+ Note how the convolution operator flips the second array
871
+ before "sliding" the two across one another:
872
+
873
+ >>> import numpy as np
874
+ >>> np.convolve([1, 2, 3], [0, 1, 0.5])
875
+ array([0. , 1. , 2.5, 4. , 1.5])
876
+
877
+ Only return the middle values of the convolution.
878
+ Contains boundary effects, where zeros are taken
879
+ into account:
880
+
881
+ >>> np.convolve([1,2,3],[0,1,0.5], 'same')
882
+ array([1. , 2.5, 4. ])
883
+
884
+ The two arrays are of the same length, so there
885
+ is only one position where they completely overlap:
886
+
887
+ >>> np.convolve([1,2,3],[0,1,0.5], 'valid')
888
+ array([2.5])
889
+
890
+ """
891
+ a, v = array(a, copy=None, ndmin=1), array(v, copy=None, ndmin=1)
892
+ if len(a) == 0:
893
+ raise ValueError('a cannot be empty')
894
+ if len(v) == 0:
895
+ raise ValueError('v cannot be empty')
896
+ if len(v) > len(a):
897
+ a, v = v, a
898
+ return multiarray.correlate(a, v[::-1], mode)
899
+
900
+
901
+ def _outer_dispatcher(a, b, out=None):
902
+ return (a, b, out)
903
+
904
+
905
+ @array_function_dispatch(_outer_dispatcher)
906
+ def outer(a, b, out=None):
907
+ """
908
+ Compute the outer product of two vectors.
909
+
910
+ Given two vectors `a` and `b` of length ``M`` and ``N``, respectively,
911
+ the outer product [1]_ is::
912
+
913
+ [[a_0*b_0 a_0*b_1 ... a_0*b_{N-1} ]
914
+ [a_1*b_0 .
915
+ [ ... .
916
+ [a_{M-1}*b_0 a_{M-1}*b_{N-1} ]]
917
+
918
+ Parameters
919
+ ----------
920
+ a : (M,) array_like
921
+ First input vector. Input is flattened if
922
+ not already 1-dimensional.
923
+ b : (N,) array_like
924
+ Second input vector. Input is flattened if
925
+ not already 1-dimensional.
926
+ out : (M, N) ndarray, optional
927
+ A location where the result is stored
928
+
929
+ Returns
930
+ -------
931
+ out : (M, N) ndarray
932
+ ``out[i, j] = a[i] * b[j]``
933
+
934
+ See also
935
+ --------
936
+ inner
937
+ einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
938
+ ufunc.outer : A generalization to dimensions other than 1D and other
939
+ operations. ``np.multiply.outer(a.ravel(), b.ravel())``
940
+ is the equivalent.
941
+ linalg.outer : An Array API compatible variation of ``np.outer``,
942
+ which accepts 1-dimensional inputs only.
943
+ tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))``
944
+ is the equivalent.
945
+
946
+ References
947
+ ----------
948
+ .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
949
+ ed., Baltimore, MD, Johns Hopkins University Press, 1996,
950
+ pg. 8.
951
+
952
+ Examples
953
+ --------
954
+ Make a (*very* coarse) grid for computing a Mandelbrot set:
955
+
956
+ >>> import numpy as np
957
+ >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
958
+ >>> rl
959
+ array([[-2., -1., 0., 1., 2.],
960
+ [-2., -1., 0., 1., 2.],
961
+ [-2., -1., 0., 1., 2.],
962
+ [-2., -1., 0., 1., 2.],
963
+ [-2., -1., 0., 1., 2.]])
964
+ >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
965
+ >>> im
966
+ array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
967
+ [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
968
+ [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
969
+ [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
970
+ [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
971
+ >>> grid = rl + im
972
+ >>> grid
973
+ array([[-2.+2.j, -1.+2.j, 0.+2.j, 1.+2.j, 2.+2.j],
974
+ [-2.+1.j, -1.+1.j, 0.+1.j, 1.+1.j, 2.+1.j],
975
+ [-2.+0.j, -1.+0.j, 0.+0.j, 1.+0.j, 2.+0.j],
976
+ [-2.-1.j, -1.-1.j, 0.-1.j, 1.-1.j, 2.-1.j],
977
+ [-2.-2.j, -1.-2.j, 0.-2.j, 1.-2.j, 2.-2.j]])
978
+
979
+ An example using a "vector" of letters:
980
+
981
+ >>> x = np.array(['a', 'b', 'c'], dtype=np.object_)
982
+ >>> np.outer(x, [1, 2, 3])
983
+ array([['a', 'aa', 'aaa'],
984
+ ['b', 'bb', 'bbb'],
985
+ ['c', 'cc', 'ccc']], dtype=object)
986
+
987
+ """
988
+ a = asarray(a)
989
+ b = asarray(b)
990
+ return multiply(a.ravel()[:, newaxis], b.ravel()[newaxis, :], out)
991
+
992
+
993
+ def _tensordot_dispatcher(a, b, axes=None):
994
+ return (a, b)
995
+
996
+
997
+ @array_function_dispatch(_tensordot_dispatcher)
998
+ def tensordot(a, b, axes=2):
999
+ """
1000
+ Compute tensor dot product along specified axes.
1001
+
1002
+ Given two tensors, `a` and `b`, and an array_like object containing
1003
+ two array_like objects, ``(a_axes, b_axes)``, sum the products of
1004
+ `a`'s and `b`'s elements (components) over the axes specified by
1005
+ ``a_axes`` and ``b_axes``. The third argument can be a single non-negative
1006
+ integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
1007
+ of `a` and the first ``N`` dimensions of `b` are summed over.
1008
+
1009
+ Parameters
1010
+ ----------
1011
+ a, b : array_like
1012
+ Tensors to "dot".
1013
+
1014
+ axes : int or (2,) array_like
1015
+ * integer_like
1016
+ If an int N, sum over the last N axes of `a` and the first N axes
1017
+ of `b` in order. The sizes of the corresponding axes must match.
1018
+ * (2,) array_like
1019
+ Or, a list of axes to be summed over, first sequence applying to `a`,
1020
+ second to `b`. Both elements array_like must be of the same length.
1021
+ Each axis may appear at most once; repeated axes are not allowed.
1022
+ For example, ``axes=([1, 1], [0, 0])`` is invalid.
1023
+ Returns
1024
+ -------
1025
+ output : ndarray
1026
+ The tensor dot product of the input.
1027
+
1028
+ See Also
1029
+ --------
1030
+ dot, einsum
1031
+
1032
+ Notes
1033
+ -----
1034
+ Three common use cases are:
1035
+ * ``axes = 0`` : tensor product :math:`a\\otimes b`
1036
+ * ``axes = 1`` : tensor dot product :math:`a\\cdot b`
1037
+ * ``axes = 2`` : (default) tensor double contraction :math:`a:b`
1038
+
1039
+ When `axes` is integer_like, the sequence of axes for evaluation
1040
+ will be: from the -Nth axis to the -1th axis in `a`,
1041
+ and from the 0th axis to (N-1)th axis in `b`.
1042
+ For example, ``axes = 2`` is the equal to
1043
+ ``axes = [[-2, -1], [0, 1]]``.
1044
+ When N-1 is smaller than 0, or when -N is larger than -1,
1045
+ the element of `a` and `b` are defined as the `axes`.
1046
+
1047
+ When there is more than one axis to sum over - and they are not the last
1048
+ (first) axes of `a` (`b`) - the argument `axes` should consist of
1049
+ two sequences of the same length, with the first axis to sum over given
1050
+ first in both sequences, the second axis second, and so forth.
1051
+ The calculation can be referred to ``numpy.einsum``.
1052
+
1053
+ For example, if ``a.shape == (2, 3, 4)`` and ``b.shape == (3, 4, 5)``,
1054
+ then ``axes=([1, 2], [0, 1])`` sums over the ``(3, 4)`` dimensions of
1055
+ both arrays and produces an output of shape ``(2, 5)``.
1056
+
1057
+ Each summation axis corresponds to a distinct contraction index; repeating
1058
+ an axis (for example ``axes=([1, 1], [0, 0])``) is invalid.
1059
+
1060
+ The shape of the result consists of the non-contracted axes of the
1061
+ first tensor, followed by the non-contracted axes of the second.
1062
+
1063
+ Examples
1064
+ --------
1065
+ An example on integer_like:
1066
+
1067
+ >>> a_0 = np.array([[1, 2], [3, 4]])
1068
+ >>> b_0 = np.array([[5, 6], [7, 8]])
1069
+ >>> c_0 = np.tensordot(a_0, b_0, axes=0)
1070
+ >>> c_0.shape
1071
+ (2, 2, 2, 2)
1072
+ >>> c_0
1073
+ array([[[[ 5, 6],
1074
+ [ 7, 8]],
1075
+ [[10, 12],
1076
+ [14, 16]]],
1077
+ [[[15, 18],
1078
+ [21, 24]],
1079
+ [[20, 24],
1080
+ [28, 32]]]])
1081
+
1082
+ An example on array_like:
1083
+
1084
+ >>> a = np.arange(60.).reshape(3,4,5)
1085
+ >>> b = np.arange(24.).reshape(4,3,2)
1086
+ >>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
1087
+ >>> c.shape
1088
+ (5, 2)
1089
+ >>> c
1090
+ array([[4400., 4730.],
1091
+ [4532., 4874.],
1092
+ [4664., 5018.],
1093
+ [4796., 5162.],
1094
+ [4928., 5306.]])
1095
+
1096
+ A slower but equivalent way of computing the same...
1097
+
1098
+ >>> d = np.zeros((5,2))
1099
+ >>> for i in range(5):
1100
+ ... for j in range(2):
1101
+ ... for k in range(3):
1102
+ ... for n in range(4):
1103
+ ... d[i,j] += a[k,n,i] * b[n,k,j]
1104
+ >>> c == d
1105
+ array([[ True, True],
1106
+ [ True, True],
1107
+ [ True, True],
1108
+ [ True, True],
1109
+ [ True, True]])
1110
+
1111
+ An extended example taking advantage of the overloading of + and \\*:
1112
+
1113
+ >>> a = np.array(range(1, 9)).reshape((2, 2, 2))
1114
+ >>> A = np.array(('a', 'b', 'c', 'd'), dtype=np.object_)
1115
+ >>> A = A.reshape((2, 2))
1116
+ >>> a; A
1117
+ array([[[1, 2],
1118
+ [3, 4]],
1119
+ [[5, 6],
1120
+ [7, 8]]])
1121
+ array([['a', 'b'],
1122
+ ['c', 'd']], dtype=object)
1123
+
1124
+ >>> np.tensordot(a, A) # third argument default is 2 for double-contraction
1125
+ array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)
1126
+
1127
+ >>> np.tensordot(a, A, 1)
1128
+ array([[['acc', 'bdd'],
1129
+ ['aaacccc', 'bbbdddd']],
1130
+ [['aaaaacccccc', 'bbbbbdddddd'],
1131
+ ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)
1132
+
1133
+ >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
1134
+ array([[[[['a', 'b'],
1135
+ ['c', 'd']],
1136
+ ...
1137
+
1138
+ >>> np.tensordot(a, A, (0, 1))
1139
+ array([[['abbbbb', 'cddddd'],
1140
+ ['aabbbbbb', 'ccdddddd']],
1141
+ [['aaabbbbbbb', 'cccddddddd'],
1142
+ ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)
1143
+
1144
+ >>> np.tensordot(a, A, (2, 1))
1145
+ array([[['abb', 'cdd'],
1146
+ ['aaabbbb', 'cccdddd']],
1147
+ [['aaaaabbbbbb', 'cccccdddddd'],
1148
+ ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)
1149
+
1150
+ >>> np.tensordot(a, A, ((0, 1), (0, 1)))
1151
+ array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)
1152
+
1153
+ >>> np.tensordot(a, A, ((2, 1), (1, 0)))
1154
+ array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)
1155
+
1156
+ """
1157
+ try:
1158
+ iter(axes)
1159
+ except Exception:
1160
+ axes_a = list(range(-axes, 0))
1161
+ axes_b = list(range(axes))
1162
+ else:
1163
+ axes_a, axes_b = axes
1164
+ try:
1165
+ na = len(axes_a)
1166
+ axes_a = list(axes_a)
1167
+ except TypeError:
1168
+ axes_a = [axes_a]
1169
+ na = 1
1170
+ try:
1171
+ nb = len(axes_b)
1172
+ axes_b = list(axes_b)
1173
+ except TypeError:
1174
+ axes_b = [axes_b]
1175
+ nb = 1
1176
+
1177
+ if len(set(axes_a)) != len(axes_a):
1178
+ raise ValueError("duplicate axes are not allowed in tensordot")
1179
+ if len(set(axes_b)) != len(axes_b):
1180
+ raise ValueError("duplicate axes are not allowed in tensordot")
1181
+
1182
+ a, b = asarray(a), asarray(b)
1183
+ as_ = a.shape
1184
+ nda = a.ndim
1185
+ bs = b.shape
1186
+ ndb = b.ndim
1187
+ equal = True
1188
+ if na != nb:
1189
+ equal = False
1190
+ else:
1191
+ for k in range(na):
1192
+ if as_[axes_a[k]] != bs[axes_b[k]]:
1193
+ equal = False
1194
+ break
1195
+ if axes_a[k] < 0:
1196
+ axes_a[k] += nda
1197
+ if axes_b[k] < 0:
1198
+ axes_b[k] += ndb
1199
+ if not equal:
1200
+ raise ValueError("shape-mismatch for sum")
1201
+
1202
+ # Move the axes to sum over to the end of "a"
1203
+ # and to the front of "b"
1204
+ notin = [k for k in range(nda) if k not in axes_a]
1205
+ newaxes_a = notin + axes_a
1206
+ N2 = math.prod(as_[axis] for axis in axes_a)
1207
+ newshape_a = (math.prod(as_[ax] for ax in notin), N2)
1208
+ olda = [as_[axis] for axis in notin]
1209
+
1210
+ notin = [k for k in range(ndb) if k not in axes_b]
1211
+ newaxes_b = axes_b + notin
1212
+ N2 = math.prod(bs[axis] for axis in axes_b)
1213
+ newshape_b = (N2, math.prod(bs[ax] for ax in notin))
1214
+ oldb = [bs[axis] for axis in notin]
1215
+
1216
+ at = a.transpose(newaxes_a).reshape(newshape_a)
1217
+ bt = b.transpose(newaxes_b).reshape(newshape_b)
1218
+ res = dot(at, bt)
1219
+ return res.reshape(olda + oldb)
1220
+
1221
+
1222
+ def _roll_dispatcher(a, shift, axis=None):
1223
+ return (a,)
1224
+
1225
+
1226
+ @array_function_dispatch(_roll_dispatcher)
1227
+ def roll(a, shift, axis=None):
1228
+ """
1229
+ Roll array elements along a given axis.
1230
+
1231
+ Elements that roll beyond the last position are re-introduced at
1232
+ the first.
1233
+
1234
+ Parameters
1235
+ ----------
1236
+ a : array_like
1237
+ Input array.
1238
+ shift : int or tuple of ints
1239
+ The number of places by which elements are shifted. If a tuple,
1240
+ then `axis` must be a tuple of the same size, and each of the
1241
+ given axes is shifted by the corresponding number. If an int
1242
+ while `axis` is a tuple of ints, then the same value is used for
1243
+ all given axes.
1244
+ axis : int or tuple of ints, optional
1245
+ Axis or axes along which elements are shifted. By default, the
1246
+ array is flattened before shifting, after which the original
1247
+ shape is restored.
1248
+
1249
+ Returns
1250
+ -------
1251
+ res : ndarray
1252
+ Output array, with the same shape as `a`.
1253
+
1254
+ See Also
1255
+ --------
1256
+ rollaxis : Roll the specified axis backwards, until it lies in a
1257
+ given position.
1258
+
1259
+ Notes
1260
+ -----
1261
+ Supports rolling over multiple dimensions simultaneously.
1262
+
1263
+ Examples
1264
+ --------
1265
+ >>> import numpy as np
1266
+ >>> x = np.arange(10)
1267
+ >>> np.roll(x, 2)
1268
+ array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
1269
+ >>> np.roll(x, -2)
1270
+ array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])
1271
+
1272
+ >>> x2 = np.reshape(x, (2, 5))
1273
+ >>> x2
1274
+ array([[0, 1, 2, 3, 4],
1275
+ [5, 6, 7, 8, 9]])
1276
+ >>> np.roll(x2, 1)
1277
+ array([[9, 0, 1, 2, 3],
1278
+ [4, 5, 6, 7, 8]])
1279
+ >>> np.roll(x2, -1)
1280
+ array([[1, 2, 3, 4, 5],
1281
+ [6, 7, 8, 9, 0]])
1282
+ >>> np.roll(x2, 1, axis=0)
1283
+ array([[5, 6, 7, 8, 9],
1284
+ [0, 1, 2, 3, 4]])
1285
+ >>> np.roll(x2, -1, axis=0)
1286
+ array([[5, 6, 7, 8, 9],
1287
+ [0, 1, 2, 3, 4]])
1288
+ >>> np.roll(x2, 1, axis=1)
1289
+ array([[4, 0, 1, 2, 3],
1290
+ [9, 5, 6, 7, 8]])
1291
+ >>> np.roll(x2, -1, axis=1)
1292
+ array([[1, 2, 3, 4, 0],
1293
+ [6, 7, 8, 9, 5]])
1294
+ >>> np.roll(x2, (1, 1), axis=(1, 0))
1295
+ array([[9, 5, 6, 7, 8],
1296
+ [4, 0, 1, 2, 3]])
1297
+ >>> np.roll(x2, (2, 1), axis=(1, 0))
1298
+ array([[8, 9, 5, 6, 7],
1299
+ [3, 4, 0, 1, 2]])
1300
+
1301
+ """
1302
+ a = asanyarray(a)
1303
+ if axis is None:
1304
+ return roll(a.ravel(), shift, 0).reshape(a.shape)
1305
+
1306
+ else:
1307
+ axis = normalize_axis_tuple(axis, a.ndim, allow_duplicate=True)
1308
+ broadcasted = broadcast(shift, axis)
1309
+ if broadcasted.ndim > 1:
1310
+ raise ValueError(
1311
+ "'shift' and 'axis' should be scalars or 1D sequences")
1312
+ shifts = dict.fromkeys(range(a.ndim), 0)
1313
+ for sh, ax in broadcasted:
1314
+ shifts[ax] += int(sh)
1315
+
1316
+ rolls = [((slice(None), slice(None)),)] * a.ndim
1317
+ for ax, offset in shifts.items():
1318
+ offset %= a.shape[ax] or 1 # If `a` is empty, nothing matters.
1319
+ if offset:
1320
+ # (original, result), (original, result)
1321
+ rolls[ax] = ((slice(None, -offset), slice(offset, None)),
1322
+ (slice(-offset, None), slice(None, offset)))
1323
+
1324
+ result = empty_like(a)
1325
+ for indices in itertools.product(*rolls):
1326
+ arr_index, res_index = zip(*indices)
1327
+ result[res_index] = a[arr_index]
1328
+
1329
+ return result
1330
+
1331
+
1332
+ def _rollaxis_dispatcher(a, axis, start=None):
1333
+ return (a,)
1334
+
1335
+
1336
+ @array_function_dispatch(_rollaxis_dispatcher)
1337
+ def rollaxis(a, axis, start=0):
1338
+ """
1339
+ Roll the specified axis backwards, until it lies in a given position.
1340
+
1341
+ This function continues to be supported for backward compatibility, but you
1342
+ should prefer `moveaxis`. The `moveaxis` function was added in NumPy
1343
+ 1.11.
1344
+
1345
+ Parameters
1346
+ ----------
1347
+ a : ndarray
1348
+ Input array.
1349
+ axis : int
1350
+ The axis to be rolled. The positions of the other axes do not
1351
+ change relative to one another.
1352
+ start : int, optional
1353
+ When ``start <= axis``, the axis is rolled back until it lies in
1354
+ this position. When ``start > axis``, the axis is rolled until it
1355
+ lies before this position. The default, 0, results in a "complete"
1356
+ roll. The following table describes how negative values of ``start``
1357
+ are interpreted:
1358
+
1359
+ .. table::
1360
+ :align: left
1361
+
1362
+ +-------------------+----------------------+
1363
+ | ``start`` | Normalized ``start`` |
1364
+ +===================+======================+
1365
+ | ``-(arr.ndim+1)`` | raise ``AxisError`` |
1366
+ +-------------------+----------------------+
1367
+ | ``-arr.ndim`` | 0 |
1368
+ +-------------------+----------------------+
1369
+ | |vdots| | |vdots| |
1370
+ +-------------------+----------------------+
1371
+ | ``-1`` | ``arr.ndim-1`` |
1372
+ +-------------------+----------------------+
1373
+ | ``0`` | ``0`` |
1374
+ +-------------------+----------------------+
1375
+ | |vdots| | |vdots| |
1376
+ +-------------------+----------------------+
1377
+ | ``arr.ndim`` | ``arr.ndim`` |
1378
+ +-------------------+----------------------+
1379
+ | ``arr.ndim + 1`` | raise ``AxisError`` |
1380
+ +-------------------+----------------------+
1381
+
1382
+ .. |vdots| unicode:: U+22EE .. Vertical Ellipsis
1383
+
1384
+ Returns
1385
+ -------
1386
+ res : ndarray
1387
+ For NumPy >= 1.10.0 a view of `a` is always returned. For earlier
1388
+ NumPy versions a view of `a` is returned only if the order of the
1389
+ axes is changed, otherwise the input array is returned.
1390
+
1391
+ See Also
1392
+ --------
1393
+ moveaxis : Move array axes to new positions.
1394
+ roll : Roll the elements of an array by a number of positions along a
1395
+ given axis.
1396
+
1397
+ Examples
1398
+ --------
1399
+ >>> import numpy as np
1400
+ >>> a = np.ones((3,4,5,6))
1401
+ >>> np.rollaxis(a, 3, 1).shape
1402
+ (3, 6, 4, 5)
1403
+ >>> np.rollaxis(a, 2).shape
1404
+ (5, 3, 4, 6)
1405
+ >>> np.rollaxis(a, 1, 4).shape
1406
+ (3, 5, 6, 4)
1407
+
1408
+ """
1409
+ n = a.ndim
1410
+ axis = normalize_axis_index(axis, n)
1411
+ if start < 0:
1412
+ start += n
1413
+ msg = "'%s' arg requires %d <= %s < %d, but %d was passed in"
1414
+ if not (0 <= start < n + 1):
1415
+ raise AxisError(msg % ('start', -n, 'start', n + 1, start))
1416
+ if axis < start:
1417
+ # it's been removed
1418
+ start -= 1
1419
+ if axis == start:
1420
+ return a[...]
1421
+ axes = list(range(n))
1422
+ axes.remove(axis)
1423
+ axes.insert(start, axis)
1424
+ return a.transpose(axes)
1425
+
1426
+
1427
+ @set_module("numpy.lib.array_utils")
1428
+ def normalize_axis_tuple(axis, ndim, argname=None, allow_duplicate=False):
1429
+ """
1430
+ Normalizes an axis argument into a tuple of non-negative integer axes.
1431
+
1432
+ This handles shorthands such as ``1`` and converts them to ``(1,)``,
1433
+ as well as performing the handling of negative indices covered by
1434
+ `normalize_axis_index`.
1435
+
1436
+ By default, this forbids axes from being specified multiple times.
1437
+
1438
+ Used internally by multi-axis-checking logic.
1439
+
1440
+ Parameters
1441
+ ----------
1442
+ axis : int, iterable of int
1443
+ The un-normalized index or indices of the axis.
1444
+ ndim : int
1445
+ The number of dimensions of the array that `axis` should be normalized
1446
+ against.
1447
+ argname : str, optional
1448
+ A prefix to put before the error message, typically the name of the
1449
+ argument.
1450
+ allow_duplicate : bool, optional
1451
+ If False, the default, disallow an axis from being specified twice.
1452
+
1453
+ Returns
1454
+ -------
1455
+ normalized_axes : tuple of int
1456
+ The normalized axis index, such that `0 <= normalized_axis < ndim`
1457
+
1458
+ Raises
1459
+ ------
1460
+ AxisError
1461
+ If any axis provided is out of range
1462
+ ValueError
1463
+ If an axis is repeated
1464
+
1465
+ See also
1466
+ --------
1467
+ normalize_axis_index : normalizing a single scalar axis
1468
+ """
1469
+ # Optimization to speed-up the most common cases.
1470
+ if not isinstance(axis, (tuple, list)):
1471
+ try:
1472
+ axis = [operator.index(axis)]
1473
+ except TypeError:
1474
+ pass
1475
+ # Going via an iterator directly is slower than via list comprehension.
1476
+ axis = tuple(normalize_axis_index(ax, ndim, argname) for ax in axis)
1477
+ if not allow_duplicate and len(set(axis)) != len(axis):
1478
+ if argname:
1479
+ raise ValueError(f'repeated axis in `{argname}` argument')
1480
+ else:
1481
+ raise ValueError('repeated axis')
1482
+ return axis
1483
+
1484
+
1485
+ def _moveaxis_dispatcher(a, source, destination):
1486
+ return (a,)
1487
+
1488
+
1489
+ @array_function_dispatch(_moveaxis_dispatcher)
1490
+ def moveaxis(a, source, destination):
1491
+ """
1492
+ Move axes of an array to new positions.
1493
+
1494
+ Other axes remain in their original order.
1495
+
1496
+ Parameters
1497
+ ----------
1498
+ a : np.ndarray
1499
+ The array whose axes should be reordered.
1500
+ source : int or sequence of int
1501
+ Original positions of the axes to move. These must be unique.
1502
+ destination : int or sequence of int
1503
+ Destination positions for each of the original axes. These must also be
1504
+ unique.
1505
+
1506
+ Returns
1507
+ -------
1508
+ result : np.ndarray
1509
+ Array with moved axes. This array is a view of the input array.
1510
+
1511
+ See Also
1512
+ --------
1513
+ transpose : Permute the dimensions of an array.
1514
+ swapaxes : Interchange two axes of an array.
1515
+
1516
+ Examples
1517
+ --------
1518
+ >>> import numpy as np
1519
+ >>> x = np.zeros((3, 4, 5))
1520
+ >>> np.moveaxis(x, 0, -1).shape
1521
+ (4, 5, 3)
1522
+ >>> np.moveaxis(x, -1, 0).shape
1523
+ (5, 3, 4)
1524
+
1525
+ These all achieve the same result:
1526
+
1527
+ >>> np.transpose(x).shape
1528
+ (5, 4, 3)
1529
+ >>> np.swapaxes(x, 0, -1).shape
1530
+ (5, 4, 3)
1531
+ >>> np.moveaxis(x, [0, 1], [-1, -2]).shape
1532
+ (5, 4, 3)
1533
+ >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
1534
+ (5, 4, 3)
1535
+
1536
+ """
1537
+ try:
1538
+ # allow duck-array types if they define transpose
1539
+ transpose = a.transpose
1540
+ except AttributeError:
1541
+ a = asarray(a)
1542
+ transpose = a.transpose
1543
+
1544
+ source = normalize_axis_tuple(source, a.ndim, 'source')
1545
+ destination = normalize_axis_tuple(destination, a.ndim, 'destination')
1546
+ if len(source) != len(destination):
1547
+ raise ValueError('`source` and `destination` arguments must have '
1548
+ 'the same number of elements')
1549
+
1550
+ order = [n for n in range(a.ndim) if n not in source]
1551
+
1552
+ for dest, src in sorted(zip(destination, source)):
1553
+ order.insert(dest, src)
1554
+
1555
+ result = transpose(order)
1556
+ return result
1557
+
1558
+
1559
+ def _cross_dispatcher(a, b, axisa=None, axisb=None, axisc=None, axis=None):
1560
+ return (a, b)
1561
+
1562
+
1563
+ @array_function_dispatch(_cross_dispatcher)
1564
+ def cross(a, b, axisa=-1, axisb=-1, axisc=-1, axis=None):
1565
+ """
1566
+ Return the cross product of two (arrays of) vectors.
1567
+
1568
+ The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
1569
+ to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors
1570
+ are defined by the last axis of `a` and `b` by default, and these axes
1571
+ must have 3 dimensions.
1572
+
1573
+ Parameters
1574
+ ----------
1575
+ a : array_like
1576
+ Components of the first vector(s).
1577
+ b : array_like
1578
+ Components of the second vector(s).
1579
+ axisa : int, optional
1580
+ Axis of `a` that defines the vector(s). By default, the last axis.
1581
+ axisb : int, optional
1582
+ Axis of `b` that defines the vector(s). By default, the last axis.
1583
+ axisc : int, optional
1584
+ Axis of `c` containing the cross product vector(s). By default, the last axis.
1585
+ axis : int, optional
1586
+ If defined, the axis of `a`, `b` and `c` that defines the vector(s)
1587
+ and cross product(s). Overrides `axisa`, `axisb` and `axisc`.
1588
+
1589
+ Returns
1590
+ -------
1591
+ c : ndarray
1592
+ Vector cross product(s).
1593
+
1594
+ Raises
1595
+ ------
1596
+ ValueError
1597
+ When the dimension of the vector(s) in `a` or `b` does not equal 3.
1598
+
1599
+ See Also
1600
+ --------
1601
+ inner : Inner product
1602
+ outer : Outer product.
1603
+ linalg.cross : An Array API compatible variation of ``np.cross``.
1604
+ ix_ : Construct index arrays.
1605
+
1606
+ Notes
1607
+ -----
1608
+ Supports full broadcasting of the inputs.
1609
+
1610
+ Examples
1611
+ --------
1612
+ Vector cross-product.
1613
+
1614
+ >>> import numpy as np
1615
+ >>> x = [1, 2, 3]
1616
+ >>> y = [4, 5, 6]
1617
+ >>> np.cross(x, y)
1618
+ array([-3, 6, -3])
1619
+
1620
+ One vector with dimension 2.
1621
+
1622
+ >>> x = [1, 2, 0]
1623
+ >>> y = [4, 5, 6]
1624
+ >>> np.cross(x, y)
1625
+ array([12, -6, -3])
1626
+
1627
+ Both vectors with dimension 2.
1628
+
1629
+ >>> x = [1, 2, 0]
1630
+ >>> y = [4, 5, 0]
1631
+ >>> np.cross(x, y)
1632
+ array([0, 0, -3])
1633
+
1634
+ Multiple vector cross-products. Note that the direction of the cross
1635
+ product vector is defined by the *right-hand rule*.
1636
+
1637
+ >>> x = np.array([[1,2,3], [4,5,6]])
1638
+ >>> y = np.array([[4,5,6], [1,2,3]])
1639
+ >>> np.cross(x, y)
1640
+ array([[-3, 6, -3],
1641
+ [ 3, -6, 3]])
1642
+
1643
+ The orientation of `c` can be changed using the `axisc` keyword.
1644
+
1645
+ >>> np.cross(x, y, axisc=0)
1646
+ array([[-3, 3],
1647
+ [ 6, -6],
1648
+ [-3, 3]])
1649
+
1650
+ Change the vector definition of `x` and `y` using `axisa` and `axisb`.
1651
+
1652
+ >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
1653
+ >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
1654
+ >>> np.cross(x, y)
1655
+ array([[ -6, 12, -6],
1656
+ [ 0, 0, 0],
1657
+ [ 6, -12, 6]])
1658
+ >>> np.cross(x, y, axisa=0, axisb=0)
1659
+ array([[-24, 48, -24],
1660
+ [-30, 60, -30],
1661
+ [-36, 72, -36]])
1662
+
1663
+ """
1664
+ if axis is not None:
1665
+ axisa, axisb, axisc = (axis,) * 3
1666
+ a = asarray(a)
1667
+ b = asarray(b)
1668
+
1669
+ if (a.ndim < 1) or (b.ndim < 1):
1670
+ raise ValueError("At least one array has zero dimension")
1671
+
1672
+ # Check axisa and axisb are within bounds
1673
+ axisa = normalize_axis_index(axisa, a.ndim, msg_prefix='axisa')
1674
+ axisb = normalize_axis_index(axisb, b.ndim, msg_prefix='axisb')
1675
+
1676
+ # Move working axis to the end of the shape
1677
+ a = moveaxis(a, axisa, -1)
1678
+ b = moveaxis(b, axisb, -1)
1679
+ if a.shape[-1] != 3 or b.shape[-1] != 3:
1680
+ raise ValueError(
1681
+ f"Both input arrays must be (arrays of) 3-dimensional vectors, "
1682
+ f"but they are {a.shape[-1]} and {b.shape[-1]} dimensional instead."
1683
+ )
1684
+
1685
+ # Create the output array
1686
+ shape = *broadcast(a[..., 0], b[..., 0]).shape, 3
1687
+ # Check axisc is within bounds
1688
+ axisc = normalize_axis_index(axisc, len(shape), msg_prefix='axisc')
1689
+ dtype = promote_types(a.dtype, b.dtype)
1690
+ cp = empty(shape, dtype)
1691
+
1692
+ # recast arrays as dtype
1693
+ a = a.astype(dtype)
1694
+ b = b.astype(dtype)
1695
+
1696
+ # create local aliases for readability
1697
+ a0 = a[..., 0]
1698
+ a1 = a[..., 1]
1699
+ a2 = a[..., 2]
1700
+ b0 = b[..., 0]
1701
+ b1 = b[..., 1]
1702
+ b2 = b[..., 2]
1703
+ cp0 = cp[..., 0]
1704
+ cp1 = cp[..., 1]
1705
+ cp2 = cp[..., 2]
1706
+
1707
+ # cp0 = a1 * b2 - a2 * b1
1708
+ # cp1 = a2 * b0 - a0 * b2
1709
+ # cp2 = a0 * b1 - a1 * b0
1710
+ multiply(a1, b2, out=cp0)
1711
+ tmp = np.multiply(a2, b1, out=...)
1712
+ cp0 -= tmp
1713
+ multiply(a2, b0, out=cp1)
1714
+ multiply(a0, b2, out=tmp)
1715
+ cp1 -= tmp
1716
+ multiply(a0, b1, out=cp2)
1717
+ multiply(a1, b0, out=tmp)
1718
+ cp2 -= tmp
1719
+
1720
+ return moveaxis(cp, -1, axisc)
1721
+
1722
+
1723
+ little_endian = (sys.byteorder == 'little')
1724
+
1725
+
1726
+ @set_module('numpy')
1727
+ def indices(dimensions, dtype=int, sparse=False):
1728
+ """
1729
+ Return an array representing the indices of a grid.
1730
+
1731
+ Compute an array where the subarrays contain index values 0, 1, ...
1732
+ varying only along the corresponding axis.
1733
+
1734
+ Parameters
1735
+ ----------
1736
+ dimensions : sequence of ints
1737
+ The shape of the grid.
1738
+ dtype : dtype, optional
1739
+ Data type of the result.
1740
+ sparse : boolean, optional
1741
+ Return a sparse representation of the grid instead of a dense
1742
+ representation. Default is False.
1743
+
1744
+ Returns
1745
+ -------
1746
+ grid : one ndarray or tuple of ndarrays
1747
+ If sparse is False:
1748
+ Returns one array of grid indices,
1749
+ ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
1750
+ If sparse is True:
1751
+ Returns a tuple of arrays, with
1752
+ ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
1753
+ dimensions[i] in the ith place
1754
+
1755
+ See Also
1756
+ --------
1757
+ mgrid, ogrid, meshgrid
1758
+
1759
+ Notes
1760
+ -----
1761
+ The output shape in the dense case is obtained by prepending the number
1762
+ of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
1763
+ is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
1764
+ ``(N, r0, ..., rN-1)``.
1765
+
1766
+ The subarrays ``grid[k]`` contains the N-D array of indices along the
1767
+ ``k-th`` axis. Explicitly::
1768
+
1769
+ grid[k, i0, i1, ..., iN-1] = ik
1770
+
1771
+ Examples
1772
+ --------
1773
+ >>> import numpy as np
1774
+ >>> grid = np.indices((2, 3))
1775
+ >>> grid.shape
1776
+ (2, 2, 3)
1777
+ >>> grid[0] # row indices
1778
+ array([[0, 0, 0],
1779
+ [1, 1, 1]])
1780
+ >>> grid[1] # column indices
1781
+ array([[0, 1, 2],
1782
+ [0, 1, 2]])
1783
+
1784
+ The indices can be used as an index into an array.
1785
+
1786
+ >>> x = np.arange(20).reshape(5, 4)
1787
+ >>> row, col = np.indices((2, 3))
1788
+ >>> x[row, col]
1789
+ array([[0, 1, 2],
1790
+ [4, 5, 6]])
1791
+
1792
+ Note that it would be more straightforward in the above example to
1793
+ extract the required elements directly with ``x[:2, :3]``.
1794
+
1795
+ If sparse is set to true, the grid will be returned in a sparse
1796
+ representation.
1797
+
1798
+ >>> i, j = np.indices((2, 3), sparse=True)
1799
+ >>> i.shape
1800
+ (2, 1)
1801
+ >>> j.shape
1802
+ (1, 3)
1803
+ >>> i # row indices
1804
+ array([[0],
1805
+ [1]])
1806
+ >>> j # column indices
1807
+ array([[0, 1, 2]])
1808
+
1809
+ """
1810
+ dimensions = tuple(dimensions)
1811
+ N = len(dimensions)
1812
+ shape = (1,) * N
1813
+ if sparse:
1814
+ res = ()
1815
+ else:
1816
+ res = empty((N,) + dimensions, dtype=dtype)
1817
+ for i, dim in enumerate(dimensions):
1818
+ idx = arange(dim, dtype=dtype).reshape(
1819
+ shape[:i] + (dim,) + shape[i + 1:]
1820
+ )
1821
+ if sparse:
1822
+ res = res + (idx,)
1823
+ else:
1824
+ res[i] = idx
1825
+ return res
1826
+
1827
+
1828
+ @finalize_array_function_like
1829
+ @set_module('numpy')
1830
+ def fromfunction(function, shape, *, dtype=float, like=None, **kwargs):
1831
+ """
1832
+ Construct an array by executing a function over each coordinate.
1833
+
1834
+ The resulting array therefore has a value ``fn(x, y, z)`` at
1835
+ coordinate ``(x, y, z)``.
1836
+
1837
+ Parameters
1838
+ ----------
1839
+ function : callable
1840
+ The function is called with N parameters, where N is the rank of
1841
+ `shape`. Each parameter represents the coordinates of the array
1842
+ varying along a specific axis. For example, if `shape`
1843
+ were ``(2, 2)``, then the parameters would be
1844
+ ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
1845
+ shape : (N,) tuple of ints
1846
+ Shape of the output array, which also determines the shape of
1847
+ the coordinate arrays passed to `function`.
1848
+ dtype : data-type, optional
1849
+ Data-type of the coordinate arrays passed to `function`.
1850
+ By default, `dtype` is float.
1851
+ ${ARRAY_FUNCTION_LIKE}
1852
+
1853
+ .. versionadded:: 1.20.0
1854
+
1855
+ Returns
1856
+ -------
1857
+ fromfunction : any
1858
+ The result of the call to `function` is passed back directly.
1859
+ Therefore the shape of `fromfunction` is completely determined by
1860
+ `function`. If `function` returns a scalar value, the shape of
1861
+ `fromfunction` would not match the `shape` parameter.
1862
+
1863
+ See Also
1864
+ --------
1865
+ indices, meshgrid
1866
+
1867
+ Notes
1868
+ -----
1869
+ Keywords other than `dtype` and `like` are passed to `function`.
1870
+
1871
+ Examples
1872
+ --------
1873
+ >>> import numpy as np
1874
+ >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=np.float64)
1875
+ array([[0., 0.],
1876
+ [1., 1.]])
1877
+
1878
+ >>> np.fromfunction(lambda i, j: j, (2, 2), dtype=np.float64)
1879
+ array([[0., 1.],
1880
+ [0., 1.]])
1881
+
1882
+ >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=np.int_)
1883
+ array([[ True, False, False],
1884
+ [False, True, False],
1885
+ [False, False, True]])
1886
+
1887
+ >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=np.int_)
1888
+ array([[0, 1, 2],
1889
+ [1, 2, 3],
1890
+ [2, 3, 4]])
1891
+
1892
+ """
1893
+ if like is not None:
1894
+ return _fromfunction_with_like(
1895
+ like, function, shape, dtype=dtype, **kwargs)
1896
+
1897
+ args = indices(shape, dtype=dtype)
1898
+ return function(*args, **kwargs)
1899
+
1900
+
1901
+ _fromfunction_with_like = array_function_dispatch()(fromfunction)
1902
+
1903
+
1904
+ def _frombuffer(buf, dtype, shape, order, axis_order=None):
1905
+ array = frombuffer(buf, dtype=dtype)
1906
+ if order == 'K' and axis_order is not None:
1907
+ return array.reshape(shape, order='C').transpose(axis_order)
1908
+ return array.reshape(shape, order=order)
1909
+
1910
+
1911
+ @set_module('numpy')
1912
+ def isscalar(element):
1913
+ """
1914
+ Returns True if the type of `element` is a scalar type.
1915
+
1916
+ Parameters
1917
+ ----------
1918
+ element : any
1919
+ Input argument, can be of any type and shape.
1920
+
1921
+ Returns
1922
+ -------
1923
+ val : bool
1924
+ True if `element` is a scalar type, False if it is not.
1925
+
1926
+ See Also
1927
+ --------
1928
+ ndim : Get the number of dimensions of an array
1929
+
1930
+ Notes
1931
+ -----
1932
+ If you need a stricter way to identify a *numerical* scalar, use
1933
+ ``isinstance(x, numbers.Number)``, as that returns ``False`` for most
1934
+ non-numerical elements such as strings.
1935
+
1936
+ In most cases ``np.ndim(x) == 0`` should be used instead of this function,
1937
+ as that will also return true for 0d arrays. This is how numpy overloads
1938
+ functions in the style of the ``dx`` arguments to `gradient` and
1939
+ the ``bins`` argument to `histogram`. Some key differences:
1940
+
1941
+ +------------------------------------+---------------+-------------------+
1942
+ | x |``isscalar(x)``|``np.ndim(x) == 0``|
1943
+ +====================================+===============+===================+
1944
+ | PEP 3141 numeric objects | ``True`` | ``True`` |
1945
+ | (including builtins) | | |
1946
+ +------------------------------------+---------------+-------------------+
1947
+ | builtin string and buffer objects | ``True`` | ``True`` |
1948
+ +------------------------------------+---------------+-------------------+
1949
+ | other builtin objects, like | ``False`` | ``True`` |
1950
+ | `pathlib.Path`, `Exception`, | | |
1951
+ | the result of `re.compile` | | |
1952
+ +------------------------------------+---------------+-------------------+
1953
+ | third-party objects like | ``False`` | ``True`` |
1954
+ | `matplotlib.figure.Figure` | | |
1955
+ +------------------------------------+---------------+-------------------+
1956
+ | zero-dimensional numpy arrays | ``False`` | ``True`` |
1957
+ +------------------------------------+---------------+-------------------+
1958
+ | other numpy arrays | ``False`` | ``False`` |
1959
+ +------------------------------------+---------------+-------------------+
1960
+ | `list`, `tuple`, and other | ``False`` | ``False`` |
1961
+ | sequence objects | | |
1962
+ +------------------------------------+---------------+-------------------+
1963
+
1964
+ Examples
1965
+ --------
1966
+ >>> import numpy as np
1967
+
1968
+ >>> np.isscalar(3.1)
1969
+ True
1970
+
1971
+ >>> np.isscalar(np.array(3.1))
1972
+ False
1973
+
1974
+ >>> np.isscalar([3.1])
1975
+ False
1976
+
1977
+ >>> np.isscalar(False)
1978
+ True
1979
+
1980
+ >>> np.isscalar('numpy')
1981
+ True
1982
+
1983
+ NumPy supports PEP 3141 numbers:
1984
+
1985
+ >>> from fractions import Fraction
1986
+ >>> np.isscalar(Fraction(5, 17))
1987
+ True
1988
+ >>> from numbers import Number
1989
+ >>> np.isscalar(Number())
1990
+ True
1991
+
1992
+ """
1993
+ return (isinstance(element, generic)
1994
+ or type(element) in ScalarType
1995
+ or isinstance(element, numbers.Number))
1996
+
1997
+
1998
+ @set_module('numpy')
1999
+ def binary_repr(num, width=None):
2000
+ """
2001
+ Return the binary representation of the input number as a string.
2002
+
2003
+ For negative numbers, if width is not given, a minus sign is added to the
2004
+ front. If width is given, the two's complement of the number is
2005
+ returned, with respect to that width.
2006
+
2007
+ In a two's-complement system negative numbers are represented by the two's
2008
+ complement of the absolute value. This is the most common method of
2009
+ representing signed integers on computers [1]_. An N-bit two's-complement
2010
+ system can represent every integer in the range
2011
+ :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
2012
+
2013
+ Parameters
2014
+ ----------
2015
+ num : int
2016
+ Only an integer decimal number can be used.
2017
+ width : int, optional
2018
+ The length of the returned string if `num` is positive, or the length
2019
+ of the two's complement if `num` is negative, provided that `width` is
2020
+ at least a sufficient number of bits for `num` to be represented in
2021
+ the designated form. If the `width` value is insufficient, an error is
2022
+ raised.
2023
+
2024
+ Returns
2025
+ -------
2026
+ bin : str
2027
+ Binary representation of `num` or two's complement of `num`.
2028
+
2029
+ See Also
2030
+ --------
2031
+ base_repr: Return a string representation of a number in the given base
2032
+ system.
2033
+ bin: Python's built-in binary representation generator of an integer.
2034
+
2035
+ Notes
2036
+ -----
2037
+ `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
2038
+ faster.
2039
+
2040
+ References
2041
+ ----------
2042
+ .. [1] Wikipedia, "Two's complement",
2043
+ https://en.wikipedia.org/wiki/Two's_complement
2044
+
2045
+ Examples
2046
+ --------
2047
+ >>> import numpy as np
2048
+ >>> np.binary_repr(3)
2049
+ '11'
2050
+ >>> np.binary_repr(-3)
2051
+ '-11'
2052
+ >>> np.binary_repr(3, width=4)
2053
+ '0011'
2054
+
2055
+ The two's complement is returned when the input number is negative and
2056
+ width is specified:
2057
+
2058
+ >>> np.binary_repr(-3, width=3)
2059
+ '101'
2060
+ >>> np.binary_repr(-3, width=5)
2061
+ '11101'
2062
+
2063
+ """
2064
+ def err_if_insufficient(width, binwidth):
2065
+ if width is not None and width < binwidth:
2066
+ raise ValueError(
2067
+ f"Insufficient bit {width=} provided for {binwidth=}"
2068
+ )
2069
+
2070
+ # Ensure that num is a Python integer to avoid overflow or unwanted
2071
+ # casts to floating point.
2072
+ num = operator.index(num)
2073
+
2074
+ if num == 0:
2075
+ return '0' * (width or 1)
2076
+
2077
+ elif num > 0:
2078
+ binary = f'{num:b}'
2079
+ binwidth = len(binary)
2080
+ outwidth = (binwidth if width is None
2081
+ else builtins.max(binwidth, width))
2082
+ err_if_insufficient(width, binwidth)
2083
+ return binary.zfill(outwidth)
2084
+
2085
+ elif width is None:
2086
+ return f'-{-num:b}'
2087
+
2088
+ else:
2089
+ poswidth = len(f'{-num:b}')
2090
+
2091
+ # See gh-8679: remove extra digit
2092
+ # for numbers at boundaries.
2093
+ if 2**(poswidth - 1) == -num:
2094
+ poswidth -= 1
2095
+
2096
+ twocomp = 2**(poswidth + 1) + num
2097
+ binary = f'{twocomp:b}'
2098
+ binwidth = len(binary)
2099
+
2100
+ outwidth = builtins.max(binwidth, width)
2101
+ err_if_insufficient(width, binwidth)
2102
+ return '1' * (outwidth - binwidth) + binary
2103
+
2104
+
2105
+ @set_module('numpy')
2106
+ def base_repr(number, base=2, padding=0):
2107
+ """
2108
+ Return a string representation of a number in the given base system.
2109
+
2110
+ Parameters
2111
+ ----------
2112
+ number : int
2113
+ The value to convert. Positive and negative values are handled.
2114
+ base : int, optional
2115
+ Convert `number` to the `base` number system. The valid range is 2-36,
2116
+ the default value is 2.
2117
+ padding : int, optional
2118
+ Number of zeros padded on the left. Default is 0 (no padding).
2119
+
2120
+ Returns
2121
+ -------
2122
+ out : str
2123
+ String representation of `number` in `base` system.
2124
+
2125
+ See Also
2126
+ --------
2127
+ binary_repr : Faster version of `base_repr` for base 2.
2128
+
2129
+ Examples
2130
+ --------
2131
+ >>> import numpy as np
2132
+ >>> np.base_repr(5)
2133
+ '101'
2134
+ >>> np.base_repr(6, 5)
2135
+ '11'
2136
+ >>> np.base_repr(7, base=5, padding=3)
2137
+ '00012'
2138
+
2139
+ >>> np.base_repr(10, base=16)
2140
+ 'A'
2141
+ >>> np.base_repr(32, base=16)
2142
+ '20'
2143
+
2144
+ """
2145
+ digits = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
2146
+ if base > len(digits):
2147
+ raise ValueError("Bases greater than 36 not handled in base_repr.")
2148
+ elif base < 2:
2149
+ raise ValueError("Bases less than 2 not handled in base_repr.")
2150
+
2151
+ num = abs(int(number))
2152
+ res = []
2153
+ while num:
2154
+ res.append(digits[num % base])
2155
+ num //= base
2156
+ if padding:
2157
+ res.append('0' * padding)
2158
+ if number < 0:
2159
+ res.append('-')
2160
+ return ''.join(reversed(res or '0'))
2161
+
2162
+
2163
+ # These are all essentially abbreviations
2164
+ # These might wind up in a special abbreviations module
2165
+
2166
+
2167
+ def _maketup(descr, val):
2168
+ dt = dtype(descr)
2169
+ # Place val in all scalar tuples:
2170
+ fields = dt.fields
2171
+ if fields is None:
2172
+ return val
2173
+ else:
2174
+ res = [_maketup(fields[name][0], val) for name in dt.names]
2175
+ return tuple(res)
2176
+
2177
+
2178
+ @finalize_array_function_like
2179
+ @set_module('numpy')
2180
+ def identity(n, dtype=None, *, like=None):
2181
+ """
2182
+ Return the identity array.
2183
+
2184
+ The identity array is a square array with ones on
2185
+ the main diagonal.
2186
+
2187
+ Parameters
2188
+ ----------
2189
+ n : int
2190
+ Number of rows (and columns) in `n` x `n` output.
2191
+ dtype : data-type, optional
2192
+ Data-type of the output. Defaults to ``float``.
2193
+ ${ARRAY_FUNCTION_LIKE}
2194
+
2195
+ .. versionadded:: 1.20.0
2196
+
2197
+ Returns
2198
+ -------
2199
+ out : ndarray
2200
+ `n` x `n` array with its main diagonal set to one,
2201
+ and all other elements 0.
2202
+
2203
+ Examples
2204
+ --------
2205
+ >>> import numpy as np
2206
+ >>> np.identity(3)
2207
+ array([[1., 0., 0.],
2208
+ [0., 1., 0.],
2209
+ [0., 0., 1.]])
2210
+
2211
+ """
2212
+ if like is not None:
2213
+ return _identity_with_like(like, n, dtype=dtype)
2214
+
2215
+ from numpy import eye
2216
+ return eye(n, dtype=dtype, like=like)
2217
+
2218
+
2219
+ _identity_with_like = array_function_dispatch()(identity)
2220
+
2221
+
2222
+ def _allclose_dispatcher(a, b, rtol=None, atol=None, equal_nan=None):
2223
+ return (a, b, rtol, atol)
2224
+
2225
+
2226
+ @array_function_dispatch(_allclose_dispatcher)
2227
+ def allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
2228
+ """
2229
+ Returns True if two arrays are element-wise equal within a tolerance.
2230
+
2231
+ The tolerance values are positive, typically very small numbers. The
2232
+ relative difference (`rtol` * abs(`b`)) and the absolute difference
2233
+ `atol` are added together to compare against the absolute difference
2234
+ between `a` and `b`.
2235
+
2236
+ .. warning:: The default `atol` is not appropriate for comparing numbers
2237
+ with magnitudes much smaller than one (see Notes).
2238
+
2239
+ NaNs are treated as equal if they are in the same place and if
2240
+ ``equal_nan=True``. Infs are treated as equal if they are in the same
2241
+ place and of the same sign in both arrays.
2242
+
2243
+ Parameters
2244
+ ----------
2245
+ a, b : array_like
2246
+ Input arrays to compare.
2247
+ rtol : array_like
2248
+ The relative tolerance parameter (see Notes).
2249
+ atol : array_like
2250
+ The absolute tolerance parameter (see Notes).
2251
+ equal_nan : bool
2252
+ Whether to compare NaN's as equal. If True, NaN's in `a` will be
2253
+ considered equal to NaN's in `b` in the output array.
2254
+
2255
+ Returns
2256
+ -------
2257
+ allclose : bool
2258
+ Returns True if the two arrays are equal within the given
2259
+ tolerance; False otherwise.
2260
+
2261
+ See Also
2262
+ --------
2263
+ isclose, all, any, equal
2264
+
2265
+ Notes
2266
+ -----
2267
+ If the following equation is element-wise True, then allclose returns
2268
+ True.::
2269
+
2270
+ absolute(a - b) <= (atol + rtol * absolute(b))
2271
+
2272
+ The above equation is not symmetric in `a` and `b`, so that
2273
+ ``allclose(a, b)`` might be different from ``allclose(b, a)`` in
2274
+ some rare cases.
2275
+
2276
+ The default value of `atol` is not appropriate when the reference value
2277
+ `b` has magnitude smaller than one. For example, it is unlikely that
2278
+ ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet
2279
+ ``allclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure
2280
+ to select `atol` for the use case at hand, especially for defining the
2281
+ threshold below which a non-zero value in `a` will be considered "close"
2282
+ to a very small or zero value in `b`.
2283
+
2284
+ The comparison of `a` and `b` uses standard broadcasting, which
2285
+ means that `a` and `b` need not have the same shape in order for
2286
+ ``allclose(a, b)`` to evaluate to True. The same is true for
2287
+ `equal` but not `array_equal`.
2288
+
2289
+ `allclose` is not defined for non-numeric data types.
2290
+ `bool` is considered a numeric data-type for this purpose.
2291
+
2292
+ Examples
2293
+ --------
2294
+ >>> import numpy as np
2295
+ >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
2296
+ False
2297
+
2298
+ >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
2299
+ True
2300
+
2301
+ >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
2302
+ False
2303
+
2304
+ >>> np.allclose([1.0, np.nan], [1.0, np.nan])
2305
+ False
2306
+
2307
+ >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
2308
+ True
2309
+
2310
+
2311
+ """
2312
+ res = all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))
2313
+ return builtins.bool(res)
2314
+
2315
+
2316
+ def _isclose_dispatcher(a, b, rtol=None, atol=None, equal_nan=None):
2317
+ return (a, b, rtol, atol)
2318
+
2319
+
2320
+ @array_function_dispatch(_isclose_dispatcher)
2321
+ def isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False):
2322
+ """
2323
+ Returns a boolean array where two arrays are element-wise equal within a
2324
+ tolerance.
2325
+
2326
+ The tolerance values are positive, typically very small numbers. The
2327
+ relative difference (`rtol` * abs(`b`)) and the absolute difference
2328
+ `atol` are added together to compare against the absolute difference
2329
+ between `a` and `b`.
2330
+
2331
+ .. warning:: The default `atol` is not appropriate for comparing numbers
2332
+ with magnitudes much smaller than one (see Notes).
2333
+
2334
+ Parameters
2335
+ ----------
2336
+ a, b : array_like
2337
+ Input arrays to compare.
2338
+ rtol : array_like
2339
+ The relative tolerance parameter (see Notes).
2340
+ atol : array_like
2341
+ The absolute tolerance parameter (see Notes).
2342
+ equal_nan : bool
2343
+ Whether to compare NaN's as equal. If True, NaN's in `a` will be
2344
+ considered equal to NaN's in `b` in the output array.
2345
+
2346
+ Returns
2347
+ -------
2348
+ y : array_like
2349
+ Returns a boolean array of where `a` and `b` are equal within the
2350
+ given tolerance. If both `a` and `b` are scalars, returns a single
2351
+ boolean value.
2352
+
2353
+ See Also
2354
+ --------
2355
+ allclose
2356
+ math.isclose
2357
+
2358
+ Notes
2359
+ -----
2360
+ For finite values, isclose uses the following equation to test whether
2361
+ two floating point values are equivalent.::
2362
+
2363
+ absolute(a - b) <= (atol + rtol * absolute(b))
2364
+
2365
+ Unlike the built-in `math.isclose`, the above equation is not symmetric
2366
+ in `a` and `b` -- it assumes `b` is the reference value -- so that
2367
+ `isclose(a, b)` might be different from `isclose(b, a)`.
2368
+
2369
+ The default value of `atol` is not appropriate when the reference value
2370
+ `b` has magnitude smaller than one. For example, it is unlikely that
2371
+ ``a = 1e-9`` and ``b = 2e-9`` should be considered "close", yet
2372
+ ``isclose(1e-9, 2e-9)`` is ``True`` with default settings. Be sure
2373
+ to select `atol` for the use case at hand, especially for defining the
2374
+ threshold below which a non-zero value in `a` will be considered "close"
2375
+ to a very small or zero value in `b`.
2376
+
2377
+ `isclose` is not defined for non-numeric data types.
2378
+ :class:`bool` is considered a numeric data-type for this purpose.
2379
+
2380
+ Examples
2381
+ --------
2382
+ >>> import numpy as np
2383
+ >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
2384
+ array([ True, False])
2385
+
2386
+ >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
2387
+ array([ True, True])
2388
+
2389
+ >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
2390
+ array([False, True])
2391
+
2392
+ >>> np.isclose([1.0, np.nan], [1.0, np.nan])
2393
+ array([ True, False])
2394
+
2395
+ >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
2396
+ array([ True, True])
2397
+
2398
+ >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
2399
+ array([ True, False])
2400
+
2401
+ >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
2402
+ array([False, False])
2403
+
2404
+ >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
2405
+ array([ True, True])
2406
+
2407
+ >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
2408
+ array([False, True])
2409
+
2410
+ """
2411
+ # Turn all but python scalars into arrays.
2412
+ x, y, atol, rtol = (
2413
+ a if isinstance(a, (int, float, complex)) else asanyarray(a)
2414
+ for a in (a, b, atol, rtol))
2415
+
2416
+ # Make sure y is an inexact type to avoid bad behavior on abs(MIN_INT).
2417
+ # This will cause casting of x later. Also, make sure to allow subclasses
2418
+ # (e.g., for numpy.ma).
2419
+ # NOTE: We explicitly allow timedelta, which used to work. This could
2420
+ # possibly be deprecated. See also gh-18286.
2421
+ # timedelta works if `atol` is an integer or also a timedelta.
2422
+ # Although, the default tolerances are unlikely to be useful
2423
+ if (dtype := getattr(y, "dtype", None)) is not None and dtype.kind != "m":
2424
+ dt = multiarray.result_type(y, 1.)
2425
+ y = asanyarray(y, dtype=dt)
2426
+ elif isinstance(y, int):
2427
+ y = float(y)
2428
+
2429
+ # atol and rtol can be arrays
2430
+ if not (np.all(np.isfinite(atol)) and np.all(np.isfinite(rtol))):
2431
+ err_s = np.geterr()["invalid"]
2432
+ err_msg = f"One of rtol or atol is not valid, atol: {atol}, rtol: {rtol}"
2433
+
2434
+ if err_s == "warn":
2435
+ warnings.warn(err_msg, RuntimeWarning, stacklevel=2)
2436
+ elif err_s == "raise":
2437
+ raise FloatingPointError(err_msg)
2438
+ elif err_s == "print":
2439
+ print(err_msg)
2440
+
2441
+ with errstate(invalid='ignore'):
2442
+
2443
+ result = (less_equal(abs(x - y), atol + rtol * abs(y))
2444
+ & isfinite(y)
2445
+ | (x == y))
2446
+ if equal_nan:
2447
+ result |= isnan(x) & isnan(y)
2448
+
2449
+ return result[()] # Flatten 0d arrays to scalars
2450
+
2451
+
2452
+ def _array_equal_dispatcher(a1, a2, equal_nan=None):
2453
+ return (a1, a2)
2454
+
2455
+
2456
+ _no_nan_types = {
2457
+ # should use np.dtype.BoolDType, but as of writing
2458
+ # that fails the reloading test.
2459
+ type(dtype(nt.bool)),
2460
+ type(dtype(nt.int8)),
2461
+ type(dtype(nt.int16)),
2462
+ type(dtype(nt.int32)),
2463
+ type(dtype(nt.int64)),
2464
+ }
2465
+
2466
+
2467
+ def _dtype_cannot_hold_nan(dtype):
2468
+ return type(dtype) in _no_nan_types
2469
+
2470
+
2471
+ @array_function_dispatch(_array_equal_dispatcher)
2472
+ def array_equal(a1, a2, equal_nan=False):
2473
+ """
2474
+ True if two arrays have the same shape and elements, False otherwise.
2475
+
2476
+ Parameters
2477
+ ----------
2478
+ a1, a2 : array_like
2479
+ Input arrays.
2480
+ equal_nan : bool
2481
+ Whether to compare NaN's as equal. If the dtype of a1 and a2 is
2482
+ complex, values will be considered equal if either the real or the
2483
+ imaginary component of a given value is ``nan``.
2484
+
2485
+ Returns
2486
+ -------
2487
+ b : bool
2488
+ Returns True if the arrays are equal.
2489
+
2490
+ See Also
2491
+ --------
2492
+ allclose: Returns True if two arrays are element-wise equal within a
2493
+ tolerance.
2494
+ array_equiv: Returns True if input arrays are shape consistent and all
2495
+ elements equal.
2496
+
2497
+ Examples
2498
+ --------
2499
+ >>> import numpy as np
2500
+
2501
+ >>> np.array_equal([1, 2], [1, 2])
2502
+ True
2503
+
2504
+ >>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
2505
+ True
2506
+
2507
+ >>> np.array_equal([1, 2], [1, 2, 3])
2508
+ False
2509
+
2510
+ >>> np.array_equal([1, 2], [1, 4])
2511
+ False
2512
+
2513
+ >>> a = np.array([1, np.nan])
2514
+ >>> np.array_equal(a, a)
2515
+ False
2516
+
2517
+ >>> np.array_equal(a, a, equal_nan=True)
2518
+ True
2519
+
2520
+ When ``equal_nan`` is True, complex values with nan components are
2521
+ considered equal if either the real *or* the imaginary components are nan.
2522
+
2523
+ >>> a = np.array([1 + 1j])
2524
+ >>> b = a.copy()
2525
+ >>> a.real = np.nan
2526
+ >>> b.imag = np.nan
2527
+ >>> np.array_equal(a, b, equal_nan=True)
2528
+ True
2529
+ """
2530
+ try:
2531
+ a1, a2 = asarray(a1), asarray(a2)
2532
+ except Exception:
2533
+ return False
2534
+ if a1.shape != a2.shape:
2535
+ return False
2536
+ if not equal_nan:
2537
+ return builtins.bool((asanyarray(a1 == a2)).all())
2538
+
2539
+ if a1 is a2:
2540
+ # nan will compare equal so an array will compare equal to itself.
2541
+ return True
2542
+
2543
+ cannot_have_nan = (_dtype_cannot_hold_nan(a1.dtype)
2544
+ and _dtype_cannot_hold_nan(a2.dtype))
2545
+ if cannot_have_nan:
2546
+ return builtins.bool(asarray(a1 == a2).all())
2547
+
2548
+ # Fast path for a1 and a2 being all NaN arrays
2549
+ a1nan = isnan(a1)
2550
+ if a1nan.all():
2551
+ return builtins.bool(isnan(a2).all())
2552
+
2553
+ equal_or_both_nan = (a1 == a2) | (a1nan & isnan(a2))
2554
+ return builtins.bool(equal_or_both_nan.all())
2555
+
2556
+
2557
+ def _array_equiv_dispatcher(a1, a2):
2558
+ return (a1, a2)
2559
+
2560
+
2561
+ @array_function_dispatch(_array_equiv_dispatcher)
2562
+ def array_equiv(a1, a2):
2563
+ """
2564
+ Returns True if input arrays are shape consistent and all elements equal.
2565
+
2566
+ Shape consistent means they are either the same shape, or one input array
2567
+ can be broadcasted to create the same shape as the other one.
2568
+
2569
+ Parameters
2570
+ ----------
2571
+ a1, a2 : array_like
2572
+ Input arrays.
2573
+
2574
+ Returns
2575
+ -------
2576
+ out : bool
2577
+ True if equivalent, False otherwise.
2578
+
2579
+ Examples
2580
+ --------
2581
+ >>> import numpy as np
2582
+ >>> np.array_equiv([1, 2], [1, 2])
2583
+ True
2584
+ >>> np.array_equiv([1, 2], [1, 3])
2585
+ False
2586
+
2587
+ Showing the shape equivalence:
2588
+
2589
+ >>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
2590
+ True
2591
+ >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
2592
+ False
2593
+
2594
+ >>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
2595
+ False
2596
+
2597
+ """
2598
+ try:
2599
+ a1, a2 = asarray(a1), asarray(a2)
2600
+ except Exception:
2601
+ return False
2602
+ try:
2603
+ multiarray.broadcast(a1, a2)
2604
+ except Exception:
2605
+ return False
2606
+
2607
+ return builtins.bool(asanyarray(a1 == a2).all())
2608
+
2609
+
2610
+ def _astype_dispatcher(x, dtype, /, *, copy=None, device=None):
2611
+ return (x, dtype)
2612
+
2613
+
2614
+ @array_function_dispatch(_astype_dispatcher)
2615
+ def astype(x, dtype, /, *, copy=True, device=None):
2616
+ """
2617
+ Copies an array to a specified data type.
2618
+
2619
+ This function is an Array API compatible alternative to
2620
+ `numpy.ndarray.astype`.
2621
+
2622
+ Parameters
2623
+ ----------
2624
+ x : ndarray
2625
+ Input NumPy array to cast. ``array_likes`` are explicitly not
2626
+ supported here.
2627
+ dtype : dtype
2628
+ Data type of the result.
2629
+ copy : bool, optional
2630
+ Specifies whether to copy an array when the specified dtype matches
2631
+ the data type of the input array ``x``. If ``True``, a newly allocated
2632
+ array must always be returned. If ``False`` and the specified dtype
2633
+ matches the data type of the input array, the input array must be
2634
+ returned; otherwise, a newly allocated array must be returned.
2635
+ Defaults to ``True``.
2636
+ device : str, optional
2637
+ The device on which to place the returned array. Default: None.
2638
+ For Array-API interoperability only, so must be ``"cpu"`` if passed.
2639
+
2640
+ .. versionadded:: 2.1.0
2641
+
2642
+ Returns
2643
+ -------
2644
+ out : ndarray
2645
+ An array having the specified data type.
2646
+
2647
+ See Also
2648
+ --------
2649
+ ndarray.astype
2650
+
2651
+ Examples
2652
+ --------
2653
+ >>> import numpy as np
2654
+ >>> arr = np.array([1, 2, 3]); arr
2655
+ array([1, 2, 3])
2656
+ >>> np.astype(arr, np.float64)
2657
+ array([1., 2., 3.])
2658
+
2659
+ Non-copy case:
2660
+
2661
+ >>> arr = np.array([1, 2, 3])
2662
+ >>> arr_noncpy = np.astype(arr, arr.dtype, copy=False)
2663
+ >>> np.shares_memory(arr, arr_noncpy)
2664
+ True
2665
+
2666
+ """
2667
+ if not (isinstance(x, np.ndarray) or isscalar(x)):
2668
+ raise TypeError(
2669
+ "Input should be a NumPy array or scalar. "
2670
+ f"It is a {type(x)} instead."
2671
+ )
2672
+ if device is not None and device != "cpu":
2673
+ raise ValueError(
2674
+ 'Device not understood. Only "cpu" is allowed, but received:'
2675
+ f' {device}'
2676
+ )
2677
+ return x.astype(dtype, copy=copy)
2678
+
2679
+
2680
+ inf = PINF
2681
+ nan = NAN
2682
+ False_ = nt.bool(False)
2683
+ True_ = nt.bool(True)
2684
+
2685
+
2686
+ def extend_all(module):
2687
+ existing = set(__all__)
2688
+ mall = module.__all__
2689
+ for a in mall:
2690
+ if a not in existing:
2691
+ __all__.append(a)
2692
+
2693
+
2694
+ from . import _asarray, _ufunc_config, arrayprint, fromnumeric
2695
+ from ._asarray import *
2696
+ from ._ufunc_config import *
2697
+ from .arrayprint import *
2698
+ from .fromnumeric import *
2699
+ from .numerictypes import *
2700
+ from .umath import *
2701
+
2702
+ extend_all(fromnumeric)
2703
+ extend_all(umath)
2704
+ extend_all(numerictypes)
2705
+ extend_all(arrayprint)
2706
+ extend_all(_asarray)
2707
+ extend_all(_ufunc_config)