Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: f7dc5e2649
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f7dc5e2649'
${ noResults }
mindspore/tests/st/numpy_native/test_math_ops.py

1175 lines
31 kB
Raw Blame History 

  1. # Copyright 2020-2021 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. # ============================================================================

  15. """unit tests for numpy math operations"""

  16. 

  17. import pytest

  18. import numpy as onp

  19. 

  20. import mindspore.numpy as mnp

  21. 

  22. from .utils import rand_int, rand_bool, run_binop_test, run_unary_test, run_multi_test, \

  23.     run_single_test, match_res, match_array

  24. 

  25. class Cases():

  26.     def __init__(self):

  27.         self.arrs = [

  28.             rand_int(2),

  29.             rand_int(2, 3),

  30.             rand_int(2, 3, 4),

  31.             rand_int(2, 3, 4, 5),

  32.         ]

  33. 

  34.         # scalars expanded across the 0th dimension

  35.         self.scalars = [

  36.             rand_int(),

  37.             rand_int(1),

  38.             rand_int(1, 1),

  39.             rand_int(1, 1, 1, 1),

  40.         ]

  41. 

  42.         # empty arrays

  43.         self.empty_arrs = [

  44.             rand_int(0),

  45.             rand_int(4, 0),

  46.             rand_int(2, 0, 2),

  47.             rand_int(5, 0, 7, 0),

  48.         ]

  49. 

  50.         # arrays of the same size expanded across the 0th dimension

  51.         self.expanded_arrs = [

  52.             rand_int(2, 3),

  53.             rand_int(1, 2, 3),

  54.             rand_int(1, 1, 2, 3),

  55.             rand_int(1, 1, 1, 2, 3),

  56.         ]

  57. 

  58.         # arrays with last dimension aligned

  59.         self.aligned_arrs = [

  60.             rand_int(2, 3),

  61.             rand_int(1, 4, 3),

  62.             rand_int(5, 1, 2, 3),

  63.             rand_int(4, 2, 1, 1, 3),

  64.         ]

  65. 

  66.         # arrays which can be broadcast

  67.         self.broadcastables = [

  68.             rand_int(5),

  69.             rand_int(6, 1),

  70.             rand_int(7, 1, 5),

  71.             rand_int(8, 1, 6, 1)

  72.         ]

  73. 

  74.         # boolean arrays which can be broadcast

  75.         self.bool_broadcastables = [

  76.             rand_bool(),

  77.             rand_bool(1),

  78.             rand_bool(5),

  79.             rand_bool(6, 1),

  80.             rand_bool(7, 1, 5),

  81.             rand_bool(8, 1, 6, 1),

  82.         ]

  83. 

  84.         # core dimension 0 is matched for each

  85.         # pair of array[i] and array[i + 1]

  86.         self.core_broadcastables = [

  87.             rand_int(3),

  88.             rand_int(3),

  89.             rand_int(6),

  90.             rand_int(6, 4),

  91.             rand_int(5, 2),

  92.             rand_int(2),

  93.             rand_int(2, 9),

  94.             rand_int(9, 8),

  95.             rand_int(6),

  96.             rand_int(2, 6, 5),

  97.             rand_int(9, 2, 7),

  98.             rand_int(7),

  99.             rand_int(5, 2, 4),

  100.             rand_int(6, 1, 4, 9),

  101.             rand_int(7, 1, 5, 3, 2),

  102.             rand_int(8, 1, 6, 1, 2, 9),

  103.         ]

  104. 

  105.         # arrays with dimensions of size 1

  106.         self.nested_arrs = [

  107.             rand_int(1),

  108.             rand_int(1, 2),

  109.             rand_int(3, 1, 8),

  110.             rand_int(1, 3, 9, 1),

  111.         ]

  112. 

  113. 

  114. test_case = Cases()

  115. 

  116. 

  117. def mnp_add(x1, x2):

  118.     return mnp.add(x1, x2)

  119. 

  120. 

  121. def onp_add(x1, x2):

  122.     return onp.add(x1, x2)

  123. 

  124. 

  125. def mnp_subtract(x1, x2):

  126.     return mnp.subtract(x1, x2)

  127. 

  128. 

  129. def onp_subtract(x1, x2):

  130.     return onp.subtract(x1, x2)

  131. 

  132. 

  133. def mnp_mutiply(x1, x2):

  134.     return mnp.multiply(x1, x2)

  135. 

  136. 

  137. def onp_multiply(x1, x2):

  138.     return onp.multiply(x1, x2)

  139. 

  140. 

  141. def mnp_divide(x1, x2):

  142.     return mnp.divide(x1, x2)

  143. 

  144. 

  145. def onp_divide(x1, x2):

  146.     return onp.divide(x1, x2)

  147. 

  148. 

  149. def mnp_true_divide(x1, x2):

  150.     return mnp.true_divide(x1, x2)

  151. 

  152. 

  153. def onp_true_divide(x1, x2):

  154.     return onp.true_divide(x1, x2)

  155. 

  156. 

  157. def mnp_power(x1, x2):

  158.     return mnp.power(x1, x2)

  159. 

  160. 

  161. def onp_power(x1, x2):

  162.     return onp.power(x1, x2)

  163. 

  164. 

  165. def mnp_float_power(x1, x2):

  166.     return mnp.float_power(x1, x2)

  167. 

  168. 

  169. def onp_float_power(x1, x2):

  170.     return onp.float_power(x1, x2)

  171. 

  172. 

  173. def mnp_minimum(a, b):

  174.     return mnp.minimum(a, b)

  175. 

  176. 

  177. def onp_minimum(a, b):

  178.     return onp.minimum(a, b)

  179. 

  180. 

  181. @pytest.mark.level1

  182. @pytest.mark.platform_arm_ascend_training

  183. @pytest.mark.platform_x86_ascend_training

  184. @pytest.mark.platform_x86_gpu_training

  185. @pytest.mark.platform_x86_cpu

  186. @pytest.mark.env_onecard

  187. def test_add():

  188.     run_binop_test(mnp_add, onp_add, test_case)

  189. 

  190. 

  191. @pytest.mark.level1

  192. @pytest.mark.platform_arm_ascend_training

  193. @pytest.mark.platform_x86_ascend_training

  194. @pytest.mark.platform_x86_gpu_training

  195. @pytest.mark.platform_x86_cpu

  196. @pytest.mark.env_onecard

  197. def test_subtract():

  198.     run_binop_test(mnp_subtract, onp_subtract, test_case)

  199. 

  200. 

  201. @pytest.mark.level1

  202. @pytest.mark.platform_arm_ascend_training

  203. @pytest.mark.platform_x86_ascend_training

  204. @pytest.mark.platform_x86_gpu_training

  205. @pytest.mark.platform_x86_cpu

  206. @pytest.mark.env_onecard

  207. def test_multiply():

  208.     run_binop_test(mnp_mutiply, onp_multiply, test_case)

  209. 

  210. 

  211. @pytest.mark.level1

  212. @pytest.mark.platform_arm_ascend_training

  213. @pytest.mark.platform_x86_ascend_training

  214. @pytest.mark.platform_x86_gpu_training

  215. @pytest.mark.platform_x86_cpu

  216. @pytest.mark.env_onecard

  217. def test_divide():

  218.     run_binop_test(mnp_divide, onp_divide, test_case)

  219. 

  220. 

  221. @pytest.mark.level1

  222. @pytest.mark.platform_arm_ascend_training

  223. @pytest.mark.platform_x86_ascend_training

  224. @pytest.mark.platform_x86_gpu_training

  225. @pytest.mark.platform_x86_cpu

  226. @pytest.mark.env_onecard

  227. def test_true_divide():

  228.     run_binop_test(mnp_true_divide, onp_true_divide, test_case)

  229. 

  230. 

  231. @pytest.mark.level1

  232. @pytest.mark.platform_arm_ascend_training

  233. @pytest.mark.platform_x86_ascend_training

  234. @pytest.mark.platform_x86_gpu_training

  235. @pytest.mark.platform_x86_cpu

  236. @pytest.mark.env_onecard

  237. def test_power():

  238.     run_binop_test(mnp_power, onp_power, test_case, error=1e-5)

  239. 

  240. 

  241. @pytest.mark.level1

  242. @pytest.mark.platform_arm_ascend_training

  243. @pytest.mark.platform_x86_ascend_training

  244. @pytest.mark.platform_x86_gpu_training

  245. @pytest.mark.platform_x86_cpu

  246. @pytest.mark.env_onecard

  247. def test_float_power():

  248.     run_binop_test(mnp_float_power, onp_float_power, test_case, error=1e-5)

  249. 

  250. 

  251. @pytest.mark.level1

  252. @pytest.mark.platform_arm_ascend_training

  253. @pytest.mark.platform_x86_ascend_training

  254. @pytest.mark.platform_x86_gpu_training

  255. @pytest.mark.platform_x86_cpu

  256. @pytest.mark.env_onecard

  257. def test_minimum():

  258.     run_binop_test(mnp_minimum, onp_minimum, test_case)

  259. 

  260. 

  261. def mnp_add_kwargs(x, y, where=None, out=None):

  262.     return mnp.add(x, y, where=where, out=out)

  263. 

  264. 

  265. def onp_add_kwargs(x, y, where=None, out=None):

  266.     return onp.add(x, y, where=where, out=out)

  267. 

  268. 

  269. @pytest.mark.level1

  270. @pytest.mark.platform_arm_ascend_training

  271. @pytest.mark.platform_x86_ascend_training

  272. @pytest.mark.platform_x86_gpu_training

  273. @pytest.mark.platform_x86_cpu

  274. @pytest.mark.env_onecard

  275. def test_add_kwargs():

  276.     for where in test_case.bool_broadcastables[:2]:

  277.         for x in test_case.broadcastables[:2]:

  278.             for y in test_case.broadcastables[:2]:

  279.                 shape_out = onp.broadcast(where, x, y).shape

  280.                 out = rand_int(*shape_out)

  281.                 match_res(mnp_add_kwargs, onp_add_kwargs, x, y, where, out)

  282. 

  283. 

  284. def mnp_tensordot(x, y):

  285.     a = mnp.tensordot(x, y)

  286.     b = mnp.tensordot(x, y, axes=0)

  287.     c = mnp.tensordot(x, y, axes=1)

  288.     d = mnp.tensordot(x, y, axes=2)

  289.     e = mnp.tensordot(x, y, axes=(3, 0))

  290.     f = mnp.tensordot(x, y, axes=[2, 1])

  291.     g = mnp.tensordot(x, y, axes=((2, 3), (0, 1)))

  292.     h = mnp.tensordot(x, y, axes=[[3, 2], [1, 0]])

  293.     return a, b, c, d, e, f, g, h

  294. 

  295. 

  296. def onp_tensordot(x, y):

  297.     a = onp.tensordot(x, y)

  298.     b = onp.tensordot(x, y, axes=0)

  299.     c = onp.tensordot(x, y, axes=1)

  300.     d = onp.tensordot(x, y, axes=2)

  301.     e = onp.tensordot(x, y, axes=(3, 0))

  302.     f = onp.tensordot(x, y, axes=[2, 1])

  303.     g = onp.tensordot(x, y, axes=((2, 3), (0, 1)))

  304.     h = onp.tensordot(x, y, axes=[[3, 2], [1, 0]])

  305.     return a, b, c, d, e, f, g, h

  306. 

  307. 

  308. @pytest.mark.level1

  309. @pytest.mark.platform_arm_ascend_training

  310. @pytest.mark.platform_x86_ascend_training

  311. @pytest.mark.platform_x86_gpu_training

  312. @pytest.mark.platform_x86_cpu

  313. @pytest.mark.env_onecard

  314. def test_tensordot():

  315.     x = rand_int(4, 2, 7, 7)

  316.     y = rand_int(7, 7, 6)

  317.     run_multi_test(mnp_tensordot, onp_tensordot, (x, y))

  318. 

  319. 

  320. def mnp_std(x):

  321.     a = mnp.std(x)

  322.     b = mnp.std(x, axis=None)

  323.     c = mnp.std(x, axis=0)

  324.     d = mnp.std(x, axis=1)

  325.     e = mnp.std(x, axis=(-1, 1))

  326.     f = mnp.std(x, axis=(0, 1, 2))

  327.     g = mnp.std(x, axis=None, ddof=1, keepdims=True)

  328.     h = mnp.std(x, axis=0, ddof=1, keepdims=True)

  329.     i = mnp.std(x, axis=(2), ddof=1, keepdims=True)

  330.     return a, b, c, d, e, f, g, h, i

  331. 

  332. 

  333. def onp_std(x):

  334.     a = onp.std(x)

  335.     b = onp.std(x, axis=None)

  336.     c = onp.std(x, axis=0)

  337.     d = onp.std(x, axis=1)

  338.     e = onp.std(x, axis=(-1, 1))

  339.     f = onp.std(x, axis=(0, 1, 2))

  340.     g = onp.std(x, axis=None, ddof=1, keepdims=True)

  341.     h = onp.std(x, axis=0, ddof=1, keepdims=True)

  342.     i = onp.std(x, axis=(2), ddof=1, keepdims=True)

  343.     return a, b, c, d, e, f, g, h, i

  344. 

  345. 

  346. @pytest.mark.level1

  347. @pytest.mark.platform_arm_ascend_training

  348. @pytest.mark.platform_x86_ascend_training

  349. @pytest.mark.platform_x86_gpu_training

  350. @pytest.mark.platform_x86_cpu

  351. @pytest.mark.env_onecard

  352. def test_std():

  353.     arr1 = rand_int(2, 3, 4, 5)

  354.     arr2 = rand_int(4, 5, 4, 3, 3)

  355.     run_single_test(mnp_std, onp_std, arr1, error=1e-5)

  356.     run_single_test(mnp_std, onp_std, arr2, error=1e-5)

  357. 

  358. 

  359. def mnp_var(x):

  360.     a = mnp.std(x)

  361.     b = mnp.std(x, axis=0)

  362.     c = mnp.std(x, axis=(0))

  363.     d = mnp.std(x, axis=(0, 1, 2))

  364.     e = mnp.std(x, axis=(-1, 1, 2), ddof=1, keepdims=True)

  365.     return a, b, c, d, e

  366. 

  367. 

  368. def onp_var(x):

  369.     a = onp.std(x)

  370.     b = onp.std(x, axis=0)

  371.     c = onp.std(x, axis=(0))

  372.     d = onp.std(x, axis=(0, 1, 2))

  373.     e = onp.std(x, axis=(-1, 1, 2), ddof=1, keepdims=True)

  374.     return a, b, c, d, e

  375. 

  376. 

  377. @pytest.mark.level1

  378. @pytest.mark.platform_arm_ascend_training

  379. @pytest.mark.platform_x86_ascend_training

  380. @pytest.mark.platform_x86_gpu_training

  381. @pytest.mark.platform_x86_cpu

  382. @pytest.mark.env_onecard

  383. def test_var():

  384.     arr1 = rand_int(2, 3, 4, 5)

  385.     arr2 = rand_int(4, 5, 4, 3, 3)

  386.     run_single_test(mnp_var, onp_var, arr1, error=1e-5)

  387.     run_single_test(mnp_var, onp_var, arr2, error=1e-5)

  388. 

  389. 

  390. def mnp_average(x):

  391.     a = mnp.average(x)

  392.     b = mnp.average(x, axis=None)

  393.     c = mnp.average(x, axis=0)

  394.     d = mnp.average(x, axis=1)

  395.     e = mnp.average(x, axis=(-2, 1))

  396.     f = mnp.average(x, axis=(0, 1, 2, 3))

  397.     g = mnp.average(x, axis=None, weights=x)

  398.     h = mnp.average(x, axis=0, weights=x)

  399.     i = mnp.average(x, axis=(1, 2, 3), weights=x)

  400.     return a, b, c, d, e, f, g, h, i

  401. 

  402. 

  403. def onp_average(x):

  404.     a = onp.average(x)

  405.     b = onp.average(x, axis=None)

  406.     c = onp.average(x, axis=0)

  407.     d = onp.average(x, axis=1)

  408.     e = onp.average(x, axis=(-2, 1))

  409.     f = onp.average(x, axis=(0, 1, 2, 3))

  410.     g = onp.average(x, axis=None, weights=x)

  411.     h = onp.average(x, axis=0, weights=x)

  412.     i = onp.average(x, axis=(1, 2, 3), weights=x)

  413.     return a, b, c, d, e, f, g, h, i

  414. 

  415. 

  416. @pytest.mark.level1

  417. @pytest.mark.platform_arm_ascend_training

  418. @pytest.mark.platform_x86_ascend_training

  419. @pytest.mark.platform_x86_gpu_training

  420. @pytest.mark.platform_x86_cpu

  421. @pytest.mark.env_onecard

  422. def test_average():

  423.     arr1 = rand_int(2, 3, 4, 5)

  424.     arr2 = rand_int(4, 5, 1, 3, 1)

  425.     run_single_test(mnp_average, onp_average, arr1, error=1e-5)

  426.     run_single_test(mnp_average, onp_average, arr2, error=1e-5)

  427. 

  428. 

  429. def mnp_count_nonzero(x):

  430.     a = mnp.count_nonzero(x)

  431.     b = mnp.count_nonzero(x, axis=None)

  432.     c = mnp.count_nonzero(x, axis=0)

  433.     d = mnp.count_nonzero(x, axis=1)

  434.     e = mnp.count_nonzero(x, axis=(-2, 1))

  435.     f = mnp.count_nonzero(x, axis=(0, 1, 2, 3))

  436.     return a, b, c, d, e, f

  437. 

  438. 

  439. def onp_count_nonzero(x):

  440.     a = onp.count_nonzero(x)

  441.     b = onp.count_nonzero(x, axis=None)

  442.     c = onp.count_nonzero(x, axis=0)

  443.     d = onp.count_nonzero(x, axis=1)

  444.     e = onp.count_nonzero(x, axis=(-2, 1))

  445.     f = onp.count_nonzero(x, axis=(0, 1, 2, 3))

  446.     return a, b, c, d, e, f

  447. 

  448. 

  449. @pytest.mark.level1

  450. @pytest.mark.platform_arm_ascend_training

  451. @pytest.mark.platform_x86_ascend_training

  452. @pytest.mark.platform_x86_gpu_training

  453. @pytest.mark.platform_x86_cpu

  454. @pytest.mark.env_onecard

  455. def test_count_nonzero():

  456.     # minus 5 to make some values below zero

  457.     arr1 = rand_int(2, 3, 4, 5) - 5

  458.     arr2 = rand_int(4, 5, 4, 3, 3) - 5

  459.     run_single_test(mnp_count_nonzero, onp_count_nonzero, arr1)

  460.     run_single_test(mnp_count_nonzero, onp_count_nonzero, arr2)

  461. 

  462. 

  463. def mnp_inner(a, b):

  464.     return mnp.inner(a, b)

  465. 

  466. 

  467. def onp_inner(a, b):

  468.     return onp.inner(a, b)

  469. 

  470. 

  471. @pytest.mark.level1

  472. @pytest.mark.platform_arm_ascend_training

  473. @pytest.mark.platform_x86_ascend_training

  474. @pytest.mark.platform_x86_gpu_training

  475. @pytest.mark.platform_x86_cpu

  476. @pytest.mark.env_onecard

  477. def test_inner():

  478.     for arr1 in test_case.aligned_arrs:

  479.         for arr2 in test_case.aligned_arrs:

  480.             match_res(mnp_inner, onp_inner, arr1, arr2)

  481. 

  482.     for scalar1 in test_case.scalars:

  483.         for scalar2 in test_case.scalars:

  484.             match_res(mnp_inner, onp_inner,

  485.                       scalar1, scalar2)

  486. 

  487. 

  488. def mnp_dot(a, b):

  489.     return mnp.dot(a, b)

  490. 

  491. 

  492. def onp_dot(a, b):

  493.     return onp.dot(a, b)

  494. 

  495. 

  496. @pytest.mark.level1

  497. @pytest.mark.platform_arm_ascend_training

  498. @pytest.mark.platform_x86_ascend_training

  499. @pytest.mark.platform_x86_gpu_training

  500. @pytest.mark.platform_x86_cpu

  501. @pytest.mark.env_onecard

  502. def test_dot():

  503.     # test case (1D, 1D)

  504.     match_res(mnp_dot, onp_dot, rand_int(3), rand_int(3))

  505. 

  506.     # test case (2D, 2D)

  507.     match_res(mnp_dot, onp_dot, rand_int(4, 7), rand_int(7, 2))

  508. 

  509.     # test case (0D, _) (_, 0D)

  510.     match_res(mnp_dot, onp_dot, rand_int(), rand_int(1, 9, 3))

  511.     match_res(mnp_dot, onp_dot, rand_int(8, 5, 6, 3), rand_int())

  512. 

  513.     # test case (ND, 1D)

  514.     match_res(mnp_dot, onp_dot, rand_int(2, 4, 5), rand_int(5))

  515. 

  516.     # test case (ND, MD)

  517.     match_res(mnp_dot, onp_dot, rand_int(5, 4, 1, 8), rand_int(8, 3))

  518. 

  519.     for i in range(8):

  520.         match_res(mnp_dot, onp_dot,

  521.                   test_case.core_broadcastables[2*i], test_case.core_broadcastables[2*i + 1])

  522. 

  523. 

  524. def mnp_outer(a, b):

  525.     return mnp.outer(a, b)

  526. 

  527. 

  528. def onp_outer(a, b):

  529.     return onp.outer(a, b)

  530. 

  531. 

  532. @pytest.mark.level1

  533. @pytest.mark.platform_arm_ascend_training

  534. @pytest.mark.platform_x86_ascend_training

  535. @pytest.mark.platform_x86_gpu_training

  536. @pytest.mark.platform_x86_cpu

  537. @pytest.mark.env_onecard

  538. def test_outer():

  539.     run_binop_test(mnp_outer, onp_outer, test_case)

  540. 

  541. 

  542. @pytest.mark.level1

  543. @pytest.mark.platform_arm_ascend_training

  544. @pytest.mark.platform_x86_ascend_training

  545. @pytest.mark.platform_x86_gpu_training

  546. @pytest.mark.platform_x86_cpu

  547. @pytest.mark.env_onecard

  548. def test_type_promotion():

  549.     arr = rand_int(2, 3)

  550.     onp_sum = onp_add(arr, arr)

  551. 

  552.     a = mnp.asarray(arr, dtype='float16')

  553.     b = mnp.asarray(arr, dtype='float32')

  554.     c = mnp.asarray(arr, dtype='int32')

  555. 

  556.     match_array(mnp_add(a, b).asnumpy(), onp_sum)

  557.     match_array(mnp_add(b, c).asnumpy(), onp_sum)

  558. 

  559. 

  560. def mnp_absolute(x):

  561.     return mnp.absolute(x)

  562. 

  563. 

  564. def onp_absolute(x):

  565.     return onp.absolute(x)

  566. 

  567. 

  568. @pytest.mark.level1

  569. @pytest.mark.platform_arm_ascend_training

  570. @pytest.mark.platform_x86_ascend_training

  571. @pytest.mark.platform_x86_gpu_training

  572. @pytest.mark.platform_x86_cpu

  573. @pytest.mark.env_onecard

  574. def test_absolute():

  575.     arr = rand_int(2, 3)

  576. 

  577.     a = mnp.asarray(arr, dtype='float16')

  578.     b = mnp.asarray(arr, dtype='float32')

  579.     c = mnp.asarray(arr, dtype='uint8')

  580.     d = mnp.asarray(arr, dtype='bool')

  581. 

  582.     match_array(mnp_absolute(a).asnumpy(), onp_absolute(a.asnumpy()))

  583.     match_array(mnp_absolute(b).asnumpy(), onp_absolute(b.asnumpy()))

  584.     match_array(mnp_absolute(c).asnumpy(), onp_absolute(c.asnumpy()))

  585.     match_array(mnp_absolute(d).asnumpy(), onp_absolute(d.asnumpy()))

  586. 

  587.     where = rand_int(2, 3).astype('bool')

  588.     out = rand_int(2, 3)

  589.     match_array(mnp.absolute(a, out=mnp.asarray(out), where=mnp.asarray(where)).asnumpy(),

  590.                 onp.absolute(a.asnumpy(), out=out, where=where))

  591. 

  592. 

  593. @pytest.mark.level1

  594. @pytest.mark.platform_arm_ascend_training

  595. @pytest.mark.platform_x86_ascend_training

  596. @pytest.mark.platform_x86_gpu_training

  597. @pytest.mark.platform_x86_cpu

  598. @pytest.mark.env_onecard

  599. def test_deg2rad_rad2deg():

  600.     arrs = [rand_int(2, 3), rand_int(1, 2, 4), rand_int(2, 4)]

  601.     for arr in arrs:

  602.         match_res(mnp.deg2rad, onp.deg2rad, arr)

  603.         match_res(mnp.rad2deg, onp.rad2deg, arr)

  604. 

  605. 

  606. def mnp_ptp(x):

  607.     a = mnp.ptp(x)

  608.     b = mnp.ptp(x, keepdims=True)

  609.     c = mnp.ptp(x, axis=(0, 1))

  610.     d = mnp.ptp(x, axis=-1)

  611.     return a, b, c, d

  612. 

  613. 

  614. def onp_ptp(x):

  615.     a = onp.ptp(x)

  616.     b = onp.ptp(x, keepdims=True)

  617.     c = onp.ptp(x, axis=(0, 1))

  618.     d = onp.ptp(x, axis=-1)

  619.     return a, b, c, d

  620. 

  621. 

  622. @pytest.mark.level1

  623. @pytest.mark.platform_arm_ascend_training

  624. @pytest.mark.platform_x86_ascend_training

  625. @pytest.mark.platform_x86_gpu_training

  626. @pytest.mark.platform_x86_cpu

  627. @pytest.mark.env_onecard

  628. def test_ptp():

  629.     arrs = [rand_int(2, 3), rand_int(1, 2, 4), rand_int(2, 4)]

  630.     for arr in arrs:

  631.         match_res(mnp_ptp, onp_ptp, arr)

  632. 

  633. 

  634. def mnp_add_dtype(x1, x2, out, where):

  635.     a = mnp.add(x1, x2, dtype=mnp.float16)

  636.     b = mnp.add(x1, x2, out=out, dtype=mnp.float16)

  637.     c = mnp.add(x1, x2, where=where, dtype=mnp.float16)

  638.     d = mnp.add(x1, x2, out=out, where=where, dtype=mnp.float16)

  639.     return a, b, c, d

  640. 

  641. 

  642. def onp_add_dtype(x1, x2, out, where):

  643.     a = onp.add(x1, x2, dtype=onp.float16)

  644.     b = onp.add(x1, x2, out=out, dtype=onp.float16)

  645.     c = onp.add(x1, x2, where=where, dtype=onp.float16)

  646.     d = onp.add(x1, x2, out=out, where=where, dtype=onp.float16)

  647.     return a, b, c, d

  648. 

  649. 

  650. @pytest.mark.level1

  651. @pytest.mark.platform_arm_ascend_training

  652. @pytest.mark.platform_x86_ascend_training

  653. @pytest.mark.platform_x86_gpu_training

  654. @pytest.mark.platform_x86_cpu

  655. @pytest.mark.env_onecard

  656. def test_add_dtype():

  657.     x1 = rand_int(2, 3).astype('int32')

  658.     x2 = rand_int(2, 3).astype('int32')

  659.     out = rand_int(2, 3).astype('float32')

  660.     where = rand_bool(2, 3)

  661.     arrs = (x1, x2, out, where)

  662.     mnp_arrs = map(mnp.array, arrs)

  663.     mnp_res = mnp_add_dtype(*mnp_arrs)

  664.     onp_res = onp_add_dtype(*arrs)

  665.     for actual, expected in zip(mnp_res, onp_res):

  666.         assert actual.asnumpy().dtype == expected.dtype

  667. 

  668. 

  669. def mnp_matmul(x1, x2):

  670.     return mnp.matmul(x1, x2)

  671. 

  672. 

  673. def onp_matmul(x1, x2):

  674.     return onp.matmul(x1, x2)

  675. 

  676. 

  677. @pytest.mark.level1

  678. @pytest.mark.platform_arm_ascend_training

  679. @pytest.mark.platform_x86_ascend_training

  680. @pytest.mark.platform_x86_gpu_training

  681. @pytest.mark.platform_x86_cpu

  682. @pytest.mark.env_onecard

  683. def test_matmul():

  684.     for scalar1 in test_case.scalars[1:]:

  685.         for scalar2 in test_case.scalars[1:]:

  686.             match_res(mnp_matmul, onp_matmul,

  687.                       scalar1, scalar2)

  688.     for i in range(8):

  689.         match_res(mnp_matmul, onp_matmul,

  690.                   test_case.core_broadcastables[2*i],

  691.                   test_case.core_broadcastables[2*i + 1])

  692. 

  693. 

  694. def mnp_square(x):

  695.     return mnp.square(x)

  696. 

  697. 

  698. def onp_square(x):

  699.     return onp.square(x)

  700. 

  701. 

  702. @pytest.mark.level1

  703. @pytest.mark.platform_arm_ascend_training

  704. @pytest.mark.platform_x86_ascend_training

  705. @pytest.mark.platform_x86_gpu_training

  706. @pytest.mark.platform_x86_cpu

  707. @pytest.mark.env_onecard

  708. def test_square():

  709.     run_unary_test(mnp_square, onp_square, test_case)

  710. 

  711. 

  712. def mnp_sqrt(x):

  713.     return mnp.sqrt(x)

  714. 

  715. 

  716. def onp_sqrt(x):

  717.     return onp.sqrt(x)

  718. 

  719. 

  720. @pytest.mark.level1

  721. @pytest.mark.platform_arm_ascend_training

  722. @pytest.mark.platform_x86_ascend_training

  723. @pytest.mark.platform_x86_gpu_training

  724. @pytest.mark.platform_x86_cpu

  725. @pytest.mark.env_onecard

  726. def test_sqrt():

  727.     run_unary_test(mnp_sqrt, onp_sqrt, test_case)

  728. 

  729. 

  730. def mnp_reciprocal(x):

  731.     return mnp.reciprocal(x)

  732. 

  733. 

  734. def onp_reciprocal(x):

  735.     return onp.reciprocal(x)

  736. 

  737. 

  738. @pytest.mark.level1

  739. @pytest.mark.platform_arm_ascend_training

  740. @pytest.mark.platform_x86_ascend_training

  741. @pytest.mark.platform_x86_gpu_training

  742. @pytest.mark.platform_x86_cpu

  743. @pytest.mark.env_onecard

  744. def test_reciprocal():

  745.     run_unary_test(mnp_reciprocal, onp_reciprocal, test_case)

  746. 

  747. 

  748. def mnp_log(x):

  749.     return mnp.log(x)

  750. 

  751. 

  752. def onp_log(x):

  753.     return onp.log(x)

  754. 

  755. 

  756. @pytest.mark.level1

  757. @pytest.mark.platform_arm_ascend_training

  758. @pytest.mark.platform_x86_ascend_training

  759. @pytest.mark.platform_x86_gpu_training

  760. @pytest.mark.platform_x86_cpu

  761. @pytest.mark.env_onecard

  762. def test_log():

  763.     run_unary_test(mnp.log, onp.log, test_case, error=1e-5)

  764. 

  765. 

  766. def mnp_maximum(x1, x2):

  767.     return mnp.maximum(x1, x2)

  768. 

  769. 

  770. def onp_maximum(x1, x2):

  771.     return onp.maximum(x1, x2)

  772. 

  773. 

  774. @pytest.mark.level1

  775. @pytest.mark.platform_arm_ascend_training

  776. @pytest.mark.platform_x86_ascend_training

  777. @pytest.mark.platform_x86_gpu_training

  778. @pytest.mark.platform_x86_cpu

  779. @pytest.mark.env_onecard

  780. def test_maximum():

  781.     run_binop_test(mnp_maximum, onp_maximum, test_case)

  782. 

  783. 

  784. def mnp_clip(x):

  785.     a = mnp.clip(x, mnp.asarray(10.0), mnp.asarray([2,]))

  786.     b = mnp.clip(x, 0, 1)

  787.     c = mnp.clip(x, mnp.asarray(0), mnp.asarray(10), dtype=mnp.float32)

  788.     return a, b, c

  789. 

  790. 

  791. def onp_clip(x):

  792.     a = onp.clip(x, onp.asarray(10.0), onp.asarray([2,]))

  793.     b = onp.clip(x, 0, 1)

  794.     c = onp.clip(x, onp.asarray(0), onp.asarray(10), dtype=onp.float32)

  795.     return a, b, c

  796. 

  797. 

  798. @pytest.mark.level1

  799. @pytest.mark.platform_arm_ascend_training

  800. @pytest.mark.platform_x86_ascend_training

  801. @pytest.mark.platform_x86_gpu_training

  802. @pytest.mark.platform_x86_cpu

  803. @pytest.mark.env_onecard

  804. def test_clip():

  805.     run_unary_test(mnp_clip, onp_clip, test_case)

  806. 

  807. 

  808. def mnp_amax(x, mask):

  809.     a = mnp.amax(x)

  810.     b = mnp.amax(x, axis=-3)

  811.     c = mnp.amax(x, keepdims=True)

  812.     d = mnp.amax(x, initial=3)

  813.     e = mnp.amax(x, axis=(0, 1), keepdims=True)

  814.     f = mnp.amax(x, initial=4, where=mask)

  815.     g = mnp.amax(x, initial=5, where=mask, keepdims=True)

  816.     h = mnp.amax(x, axis=(1, 2, 3), initial=6, where=mask)

  817.     return a, b, c, d, e, f, g, h

  818. 

  819. 

  820. def onp_amax(x, mask):

  821.     a = onp.amax(x)

  822.     b = onp.amax(x, axis=-3)

  823.     c = onp.amax(x, keepdims=True)

  824.     d = onp.amax(x, initial=3)

  825.     e = onp.amax(x, axis=(0, 1), keepdims=True)

  826.     f = onp.amax(x, initial=4, where=mask)

  827.     g = onp.amax(x, initial=5, where=mask, keepdims=True)

  828.     h = onp.amax(x, axis=(1, 2, 3), initial=6, where=mask)

  829.     return a, b, c, d, e, f, g, h

  830. 

  831. 

  832. @pytest.mark.level1

  833. @pytest.mark.platform_arm_ascend_training

  834. @pytest.mark.platform_x86_ascend_training

  835. @pytest.mark.platform_x86_gpu_training

  836. @pytest.mark.platform_x86_cpu

  837. @pytest.mark.env_onecard

  838. def test_amax():

  839.     a = rand_int(2, 3, 4, 5).astype('float32')

  840.     mask = rand_bool(2, 3, 4, 5)

  841.     run_multi_test(mnp_amax, onp_amax, (a, mask))

  842. 

  843. 

  844. def mnp_amin(x, mask):

  845.     a = mnp.amin(x)

  846.     b = mnp.amin(x, axis=-3)

  847.     c = mnp.amin(x, keepdims=True)

  848.     d = mnp.amin(x, initial=-1)

  849.     e = mnp.amin(x, axis=(0, 1), keepdims=True)

  850.     f = mnp.amin(x, initial=-2, where=mask)

  851.     g = mnp.amin(x, initial=-3, where=mask, keepdims=True)

  852.     h = mnp.amin(x, axis=(1, 2, 3), initial=-4, where=mask)

  853.     return a, b, c, d, e, f, g, h

  854. 

  855. 

  856. def onp_amin(x, mask):

  857.     a = onp.amin(x)

  858.     b = onp.amin(x, axis=-3)

  859.     c = onp.amin(x, keepdims=True)

  860.     d = onp.amin(x, initial=-1)

  861.     e = onp.amin(x, axis=(0, 1), keepdims=True)

  862.     f = onp.amin(x, initial=-2, where=mask)

  863.     g = onp.amin(x, initial=-3, where=mask, keepdims=True)

  864.     h = onp.amin(x, axis=(1, 2, 3), initial=-4, where=mask)

  865.     return a, b, c, d, e, f, g, h

  866. 

  867. 

  868. @pytest.mark.level1

  869. @pytest.mark.platform_arm_ascend_training

  870. @pytest.mark.platform_x86_ascend_training

  871. @pytest.mark.platform_x86_gpu_training

  872. @pytest.mark.platform_x86_cpu

  873. @pytest.mark.env_onecard

  874. def test_amin():

  875.     a = rand_int(2, 3, 4, 5).astype('float32')

  876.     mask = rand_bool(2, 3, 4, 5)

  877.     run_multi_test(mnp_amin, onp_amin, (a, mask))

  878. 

  879. 

  880. def mnp_hypot(x1, x2):

  881.     return mnp.hypot(x1, x2)

  882. 

  883. 

  884. def onp_hypot(x1, x2):

  885.     return onp.hypot(x1, x2)

  886. 

  887. 

  888. @pytest.mark.level1

  889. @pytest.mark.platform_arm_ascend_training

  890. @pytest.mark.platform_x86_ascend_training

  891. @pytest.mark.platform_x86_gpu_training

  892. @pytest.mark.platform_x86_cpu

  893. @pytest.mark.env_onecard

  894. def test_hypot():

  895.     run_binop_test(mnp_hypot, onp_hypot, test_case)

  896. 

  897. 

  898. def mnp_heaviside(x1, x2):

  899.     return mnp.heaviside(x1, x2)

  900. 

  901. 

  902. def onp_heaviside(x1, x2):

  903.     return onp.heaviside(x1, x2)

  904. 

  905. 

  906. @pytest.mark.level1

  907. @pytest.mark.platform_arm_ascend_training

  908. @pytest.mark.platform_x86_ascend_training

  909. @pytest.mark.platform_x86_gpu_training

  910. @pytest.mark.platform_x86_cpu

  911. @pytest.mark.env_onecard

  912. def test_heaviside():

  913.     broadcastables = test_case.broadcastables

  914.     for b1 in broadcastables:

  915.         for b2 in broadcastables:

  916.             b = onp.subtract(b1, b2)

  917.             match_res(mnp_heaviside, onp_heaviside, b, b1)

  918.             match_res(mnp_heaviside, onp_heaviside, b, b2)

  919. 

  920. 

  921. def mnp_floor(x):

  922.     return mnp.floor(x)

  923. 

  924. 

  925. def onp_floor(x):

  926.     return onp.floor(x)

  927. 

  928. 

  929. @pytest.mark.level1

  930. @pytest.mark.platform_arm_ascend_training

  931. @pytest.mark.platform_x86_ascend_training

  932. @pytest.mark.platform_x86_gpu_training

  933. @pytest.mark.platform_x86_cpu

  934. @pytest.mark.env_onecard

  935. def test_floor():

  936.     run_unary_test(mnp_floor, onp_floor, test_case)

  937.     x = rand_int(2, 3) * onp.random.rand(2, 3)

  938.     match_res(mnp_floor, onp_floor, x)

  939.     match_res(mnp_floor, onp_floor, -x)

  940. 

  941. 

  942. def mnp_floor_divide(x, y):

  943.     return mnp.floor_divide(x, y)

  944. 

  945. 

  946. def onp_floor_divde(x, y):

  947.     return onp.floor_divide(x, y)

  948. 

  949. 

  950. @pytest.mark.level1

  951. @pytest.mark.platform_arm_ascend_training

  952. @pytest.mark.platform_x86_ascend_training

  953. @pytest.mark.platform_x86_gpu_training

  954. @pytest.mark.platform_x86_cpu

  955. @pytest.mark.env_onecard

  956. def test_floor_divide():

  957.     run_binop_test(mnp_floor_divide, onp_floor_divde, test_case)

  958. 

  959. 

  960. def mnp_remainder(x, y):

  961.     return mnp.remainder(x, y)

  962. 

  963. 

  964. def onp_remainder(x, y):

  965.     return onp.remainder(x, y)

  966. 

  967. 

  968. @pytest.mark.level1

  969. @pytest.mark.platform_arm_ascend_training

  970. @pytest.mark.platform_x86_ascend_training

  971. @pytest.mark.platform_x86_gpu_training

  972. @pytest.mark.platform_x86_cpu

  973. @pytest.mark.env_onecard

  974. def test_remainder():

  975.     run_binop_test(mnp_remainder, onp_remainder, test_case)

  976. 

  977. 

  978. def mnp_mod(x, y):

  979.     return mnp.mod(x, y)

  980. 

  981. 

  982. def onp_mod(x, y):

  983.     return onp.mod(x, y)

  984. 

  985. 

  986. @pytest.mark.level1

  987. @pytest.mark.platform_arm_ascend_training

  988. @pytest.mark.platform_x86_ascend_training

  989. @pytest.mark.platform_x86_gpu_training

  990. @pytest.mark.platform_x86_cpu

  991. @pytest.mark.env_onecard

  992. def test_mod():

  993.     run_binop_test(mnp_mod, onp_mod, test_case)

  994. 

  995. 

  996. def mnp_fmod(x, y):

  997.     return mnp.fmod(x, y)

  998. 

  999. 

  1000. def onp_fmod(x, y):

  1001.     return onp.fmod(x, y)

  1002. 

  1003. 

  1004. @pytest.mark.level1

  1005. @pytest.mark.platform_arm_ascend_training

  1006. @pytest.mark.platform_x86_ascend_training

  1007. @pytest.mark.platform_x86_gpu_training

  1008. @pytest.mark.platform_x86_cpu

  1009. @pytest.mark.env_onecard

  1010. def test_fmod():

  1011.     run_binop_test(mnp_fmod, onp_fmod, test_case)

  1012. 

  1013. 

  1014. def mnp_fix(x):

  1015.     return mnp.fix(x)

  1016. 

  1017. 

  1018. def onp_fix(x):

  1019.     return onp.fix(x)

  1020. 

  1021. 

  1022. @pytest.mark.level1

  1023. @pytest.mark.platform_arm_ascend_training

  1024. @pytest.mark.platform_x86_ascend_training

  1025. @pytest.mark.platform_x86_gpu_training

  1026. @pytest.mark.platform_x86_cpu

  1027. @pytest.mark.env_onecard

  1028. def test_fix():

  1029.     x = rand_int(2, 3)

  1030.     y = rand_int(2, 3)

  1031.     floats = onp.divide(onp.subtract(x, y), y)

  1032.     match_res(mnp_fix, onp_fix, floats, error=1e-5)

  1033.     run_binop_test(mnp_fmod, onp_fmod, test_case, error=1e-5)

  1034. 

  1035. 

  1036. def mnp_trunc(x):

  1037.     return mnp.trunc(x)

  1038. 

  1039. 

  1040. def onp_trunc(x):

  1041.     return onp.trunc(x)

  1042. 

  1043. 

  1044. @pytest.mark.level1

  1045. @pytest.mark.platform_arm_ascend_training

  1046. @pytest.mark.platform_x86_ascend_training

  1047. @pytest.mark.platform_x86_gpu_training

  1048. @pytest.mark.platform_x86_cpu

  1049. @pytest.mark.env_onecard

  1050. def test_trunc():

  1051.     x = rand_int(2, 3)

  1052.     y = rand_int(2, 3)

  1053.     floats = onp.divide(onp.subtract(x, y), y)

  1054.     match_res(mnp_trunc, onp_trunc, floats, error=1e-5)

  1055. 

  1056. 

  1057. def mnp_exp(x):

  1058.     return mnp.exp(x)

  1059. 

  1060. 

  1061. def onp_exp(x):

  1062.     return onp.exp(x)

  1063. 

  1064. 

  1065. @pytest.mark.level1

  1066. @pytest.mark.platform_arm_ascend_training

  1067. @pytest.mark.platform_x86_ascend_training

  1068. @pytest.mark.platform_x86_gpu_training

  1069. @pytest.mark.platform_x86_cpu

  1070. @pytest.mark.env_onecard

  1071. def test_exp():

  1072.     run_unary_test(mnp_exp, onp_exp, test_case, error=5)

  1073. 

  1074. 

  1075. def mnp_expm1(x):

  1076.     return mnp.expm1(x)

  1077. 

  1078. 

  1079. def onp_expm1(x):

  1080.     return onp.expm1(x)

  1081. 

  1082. 

  1083. @pytest.mark.level1

  1084. @pytest.mark.platform_arm_ascend_training

  1085. @pytest.mark.platform_x86_ascend_training

  1086. @pytest.mark.platform_x86_gpu_training

  1087. @pytest.mark.platform_x86_cpu

  1088. @pytest.mark.env_onecard

  1089. def test_expm1():

  1090.     run_unary_test(mnp_expm1, onp_expm1, test_case, error=5)

  1091. 

  1092. 

  1093. def mnp_positive(x, out, where):

  1094.     return mnp.positive(x, out=out, where=where)

  1095. 

  1096. 

  1097. def onp_positive(x, out, where):

  1098.     return onp.positive(x, out=out, where=where)

  1099. 

  1100. 

  1101. @pytest.mark.level1

  1102. @pytest.mark.platform_arm_ascend_training

  1103. @pytest.mark.platform_x86_ascend_training

  1104. @pytest.mark.platform_x86_gpu_training

  1105. @pytest.mark.platform_x86_cpu

  1106. @pytest.mark.env_onecard

  1107. def test_positive():

  1108.     arr = onp.arange(-6, 6).reshape((2, 2, 3)).astype('float32')

  1109.     out_lst = [onp.ones((2, 2, 3)).astype('float32'), onp.ones((5, 2, 2, 3)).astype('float32')]

  1110.     where_lst = [onp.full((2, 2, 3), [True, False, True]), onp.full((2, 3), False)]

  1111.     for out in out_lst:

  1112.         for where in where_lst:

  1113.             onp_pos = onp_positive(arr, out=out, where=where)

  1114.             mnp_pos = mnp_positive(mnp.asarray(arr), mnp.asarray(out), mnp.asarray(where))

  1115.             match_array(mnp_pos.asnumpy(), onp_pos)

  1116. 

  1117. 

  1118. def mnp_negative(x, out, where):

  1119.     return mnp.negative(x, out=out, where=where)

  1120. 

  1121. 

  1122. def onp_negative(x, out, where):

  1123.     return onp.negative(x, out=out, where=where)

  1124. 

  1125. 

  1126. @pytest.mark.level1

  1127. @pytest.mark.platform_arm_ascend_training

  1128. @pytest.mark.platform_x86_ascend_training

  1129. @pytest.mark.platform_x86_gpu_training

  1130. @pytest.mark.platform_x86_cpu

  1131. @pytest.mark.env_onecard

  1132. def test_negative():

  1133.     arr = onp.arange(-6, 6).reshape((2, 2, 3)).astype('float32')

  1134.     out_lst = [onp.ones((2, 2, 3)).astype('float32'), onp.ones((5, 2, 2, 3)).astype('float32')]

  1135.     where_lst = [onp.full((2, 2, 3), [True, False, True]), onp.full((2, 3), False)]

  1136.     for out in out_lst:

  1137.         for where in where_lst:

  1138.             onp_neg = onp_negative(arr, out=out, where=where)

  1139.             mnp_neg = mnp_negative(mnp.asarray(arr), mnp.asarray(out), mnp.asarray(where))

  1140.             match_array(mnp_neg.asnumpy(), onp_neg, 1e-5)

  1141. 

  1142. 

  1143. @pytest.mark.level1

  1144. @pytest.mark.platform_arm_ascend_training

  1145. @pytest.mark.platform_x86_ascend_training

  1146. @pytest.mark.platform_x86_gpu_training

  1147. @pytest.mark.platform_x86_cpu

  1148. @pytest.mark.env_onecard

  1149. def test_exception_innner():

  1150.     with pytest.raises(ValueError):

  1151.         mnp.inner(mnp.asarray(test_case.arrs[0]),

  1152.                   mnp.asarray(test_case.arrs[1]))

  1153. 

  1154. 

  1155. @pytest.mark.level1

  1156. @pytest.mark.platform_arm_ascend_training

  1157. @pytest.mark.platform_x86_ascend_training

  1158. @pytest.mark.platform_x86_gpu_training

  1159. @pytest.mark.platform_x86_cpu

  1160. @pytest.mark.env_onecard

  1161. def test_exception_add():

  1162.     with pytest.raises(ValueError):

  1163.         mnp.add(mnp.asarray(test_case.arrs[1]), mnp.asarray(test_case.arrs[2]))

  1164. 

  1165. 

  1166. @pytest.mark.level1

  1167. @pytest.mark.platform_arm_ascend_training

  1168. @pytest.mark.platform_x86_ascend_training

  1169. @pytest.mark.platform_x86_gpu_training

  1170. @pytest.mark.platform_x86_cpu

  1171. @pytest.mark.env_onecard

  1172. def test_exception_mean():

  1173.     with pytest.raises(ValueError):

  1174.         mnp.mean(mnp.asarray(test_case.arrs[0]), (-1, 0))