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: d8c66aee4a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd8c66aee4a'
${ noResults }
mindspore/tests/st/numpy_native/test_array_creations.py

839 lines
29 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 array 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, match_array, match_res, match_meta, \

  23.     match_all_arrays, run_multi_test, to_tensor

  24. 

  25. 

  26. class Cases():

  27.     def __init__(self):

  28.         self.all_shapes = [

  29.             1, 2, (1,), (2,), (1, 2, 3), [1], [2], [1, 2, 3]

  30.         ]

  31.         self.onp_dtypes = [onp.int32, 'int32', int,

  32.                            onp.float32, 'float32', float,

  33.                            onp.uint32, 'uint32',

  34.                            onp.bool_, 'bool', bool]

  35. 

  36.         self.mnp_dtypes = [mnp.int32, 'int32', int,

  37.                            mnp.float32, 'float32', float,

  38.                            mnp.uint32, 'uint32',

  39.                            mnp.bool_, 'bool', bool]

  40. 

  41.         self.array_sets = [1, 1.1, True, [1, 0, True], [1, 1.0, 2], (1,),

  42.                            [(1, 2, 3), (4, 5, 6)], onp.random.random(  # pylint: disable=no-member

  43.                                (100, 100)).astype(onp.float32).tolist(),

  44.                            onp.random.random((100, 100)).astype(onp.bool).tolist()]

  45. 

  46.         self.arrs = [

  47.             rand_int(2),

  48.             rand_int(2, 3),

  49.             rand_int(2, 3, 4),

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

  51.         ]

  52. 

  53.         # scalars expanded across the 0th dimension

  54.         self.scalars = [

  55.             rand_int(),

  56.             rand_int(1),

  57.             rand_int(1, 1),

  58.             rand_int(1, 1, 1),

  59.         ]

  60. 

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

  62.         self.expanded_arrs = [

  63.             rand_int(2, 3),

  64.             rand_int(1, 2, 3),

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

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

  67.         ]

  68. 

  69.         # arrays with dimensions of size 1

  70.         self.nested_arrs = [

  71.             rand_int(1),

  72.             rand_int(1, 2),

  73.             rand_int(3, 1, 8),

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

  75.         ]

  76. 

  77.         # arrays which can be broadcast

  78.         self.broadcastables = [

  79.             rand_int(5),

  80.             rand_int(6, 1),

  81.             rand_int(7, 1, 5),

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

  83.         ]

  84. 

  85.         # boolean arrays which can be broadcast

  86.         self.bool_broadcastables = [

  87.             rand_bool(),

  88.             rand_bool(1),

  89.             rand_bool(5),

  90.             rand_bool(6, 1),

  91.             rand_bool(7, 1, 5),

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

  93.         ]

  94. 

  95.         self.mnp_prototypes = [

  96.             mnp.ones((2, 3, 4)),

  97.             mnp.ones((1, 3, 1, 2, 5)),

  98.             mnp.ones((2, 7, 1)),

  99.             [mnp.ones(3), (1, 2, 3), mnp.ones(3), [4, 5, 6]],

  100.             ([(1, 2), mnp.ones(2)], (mnp.ones(2), [3, 4])),

  101.         ]

  102. 

  103.         self.onp_prototypes = [

  104.             onp.ones((2, 3, 4)),

  105.             onp.ones((1, 3, 1, 2, 5)),

  106.             onp.ones((2, 7, 1)),

  107.             [onp.ones(3), (1, 2, 3), onp.ones(3), [4, 5, 6]],

  108.             ([(1, 2), onp.ones(2)], (onp.ones(2), [3, 4])),

  109.         ]

  110. 

  111. 

  112. @pytest.mark.level1

  113. @pytest.mark.platform_arm_ascend_training

  114. @pytest.mark.platform_x86_ascend_training

  115. @pytest.mark.platform_x86_gpu_training

  116. @pytest.mark.platform_x86_cpu

  117. @pytest.mark.env_onecard

  118. def test_asarray():

  119.     test_case = Cases()

  120.     for array in test_case.array_sets:

  121.         # Check for dtype matching

  122.         actual = onp.asarray(array)

  123.         expected = mnp.asarray(array).asnumpy()

  124.         # Since we set float32/int32 as the default dtype in mindspore, we need

  125.         # to make a conversion between numpy.asarray and mindspore.numpy.asarray

  126.         if actual.dtype is onp.dtype('float64'):

  127.             assert expected.dtype == onp.dtype('float32')

  128.         elif actual.dtype is onp.dtype('int64'):

  129.             assert expected.dtype == onp.dtype('int32')

  130.         else:

  131.             assert actual.dtype == expected.dtype

  132.         match_array(actual, expected, error=7)

  133. 

  134.         for i in range(len(test_case.onp_dtypes)):

  135.             actual = onp.asarray(array, test_case.onp_dtypes[i])

  136.             expected = mnp.asarray(array, test_case.mnp_dtypes[i]).asnumpy()

  137.             match_array(actual, expected, error=7)

  138. 

  139.     # Additional tests for nested tensor mixture

  140.     mnp_input = [(mnp.ones(3,), mnp.ones(3)), [[1, 1, 1], (1, 1, 1)]]

  141.     onp_input = [(onp.ones(3,), onp.ones(3)), [[1, 1, 1], (1, 1, 1)]]

  142. 

  143.     actual = onp.asarray(onp_input)

  144.     expected = mnp.asarray(mnp_input).asnumpy()

  145.     match_array(actual, expected, error=7)

  146. 

  147. 

  148. @pytest.mark.level1

  149. @pytest.mark.platform_arm_ascend_training

  150. @pytest.mark.platform_x86_ascend_training

  151. @pytest.mark.platform_x86_gpu_training

  152. @pytest.mark.platform_x86_cpu

  153. @pytest.mark.env_onecard

  154. def test_array():

  155.     # array's function is very similar to asarray, so we mainly test the

  156.     # `copy` argument.

  157.     test_case = Cases()

  158.     for array in test_case.array_sets:

  159.         arr1 = mnp.asarray(array)

  160.         arr2 = mnp.array(arr1, copy=False)

  161.         arr3 = mnp.array(arr1)

  162.         arr4 = mnp.asarray(array, dtype='int32')

  163.         arr5 = mnp.asarray(arr4, dtype=mnp.int32)

  164.         assert arr1 is arr2

  165.         assert arr1 is not arr3

  166.         assert arr4 is arr5

  167. 

  168.     # Additional tests for nested tensor/numpy_array mixture

  169.     mnp_input = [(mnp.ones(3,), mnp.ones(3)), [[1, 1, 1], (1, 1, 1)]]

  170.     onp_input = [(onp.ones(3,), onp.ones(3)), [[1, 1, 1], (1, 1, 1)]]

  171. 

  172.     actual = onp.array(onp_input)

  173.     expected = mnp.array(mnp_input).asnumpy()

  174.     match_array(actual, expected, error=7)

  175. 

  176. 

  177. @pytest.mark.level1

  178. @pytest.mark.platform_arm_ascend_training

  179. @pytest.mark.platform_x86_ascend_training

  180. @pytest.mark.platform_x86_gpu_training

  181. @pytest.mark.platform_x86_cpu

  182. @pytest.mark.env_onecard

  183. def test_asfarray():

  184.     test_case = Cases()

  185.     for array in test_case.array_sets:

  186.         # Check for dtype matching

  187.         actual = onp.asfarray(array)

  188.         expected = mnp.asfarray(array).asnumpy()

  189.         # Since we set float32/int32 as the default dtype in mindspore, we need

  190.         # to make a conversion between numpy.asarray and mindspore.numpy.asarray

  191.         if actual.dtype is onp.dtype('float64'):

  192.             assert expected.dtype == onp.dtype('float32')

  193.         else:

  194.             assert actual.dtype == expected.dtype

  195.         match_array(actual, expected, error=7)

  196. 

  197.         for i in range(len(test_case.onp_dtypes)):

  198.             actual = onp.asfarray(array, test_case.onp_dtypes[i])

  199.             expected = mnp.asfarray(array, test_case.mnp_dtypes[i]).asnumpy()

  200.             match_array(actual, expected, error=7)

  201. 

  202.     # Additional tests for nested tensor/numpy_array mixture

  203.     mnp_input = [(mnp.ones(3,), mnp.ones(3)), [[1, 1, 1], (1, 1, 1)]]

  204.     onp_input = [(onp.ones(3,), onp.ones(3)), [[1, 1, 1], (1, 1, 1)]]

  205. 

  206.     actual = onp.asfarray(onp_input)

  207.     expected = mnp.asfarray(mnp_input).asnumpy()

  208.     match_array(actual, expected, error=7)

  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_zeros():

  218.     test_case = Cases()

  219.     for shape in test_case.all_shapes:

  220.         for i in range(len(test_case.onp_dtypes)):

  221.             actual = onp.zeros(shape, test_case.onp_dtypes[i])

  222.             expected = mnp.zeros(shape, test_case.mnp_dtypes[i]).asnumpy()

  223.             match_array(actual, expected)

  224.         actual = onp.zeros(shape)

  225.         expected = mnp.zeros(shape).asnumpy()

  226.         match_array(actual, expected)

  227. 

  228. 

  229. @pytest.mark.level1

  230. @pytest.mark.platform_arm_ascend_training

  231. @pytest.mark.platform_x86_ascend_training

  232. @pytest.mark.platform_x86_gpu_training

  233. @pytest.mark.platform_x86_cpu

  234. @pytest.mark.env_onecard

  235. def test_ones():

  236.     test_case = Cases()

  237.     for shape in test_case.all_shapes:

  238.         for i in range(len(test_case.onp_dtypes)):

  239.             actual = onp.ones(shape, test_case.onp_dtypes[i])

  240.             expected = mnp.ones(shape, test_case.mnp_dtypes[i]).asnumpy()

  241.             match_array(actual, expected)

  242.         actual = onp.ones(shape)

  243.         expected = mnp.ones(shape).asnumpy()

  244.         match_array(actual, expected)

  245. 

  246. 

  247. @pytest.mark.level1

  248. @pytest.mark.platform_arm_ascend_training

  249. @pytest.mark.platform_x86_ascend_training

  250. @pytest.mark.platform_x86_gpu_training

  251. @pytest.mark.platform_x86_cpu

  252. @pytest.mark.env_onecard

  253. def test_full():

  254.     actual = onp.full((2, 2), [1, 2])

  255.     expected = mnp.full((2, 2), [1, 2]).asnumpy()

  256.     match_array(actual, expected)

  257. 

  258.     actual = onp.full((2, 3), True)

  259.     expected = mnp.full((2, 3), True).asnumpy()

  260.     match_array(actual, expected)

  261. 

  262.     actual = onp.full((3, 4, 5), 7.5)

  263.     expected = mnp.full((3, 4, 5), 7.5).asnumpy()

  264.     match_array(actual, expected)

  265. 

  266. 

  267. @pytest.mark.level1

  268. @pytest.mark.platform_arm_ascend_training

  269. @pytest.mark.platform_x86_ascend_training

  270. @pytest.mark.platform_x86_gpu_training

  271. @pytest.mark.platform_x86_cpu

  272. @pytest.mark.env_onecard

  273. def test_eye():

  274.     test_case = Cases()

  275.     for i in range(len(test_case.onp_dtypes)):

  276.         for m in range(1, 5):

  277.             actual = onp.eye(m, dtype=test_case.onp_dtypes[i])

  278.             expected = mnp.eye(m, dtype=test_case.mnp_dtypes[i]).asnumpy()

  279.             match_array(actual, expected)

  280.             for n in range(1, 5):

  281.                 for k in range(0, 5):

  282.                     actual = onp.eye(m, n, k, dtype=test_case.onp_dtypes[i])

  283.                     expected = mnp.eye(

  284.                         m, n, k, dtype=test_case.mnp_dtypes[i]).asnumpy()

  285.                     match_array(actual, expected)

  286. 

  287. 

  288. @pytest.mark.level1

  289. @pytest.mark.platform_arm_ascend_training

  290. @pytest.mark.platform_x86_ascend_training

  291. @pytest.mark.platform_x86_gpu_training

  292. @pytest.mark.platform_x86_cpu

  293. @pytest.mark.env_onecard

  294. def test_identity():

  295.     test_case = Cases()

  296.     for i in range(len(test_case.onp_dtypes)):

  297.         for m in range(1, 5):

  298.             actual = onp.identity(m, dtype=test_case.onp_dtypes[i])

  299.             expected = mnp.identity(m, dtype=test_case.mnp_dtypes[i]).asnumpy()

  300.             match_array(actual, expected)

  301. 

  302. 

  303. @pytest.mark.level1

  304. @pytest.mark.platform_arm_ascend_training

  305. @pytest.mark.platform_x86_ascend_training

  306. @pytest.mark.platform_x86_gpu_training

  307. @pytest.mark.platform_x86_cpu

  308. @pytest.mark.env_onecard

  309. def test_arange():

  310.     actual = onp.arange(10)

  311.     expected = mnp.arange(10).asnumpy()

  312.     match_array(actual, expected)

  313. 

  314.     actual = onp.arange(0, 10)

  315.     expected = mnp.arange(0, 10).asnumpy()

  316.     match_array(actual, expected)

  317. 

  318.     actual = onp.arange(start=10)

  319.     expected = mnp.arange(start=10).asnumpy()

  320.     match_array(actual, expected)

  321. 

  322.     actual = onp.arange(start=10, step=0.1)

  323.     expected = mnp.arange(start=10, step=0.1).asnumpy()

  324.     match_array(actual, expected, error=6)

  325. 

  326.     actual = onp.arange(10, step=0.1)

  327.     expected = mnp.arange(10, step=0.1).asnumpy()

  328.     match_array(actual, expected, error=6)

  329. 

  330.     actual = onp.arange(0.1, 9.9)

  331.     expected = mnp.arange(0.1, 9.9).asnumpy()

  332.     match_array(actual, expected, error=6)

  333. 

  334. 

  335. @pytest.mark.level0

  336. @pytest.mark.platform_arm_ascend_training

  337. @pytest.mark.platform_x86_ascend_training

  338. @pytest.mark.platform_x86_gpu_training

  339. @pytest.mark.platform_x86_cpu

  340. @pytest.mark.env_onecard

  341. def test_linspace():

  342.     actual = onp.linspace(2.0, 3.0, dtype=onp.float32)

  343.     expected = mnp.linspace(2.0, 3.0).asnumpy()

  344.     match_array(actual, expected, error=6)

  345. 

  346.     actual = onp.linspace(2.0, 3.0, num=5, dtype=onp.float32)

  347.     expected = mnp.linspace(2.0, 3.0, num=5).asnumpy()

  348.     match_array(actual, expected, error=6)

  349. 

  350.     actual = onp.linspace(

  351.         2.0, 3.0, num=5, endpoint=False, dtype=onp.float32)

  352.     expected = mnp.linspace(2.0, 3.0, num=5, endpoint=False).asnumpy()

  353.     match_array(actual, expected, error=6)

  354. 

  355.     actual = onp.linspace(2.0, 3.0, num=5, retstep=True, dtype=onp.float32)

  356.     expected = mnp.linspace(2.0, 3.0, num=5, retstep=True)

  357.     match_array(actual[0], expected[0].asnumpy())

  358.     assert actual[1] == expected[1].asnumpy()

  359. 

  360.     actual = onp.linspace(2.0, [3, 4, 5], num=5,

  361.                           endpoint=False, dtype=onp.float32)

  362.     expected = mnp.linspace(

  363.         2.0, [3, 4, 5], num=5, endpoint=False).asnumpy()

  364.     match_array(actual, expected, error=6)

  365. 

  366.     actual = onp.linspace(2.0, [[3, 4, 5]], num=5, endpoint=False, axis=2)

  367.     expected = mnp.linspace(2.0, [[3, 4, 5]], num=5, endpoint=False, axis=2).asnumpy()

  368.     match_array(actual, expected, error=6)

  369. 

  370.     start = onp.random.random([2, 1, 4]).astype("float32")

  371.     stop = onp.random.random([1, 5, 1]).astype("float32")

  372.     actual = onp.linspace(start, stop, num=20, retstep=True,

  373.                           endpoint=False, dtype=onp.float32)

  374.     expected = mnp.linspace(to_tensor(start), to_tensor(stop), num=20,

  375.                             retstep=True, endpoint=False)

  376.     match_array(actual[0], expected[0].asnumpy(), error=6)

  377.     match_array(actual[1], expected[1].asnumpy(), error=6)

  378. 

  379.     actual = onp.linspace(start, stop, num=20, retstep=True,

  380.                           endpoint=False, dtype=onp.int16)

  381.     expected = mnp.linspace(to_tensor(start), to_tensor(stop), num=20,

  382.                             retstep=True, endpoint=False, dtype=mnp.int16)

  383.     match_array(actual[0], expected[0].asnumpy(), error=6)

  384.     match_array(actual[1], expected[1].asnumpy(), error=6)

  385. 

  386.     for axis in range(2):

  387.         actual = onp.linspace(start, stop, num=20, retstep=False,

  388.                               endpoint=False, dtype=onp.float32, axis=axis)

  389.         expected = mnp.linspace(to_tensor(start), to_tensor(stop), num=20,

  390.                                 retstep=False, endpoint=False, dtype=mnp.float32, axis=axis)

  391.         match_array(actual, expected.asnumpy(), error=6)

  392. 

  393. 

  394. @pytest.mark.level1

  395. @pytest.mark.platform_arm_ascend_training

  396. @pytest.mark.platform_x86_ascend_training

  397. @pytest.mark.platform_x86_gpu_training

  398. @pytest.mark.platform_x86_cpu

  399. @pytest.mark.env_onecard

  400. def test_logspace():

  401.     actual = onp.logspace(2.0, 3.0, dtype=onp.float32)

  402.     expected = mnp.logspace(2.0, 3.0).asnumpy()

  403.     match_array(actual, expected, error=3)

  404. 

  405.     actual = onp.logspace(2.0, 3.0, num=5, dtype=onp.float32)

  406.     expected = mnp.logspace(2.0, 3.0, num=5).asnumpy()

  407.     match_array(actual, expected, error=3)

  408. 

  409.     actual = onp.logspace(

  410.         2.0, 3.0, num=5, endpoint=False, dtype=onp.float32)

  411.     expected = mnp.logspace(2.0, 3.0, num=5, endpoint=False).asnumpy()

  412.     match_array(actual, expected, error=3)

  413. 

  414.     actual = onp.logspace(2.0, [3, 4, 5], num=5, base=2,

  415.                           endpoint=False, dtype=onp.float32)

  416.     expected = mnp.logspace(

  417.         2.0, [3, 4, 5], num=5, base=2, endpoint=False).asnumpy()

  418.     match_array(actual, expected, error=3)

  419. 

  420. 

  421. @pytest.mark.level1

  422. @pytest.mark.platform_arm_ascend_training

  423. @pytest.mark.platform_x86_ascend_training

  424. @pytest.mark.platform_x86_gpu_training

  425. @pytest.mark.platform_x86_cpu

  426. @pytest.mark.env_onecard

  427. def test_empty():

  428.     test_case = Cases()

  429.     for shape in test_case.all_shapes:

  430.         for mnp_dtype, onp_dtype in zip(test_case.mnp_dtypes,

  431.                                         test_case.onp_dtypes):

  432.             actual = mnp.empty(shape, mnp_dtype).asnumpy()

  433.             expected = onp.empty(shape, onp_dtype)

  434.             match_meta(actual, expected)

  435. 

  436. 

  437. @pytest.mark.level1

  438. @pytest.mark.platform_arm_ascend_training

  439. @pytest.mark.platform_x86_ascend_training

  440. @pytest.mark.platform_x86_gpu_training

  441. @pytest.mark.platform_x86_cpu

  442. @pytest.mark.env_onecard

  443. def test_empty_like():

  444.     test_case = Cases()

  445.     for mnp_proto, onp_proto in zip(test_case.mnp_prototypes, test_case.onp_prototypes):

  446.         actual = mnp.empty_like(mnp_proto).asnumpy()

  447.         expected = onp.empty_like(onp_proto)

  448.         assert actual.shape == expected.shape

  449. 

  450.         for mnp_dtype, onp_dtype in zip(test_case.mnp_dtypes,

  451.                                         test_case.onp_dtypes):

  452.             actual = mnp.empty_like(mnp_proto, dtype=mnp_dtype).asnumpy()

  453.             expected = onp.empty_like(onp_proto, dtype=onp_dtype)

  454.             match_meta(actual, expected)

  455. 

  456. 

  457. def run_x_like(mnp_fn, onp_fn):

  458.     test_case = Cases()

  459.     for mnp_proto, onp_proto in zip(test_case.mnp_prototypes, test_case.onp_prototypes):

  460.         actual = mnp_fn(mnp_proto).asnumpy()

  461.         expected = onp_fn(onp_proto)

  462.         match_array(actual, expected)

  463. 

  464.         for shape in test_case.all_shapes:

  465.             actual = mnp_fn(mnp_proto, shape=shape).asnumpy()

  466.             expected = onp_fn(onp_proto, shape=shape)

  467.             match_array(actual, expected)

  468.             for mnp_dtype, onp_dtype in zip(test_case.mnp_dtypes,

  469.                                             test_case.onp_dtypes):

  470.                 actual = mnp_fn(mnp_proto, dtype=mnp_dtype).asnumpy()

  471.                 expected = onp_fn(onp_proto, dtype=onp_dtype)

  472.                 match_array(actual, expected)

  473. 

  474.                 actual = mnp_fn(mnp_proto, dtype=mnp_dtype,

  475.                                 shape=shape).asnumpy()

  476.                 expected = onp_fn(onp_proto, dtype=onp_dtype, shape=shape)

  477.                 match_array(actual, expected)

  478. 

  479. 

  480. @pytest.mark.level1

  481. @pytest.mark.platform_arm_ascend_training

  482. @pytest.mark.platform_x86_ascend_training

  483. @pytest.mark.platform_x86_gpu_training

  484. @pytest.mark.platform_x86_cpu

  485. @pytest.mark.env_onecard

  486. def test_ones_like():

  487.     run_x_like(mnp.ones_like, onp.ones_like)

  488. 

  489. 

  490. @pytest.mark.level1

  491. @pytest.mark.platform_arm_ascend_training

  492. @pytest.mark.platform_x86_ascend_training

  493. @pytest.mark.platform_x86_gpu_training

  494. @pytest.mark.platform_x86_cpu

  495. @pytest.mark.env_onecard

  496. def test_zeros_like():

  497.     run_x_like(mnp.zeros_like, onp.zeros_like)

  498. 

  499. 

  500. @pytest.mark.level1

  501. @pytest.mark.platform_arm_ascend_training

  502. @pytest.mark.platform_x86_ascend_training

  503. @pytest.mark.platform_x86_gpu_training

  504. @pytest.mark.platform_x86_cpu

  505. @pytest.mark.env_onecard

  506. def test_full_like():

  507.     test_case = Cases()

  508.     for mnp_proto, onp_proto in zip(test_case.mnp_prototypes, test_case.onp_prototypes):

  509.         shape = onp.zeros_like(onp_proto).shape

  510.         fill_value = rand_int()

  511.         actual = mnp.full_like(mnp_proto, to_tensor(fill_value)).asnumpy()

  512.         expected = onp.full_like(onp_proto, fill_value)

  513.         match_array(actual, expected)

  514. 

  515.         for i in range(len(shape) - 1, 0, -1):

  516.             fill_value = rand_int(*shape[i:])

  517.             actual = mnp.full_like(mnp_proto, to_tensor(fill_value)).asnumpy()

  518.             expected = onp.full_like(onp_proto, fill_value)

  519.             match_array(actual, expected)

  520. 

  521.             fill_value = rand_int(1, *shape[i + 1:])

  522.             actual = mnp.full_like(mnp_proto, to_tensor(fill_value)).asnumpy()

  523.             expected = onp.full_like(onp_proto, fill_value)

  524.             match_array(actual, expected)

  525. 

  526. 

  527. @pytest.mark.level1

  528. @pytest.mark.platform_arm_ascend_training

  529. @pytest.mark.platform_x86_ascend_training

  530. @pytest.mark.platform_x86_gpu_training

  531. @pytest.mark.platform_x86_cpu

  532. @pytest.mark.env_onecard

  533. def test_tri_triu_tril():

  534.     x = mnp.ones((16, 32), dtype="bool")

  535.     match_array(mnp.tril(x).asnumpy(), onp.tril(x.asnumpy()))

  536.     match_array(mnp.tril(x, -1).asnumpy(), onp.tril(x.asnumpy(), -1))

  537.     match_array(mnp.triu(x).asnumpy(), onp.triu(x.asnumpy()))

  538.     match_array(mnp.triu(x, -1).asnumpy(), onp.triu(x.asnumpy(), -1))

  539. 

  540.     x = mnp.ones((64, 64), dtype="uint8")

  541.     match_array(mnp.tril(x).asnumpy(), onp.tril(x.asnumpy()))

  542.     match_array(mnp.tril(x, 25).asnumpy(), onp.tril(x.asnumpy(), 25))

  543.     match_array(mnp.triu(x).asnumpy(), onp.triu(x.asnumpy()))

  544.     match_array(mnp.triu(x, 25).asnumpy(), onp.triu(x.asnumpy(), 25))

  545. 

  546.     match_array(mnp.tri(64, 64).asnumpy(), onp.tri(64, 64))

  547.     match_array(mnp.tri(64, 64, -10).asnumpy(), onp.tri(64, 64, -10))

  548. 

  549. 

  550. @pytest.mark.level1

  551. @pytest.mark.platform_x86_gpu_training

  552. @pytest.mark.platform_x86_cpu

  553. @pytest.mark.env_onecard

  554. def test_nancumsum():

  555.     x = rand_int(2, 3, 4, 5)

  556.     x[0][2][1][3] = onp.nan

  557.     x[1][0][2][4] = onp.nan

  558.     x[1][1][1][1] = onp.nan

  559.     match_res(mnp.nancumsum, onp.nancumsum, x)

  560.     match_res(mnp.nancumsum, onp.nancumsum, x, axis=-2)

  561.     match_res(mnp.nancumsum, onp.nancumsum, x, axis=0)

  562.     match_res(mnp.nancumsum, onp.nancumsum, x, axis=3)

  563. 

  564. 

  565. def mnp_diagonal(arr):

  566.     return mnp.diagonal(arr, offset=2, axis1=-1, axis2=0)

  567. 

  568. 

  569. def onp_diagonal(arr):

  570.     return onp.diagonal(arr, offset=2, axis1=-1, axis2=0)

  571. 

  572. 

  573. @pytest.mark.level1

  574. @pytest.mark.platform_arm_ascend_training

  575. @pytest.mark.platform_x86_ascend_training

  576. @pytest.mark.platform_x86_gpu_training

  577. @pytest.mark.platform_x86_cpu

  578. @pytest.mark.env_onecard

  579. def test_diagonal():

  580. 

  581.     arr = rand_int(3, 5)

  582.     for i in [-1, 0, 2]:

  583.         match_res(mnp.diagonal, onp.diagonal, arr, offset=i, axis1=0, axis2=1)

  584.         match_res(mnp.diagonal, onp.diagonal, arr, offset=i, axis1=1, axis2=0)

  585. 

  586.     arr = rand_int(7, 4, 9)

  587.     for i in [-1, 0, 2]:

  588.         match_res(mnp.diagonal, onp.diagonal, arr, offset=i, axis1=0, axis2=-1)

  589.         match_res(mnp.diagonal, onp.diagonal, arr, offset=i, axis1=-2, axis2=2)

  590.         match_res(mnp.diagonal, onp.diagonal, arr,

  591.                   offset=i, axis1=-1, axis2=-2)

  592. 

  593. 

  594. def mnp_trace(arr):

  595.     return mnp.trace(arr, offset=4, axis1=1, axis2=2)

  596. 

  597. 

  598. def onp_trace(arr):

  599.     return onp.trace(arr, offset=4, axis1=1, axis2=2)

  600. 

  601. 

  602. @pytest.mark.level1

  603. @pytest.mark.platform_arm_ascend_training

  604. @pytest.mark.platform_x86_ascend_training

  605. @pytest.mark.platform_x86_gpu_training

  606. @pytest.mark.platform_x86_cpu

  607. @pytest.mark.env_onecard

  608. def test_trace():

  609. 

  610.     arr = rand_int(3, 5)

  611.     for i in [-1, 0]:

  612.         match_res(mnp.trace, onp.trace, arr, offset=i, axis1=0, axis2=1)

  613.         match_res(mnp.trace, onp.trace, arr, offset=i, axis1=1, axis2=0)

  614. 

  615.     arr = rand_int(7, 4, 9)

  616.     for i in [-1, 0, 2]:

  617.         match_res(mnp.trace, onp.trace, arr, offset=i, axis1=0, axis2=-1)

  618.         match_res(mnp.trace, onp.trace, arr, offset=i, axis1=-2, axis2=2)

  619.         match_res(mnp.trace, onp.trace, arr, offset=i, axis1=-1, axis2=-2)

  620. 

  621. 

  622. 

  623. def mnp_meshgrid(*xi):

  624.     a = mnp.meshgrid(*xi)

  625.     b = mnp.meshgrid(*xi, sparse=True)

  626.     c = mnp.meshgrid(*xi, indexing='ij')

  627.     d = mnp.meshgrid(*xi, sparse=False, indexing='ij')

  628.     return a, b, c, d

  629. 

  630. 

  631. def onp_meshgrid(*xi):

  632.     a = onp.meshgrid(*xi)

  633.     b = onp.meshgrid(*xi, sparse=True)

  634.     c = onp.meshgrid(*xi, indexing='ij')

  635.     d = onp.meshgrid(*xi, sparse=False, indexing='ij')

  636.     return a, b, c, d

  637. 

  638. 

  639. @pytest.mark.level1

  640. @pytest.mark.platform_arm_ascend_training

  641. @pytest.mark.platform_x86_ascend_training

  642. @pytest.mark.platform_x86_gpu_training

  643. @pytest.mark.platform_x86_cpu

  644. @pytest.mark.env_onecard

  645. def test_meshgrid():

  646.     xi = (onp.full(3, 2), onp.full(1, 5), onp.full(

  647.         (2, 3), 9), onp.full((4, 5, 6), 7))

  648.     for i in range(len(xi)):

  649.         arrs = xi[i:]

  650.         mnp_arrs = map(to_tensor, arrs)

  651.         for mnp_res, onp_res in zip(mnp_meshgrid(*mnp_arrs), onp_meshgrid(*arrs)):

  652.             match_all_arrays(mnp_res, onp_res)

  653. 

  654. 

  655. @pytest.mark.level1

  656. @pytest.mark.platform_arm_ascend_training

  657. @pytest.mark.platform_x86_ascend_training

  658. @pytest.mark.platform_x86_gpu_training

  659. @pytest.mark.platform_x86_cpu

  660. @pytest.mark.env_onecard

  661. def test_mgrid():

  662.     mnp_res = mnp.mgrid[0:5]

  663.     onp_res = onp.mgrid[0:5]

  664.     match_all_arrays(mnp_res, onp_res, error=5)

  665. 

  666.     mnp_res = mnp.mgrid[2:30:4j, -10:20:7, 2:5:0.5]

  667.     onp_res = onp.mgrid[2:30:4j, -10:20:7, 2:5:0.5]

  668.     match_all_arrays(mnp_res, onp_res, error=5)

  669. 

  670. 

  671. @pytest.mark.level1

  672. @pytest.mark.platform_arm_ascend_training

  673. @pytest.mark.platform_x86_ascend_training

  674. @pytest.mark.platform_x86_gpu_training

  675. @pytest.mark.platform_x86_cpu

  676. @pytest.mark.env_onecard

  677. def test_ogrid():

  678.     mnp_res = mnp.ogrid[0:5]

  679.     onp_res = onp.ogrid[0:5]

  680.     match_all_arrays(mnp_res, onp_res, error=5)

  681. 

  682.     mnp_res = mnp.ogrid[2:30:4j, -10:20:7, 2:5:0.5]

  683.     onp_res = onp.ogrid[2:30:4j, -10:20:7, 2:5:0.5]

  684.     match_all_arrays(mnp_res, onp_res, error=5)

  685. 

  686. 

  687. @pytest.mark.level1

  688. @pytest.mark.platform_arm_ascend_training

  689. @pytest.mark.platform_x86_ascend_training

  690. @pytest.mark.platform_x86_gpu_training

  691. @pytest.mark.platform_x86_cpu

  692. @pytest.mark.env_onecard

  693. def test_diagflat():

  694.     arrs = [rand_int(2, 3)]

  695.     for arr in arrs:

  696.         for i in [-2, 0, 7]:

  697.             match_res(mnp.diagflat, onp.diagflat, arr, k=i)

  698. 

  699. 

  700. @pytest.mark.level1

  701. @pytest.mark.platform_arm_ascend_training

  702. @pytest.mark.platform_x86_ascend_training

  703. @pytest.mark.platform_x86_gpu_training

  704. @pytest.mark.platform_x86_cpu

  705. @pytest.mark.env_onecard

  706. def test_diag():

  707.     arrs = [rand_int(7), rand_int(5, 5), rand_int(3, 8), rand_int(9, 6)]

  708.     for arr in arrs:

  709.         for i in [-10, -5, -1, 0, 2, 5, 6, 10]:

  710.             match_res(mnp.diag, onp.diag, arr, k=i)

  711. 

  712. 

  713. @pytest.mark.level1

  714. @pytest.mark.platform_arm_ascend_training

  715. @pytest.mark.platform_x86_ascend_training

  716. @pytest.mark.platform_x86_gpu_training

  717. @pytest.mark.platform_x86_cpu

  718. @pytest.mark.env_onecard

  719. def test_diag_indices():

  720.     mnp_res = mnp.diag_indices(5, 7)

  721.     onp_res = onp.diag_indices(5, 7)

  722.     match_all_arrays(mnp_res, onp_res)

  723. 

  724. 

  725. def mnp_ix_(*args):

  726.     return mnp.ix_(*args)

  727. 

  728. 

  729. def onp_ix_(*args):

  730.     return onp.ix_(*args)

  731. 

  732. 

  733. @pytest.mark.level1

  734. @pytest.mark.platform_arm_ascend_training

  735. @pytest.mark.platform_x86_ascend_training

  736. @pytest.mark.platform_x86_gpu_training

  737. @pytest.mark.platform_x86_cpu

  738. @pytest.mark.env_onecard

  739. def test_ix_():

  740.     arrs = [rand_int(i + 1) for i in range(10)]

  741.     for i in range(10):

  742.         test_arrs = arrs[:i + 1]

  743.         match_res(mnp_ix_, onp_ix_, *test_arrs)

  744. 

  745. 

  746. def mnp_indices():

  747.     a = mnp.indices((2, 3))

  748.     b = mnp.indices((2, 3, 4), sparse=True)

  749.     return a, b

  750. 

  751. 

  752. def onp_indices():

  753.     a = onp.indices((2, 3))

  754.     b = onp.indices((2, 3, 4), sparse=True)

  755.     return a, b

  756. 

  757. 

  758. def test_indices():

  759.     run_multi_test(mnp_indices, onp_indices, ())

  760. 

  761. 

  762. @pytest.mark.level1

  763. @pytest.mark.platform_arm_ascend_training

  764. @pytest.mark.platform_x86_ascend_training

  765. @pytest.mark.platform_x86_gpu_training

  766. @pytest.mark.platform_x86_cpu

  767. @pytest.mark.env_onecard

  768. def test_geomspace():

  769.     start = onp.arange(1, 7).reshape(2, 3)

  770.     end = [1000, 2000, 3000]

  771.     match_array(mnp.geomspace(1, 256, num=9).asnumpy(),

  772.                 onp.geomspace(1, 256, num=9), error=1)

  773.     match_array(mnp.geomspace(1, 256, num=8, endpoint=False).asnumpy(),

  774.                 onp.geomspace(1, 256, num=8, endpoint=False), error=1)

  775.     match_array(mnp.geomspace(to_tensor(start), end, num=4).asnumpy(),

  776.                 onp.geomspace(start, end, num=4), error=1)

  777.     match_array(mnp.geomspace(to_tensor(start), end, num=4, endpoint=False).asnumpy(),

  778.                 onp.geomspace(start, end, num=4, endpoint=False), error=1)

  779.     match_array(mnp.geomspace(to_tensor(start), end, num=4, axis=-1).asnumpy(),

  780.                 onp.geomspace(start, end, num=4, axis=-1), error=1)

  781.     match_array(mnp.geomspace(to_tensor(start), end, num=4, endpoint=False, axis=-1).asnumpy(),

  782.                 onp.geomspace(start, end, num=4, endpoint=False, axis=-1), error=1)

  783. 

  784.     start = onp.arange(1, 1 + 2*3*4*5).reshape(2, 3, 4, 5)

  785.     end = [1000, 2000, 3000, 4000, 5000]

  786.     for i in range(-5, 5):

  787.         match_array(mnp.geomspace(to_tensor(start), end, num=4, axis=i).asnumpy(),

  788.                     onp.geomspace(start, end, num=4, axis=i), error=1)

  789. 

  790. 

  791. @pytest.mark.level1

  792. @pytest.mark.platform_arm_ascend_training

  793. @pytest.mark.platform_x86_ascend_training

  794. @pytest.mark.platform_x86_gpu_training

  795. @pytest.mark.platform_x86_cpu

  796. @pytest.mark.env_onecard

  797. def test_vander():

  798.     arrs = [rand_int(i + 3) for i in range(3)]

  799.     for i in range(3):

  800.         mnp_vander = mnp.vander(to_tensor(arrs[i]))

  801.         onp_vander = onp.vander(arrs[i])

  802.         match_all_arrays(mnp_vander, onp_vander, error=1e-4)

  803.         mnp_vander = mnp.vander(to_tensor(arrs[i]), N=2, increasing=True)

  804.         onp_vander = onp.vander(arrs[i], N=2, increasing=True)

  805.         match_all_arrays(mnp_vander, onp_vander, error=1e-4)

  806. 

  807. 

  808. @pytest.mark.level1

  809. @pytest.mark.platform_arm_ascend_training

  810. @pytest.mark.platform_x86_ascend_training

  811. @pytest.mark.platform_x86_gpu_training

  812. @pytest.mark.platform_x86_cpu

  813. @pytest.mark.env_onecard

  814. def test_asarray_exception():

  815.     with pytest.raises(TypeError):

  816.         mnp.asarray({1, 2, 3})

  817. 

  818. 

  819. @pytest.mark.level1

  820. @pytest.mark.platform_arm_ascend_training

  821. @pytest.mark.platform_x86_ascend_training

  822. @pytest.mark.platform_x86_gpu_training

  823. @pytest.mark.platform_x86_cpu

  824. @pytest.mark.env_onecard

  825. def test_linspace_exception():

  826.     with pytest.raises(TypeError):

  827.         mnp.linspace(0, 1, num=2.5)

  828. 

  829. 

  830. @pytest.mark.level1

  831. @pytest.mark.platform_arm_ascend_training

  832. @pytest.mark.platform_x86_ascend_training

  833. @pytest.mark.platform_x86_gpu_training

  834. @pytest.mark.platform_x86_cpu

  835. @pytest.mark.env_onecard

  836. def test_empty_like_exception():

  837.     with pytest.raises(ValueError):

  838.         mnp.empty_like([[1, 2, 3], [4, 5]])