From 5744cf7902779a2a880ab41bfca27b49dac497a7 Mon Sep 17 00:00:00 2001 From: Margaret_wangrui Date: Sat, 11 Sep 2021 10:37:07 +0800 Subject: [PATCH] Add assignment operators and math operators tests --- .../simple_expression/test_assignment_ops.py | 480 ++++++++++++++ .../syntax/simple_expression/test_math_ops.py | 587 ++++++++++++++++++ 2 files changed, 1067 insertions(+) create mode 100644 tests/syntax/simple_expression/test_assignment_ops.py create mode 100644 tests/syntax/simple_expression/test_math_ops.py diff --git a/tests/syntax/simple_expression/test_assignment_ops.py b/tests/syntax/simple_expression/test_assignment_ops.py new file mode 100644 index 00000000000..7aefb3899ee --- /dev/null +++ b/tests/syntax/simple_expression/test_assignment_ops.py @@ -0,0 +1,480 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ + +import numpy as np +import mindspore.context as context +import mindspore.nn as nn +from mindspore import Tensor, Parameter +from mindspore.common.initializer import initializer +from mindspore.ops import operations as P + +context.set_context(mode=context.GRAPH_MODE) + + +class Assign(nn.Cell): + def __init__(self, x, y): + super(Assign, self).__init__() + self.x = Parameter(initializer(x, x.shape), name="x") + self.y = Parameter(initializer(y, y.shape), name="y") + self.assign = P.Assign() + + def construct(self): + self.assign(self.y, self.x) + return self.y + + +def test_assign_bool(): + x = Tensor(np.ones([3, 3]).astype(np.bool_)) + y = Tensor(np.zeros([3, 3]).astype(np.bool_)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.bool_) + print(output) + assert np.all(output == output_expect) + + +def test_assign_int8(): + x = Tensor(np.ones([3, 3]).astype(np.int8)) + y = Tensor(np.zeros([3, 3]).astype(np.int8)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.int8) + print(output) + assert np.all(output == output_expect) + + +def test_assign_uint8(): + x = Tensor(np.ones([3, 3]).astype(np.uint8)) + y = Tensor(np.zeros([3, 3]).astype(np.uint8)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.uint8) + print(output) + assert np.all(output == output_expect) + + +def test_assign_int16(): + x = Tensor(np.ones([3, 3]).astype(np.int16)) + y = Tensor(np.zeros([3, 3]).astype(np.int16)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.int16) + print(output) + assert np.all(output == output_expect) + + +def test_assign_uint16(): + x = Tensor(np.ones([3, 3]).astype(np.uint16)) + y = Tensor(np.zeros([3, 3]).astype(np.uint16)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.uint16) + print(output) + assert np.all(output == output_expect) + + +def test_assign_int32(): + x = Tensor(np.ones([3, 3]).astype(np.int32)) + y = Tensor(np.zeros([3, 3]).astype(np.int32)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.int32) + print(output) + assert np.all(output == output_expect) + + +def test_assign_uint32(): + x = Tensor(np.ones([3, 3]).astype(np.uint32)) + y = Tensor(np.zeros([3, 3]).astype(np.uint32)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.uint32) + print(output) + assert np.all(output == output_expect) + + +def test_assign_int64(): + x = Tensor(np.ones([3, 3]).astype(np.int64)) + y = Tensor(np.zeros([3, 3]).astype(np.int64)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.int64) + print(output) + assert np.all(output == output_expect) + + +def test_assign_uint64(): + x = Tensor(np.ones([3, 3]).astype(np.uint64)) + y = Tensor(np.zeros([3, 3]).astype(np.uint64)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.ones([3, 3]).astype(np.uint64) + print(output) + assert np.all(output == output_expect) + + +def test_assign_float16(): + x = Tensor(np.array([[0.1, 0.2, 0.3], + [0.4, 0.5, 0.5], + [0.6, 0.7, 0.8]]).astype(np.float16)) + y = Tensor(np.array([[0.4, 0.5, 0.5], + [0.6, 0.7, 0.8], + [0.1, 0.2, 0.3]]).astype(np.float16)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.array([[0.1, 0.2, 0.3], + [0.4, 0.5, 0.5], + [0.6, 0.7, 0.8]]).astype(np.float16) + print(output) + assert np.all(output - output_expect < 1e-6) + + +def test_assign_float32(): + x = Tensor(np.array([[0.1, 0.2, 0.3], + [0.4, 0.5, 0.5], + [0.6, 0.7, 0.8]]).astype(np.float32)) + y = Tensor(np.array([[0.4, 0.5, 0.5], + [0.6, 0.7, 0.8], + [0.1, 0.2, 0.3]]).astype(np.float32)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.array([[0.1, 0.2, 0.3], + [0.4, 0.5, 0.5], + [0.6, 0.7, 0.8]]).astype(np.float32) + print(output) + assert np.all(output - output_expect < 1e-6) + + +def test_assign_float64(): + x = Tensor(np.array([[0.1, 0.2, 0.3], + [0.4, 0.5, 0.5], + [0.6, 0.7, 0.8]]).astype(np.float64)) + y = Tensor(np.array([[0.4, 0.5, 0.5], + [0.6, 0.7, 0.8], + [0.1, 0.2, 0.3]]).astype(np.float64)) + assign = Assign(x, y) + output = assign() + output = output.asnumpy() + output_expect = np.array([[0.1, 0.2, 0.3], + [0.4, 0.5, 0.5], + [0.6, 0.7, 0.8]]).astype(np.float64) + print(output) + assert np.all(output - output_expect < 1e-6) + + +class AssignAdd(nn.Cell): + def __init__(self, x, y): + super(AssignAdd, self).__init__() + self.x = Parameter(initializer(x, x.shape), name="x") + self.y = Parameter(initializer(y, y.shape), name="y") + self.assignadd = P.AssignAdd() + + def construct(self): + self.assignadd(self.y, self.x) + return self.y + + +def test_number_assignadd_number(): + input_x = 2 + result1 = 5 + result2 = 5 + result1 += input_x + assignadd = AssignAdd(result2, input_x) + result2 = assignadd() + expect = 7 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_assignadd_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result1 = Tensor(np.array([[4, -2], [2, 17]])) + result2 = Tensor(np.array([[4, -2], [2, 17]])) + result1 += input_x + result2 = AssignAdd(result2, input_x)() + expect = Tensor(np.array([[6, 0], [5, 20]])) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_assignadd_number(): + input_x = 3 + result1 = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result2 = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result1 += input_x + result2 = AssignAdd(result2, input_x)() + expect = Tensor(np.array([[7, 1], [5, 20]])) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_number_assignadd_tensor(): + result1 = 3 + result2 = 3 + input_x = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result1 += input_x + result2 = AssignAdd(result2, input_x)() + expect = Tensor(np.array([[7, 1], [5, 20]])) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tuple_assignadd_tuple(): + result1 = (1, 2, 3, 4) + result2 = (1, 2, 3, 4) + input_x = (2, 3, 4, 5, 6) + result1 += input_x + result2 = AssignAdd(result2, input_x)() + expect = (1, 2, 3, 4, 2, 3, 4, 5, 6) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_string_assignadd_string(): + result1 = "string111" + result2 = "string111" + input_x = "string222" + result1 += input_x + result2 = AssignAdd(result2, input_x)() + expect = "string111string222" + assert result1 == expect + assert result2 == expect + + +class AssignSub(nn.Cell): + def __init__(self, x, y): + super(AssignSub, self).__init__() + self.x = Parameter(initializer(x, x.shape), name="x") + self.y = Parameter(initializer(y, y.shape), name="y") + self.assignsub = P.AssignSub() + + def construct(self): + self.assignsub(self.y, self.x) + return self.y + + +def test_number_assignsub_number(): + input_x = 2 + result1 = 5 + result2 = 5 + result1 -= input_x + result2 = AssignSub(result2, input_x)() + expect = 3 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_assignsub_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result1 = Tensor(np.array([[4, -2], [2, 17]])) + result2 = Tensor(np.array([[4, -2], [2, 17]])) + result1 -= input_x + result2 = AssignSub(result2, input_x)() + expect = Tensor(np.array([[2, -4], [-1, 14]])) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_assignsub_number(): + input_x = 3 + result1 = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result2 = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result1 -= input_x + result2 = AssignSub(result2, input_x)() + expect = Tensor(np.array([[1, -5], [-1, 14]])) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_number_assignsub_tensor(): + result1 = 3 + result2 = 3 + input_x = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result1 -= input_x + result2 = AssignSub(result2, input_x)() + expect = Tensor(np.array([[-1, 5], [1, -14]])) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_number_assignmul_number(): + input_x = 2 + result = 5 + result *= input_x + expect = 10 + assert np.all(result == expect) + + +def test_tensor_assignmul_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result = Tensor(np.array([[4, -2], [2, 17]])) + result *= input_x + expect = Tensor(np.array([[8, -4], [6, 51]])) + assert np.all(result.asnumpy() == expect) + + +def test_tensor_assignmul_number(): + input_x = 3 + result = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result *= input_x + expect = Tensor(np.array([[12, -6], [6, 51]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assignmul_tensor(): + result = 3 + input_x = Tensor(np.array([[4, -2], [2, 17]])).astype(np.float16) + result *= input_x + expect = Tensor(np.array([[12, -6], [6, 51]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assigndiv_number(): + input_x = 2 + result = 5 + result /= input_x + expect = 2.5 + assert np.all(result == expect) + + +def test_tensor_assigndiv_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result = Tensor(np.array([[4, -2], [6, 15]])) + result /= input_x + expect = Tensor(np.array([[2, -1], [2, 5]])) + assert np.all(result.asnumpy() == expect) + + +def test_tensor_assigndiv_number(): + input_x = 3 + result = Tensor(np.array([[9, -3], [6, 15]])).astype(np.float16) + result /= input_x + expect = Tensor(np.array([[3, -1], [2, 5]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assigndiv_tensor(): + result = 3 + input_x = Tensor(np.array([[2, -2], [2, -2]])).astype(np.float16) + result /= input_x + expect = Tensor(np.array([[1.5, -1.5], [1.5, -1.5]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assignmod_number(): + input_x = 2 + result = 5 + result %= input_x + expect = 1 + assert np.all(result == expect) + + +def test_tensor_assignmod_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result = Tensor(np.array([[4, -2], [6, 15]])) + result %= input_x + expect = Tensor(np.array([[0, 0], [0, 0]])) + assert np.all(result.asnumpy() == expect) + + +def test_tensor_assignmod_number(): + input_x = 3 + result = Tensor(np.array([[9, -3], [7, 15]])).astype(np.float16) + result %= input_x + expect = Tensor(np.array([[0, 0], [1, 0]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assignmod_tensor(): + result = 3 + input_x = Tensor(np.array([[2, -2], [2, -2]])).astype(np.float16) + result %= input_x + expect = Tensor(np.array([[1, -1], [1, -1]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assignmulmul_number(): + input_x = 2 + result = 5 + result **= input_x + expect = 25 + assert np.all(result == expect) + + +def test_tensor_assignmulmul_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result = Tensor(np.array([[4, -2], [6, 5]])) + result **= input_x + expect = Tensor(np.array([[16, 4], [216, 125]])) + assert np.all(result.asnumpy() == expect) + + +def test_tensor_assignmulmul_number(): + input_x = 3 + result = Tensor(np.array([[9, -3], [7, 5]])).astype(np.float16) + result **= input_x + expect = Tensor(np.array([[729, -27], [343, 125]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assignmulmul_tensor(): + result = 3 + input_x = Tensor(np.array([[2, 2], [2, 2]])).astype(np.float16) + result **= input_x + expect = Tensor(np.array([[9, 9], [9, 9]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assigndivdiv_number(): + input_x = 2 + result = 5 + result //= input_x + expect = 2 + assert np.all(result == expect) + + +def test_tensor_assigndivdiv_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + result = Tensor(np.array([[4, -2], [6, 6]])) + result //= input_x + expect = Tensor(np.array([[2, -1], [2, 2]])) + assert np.all(result.asnumpy() == expect) + + +def test_tensor_assigndivdiv_number(): + input_x = 3 + result = Tensor(np.array([[9, -3], [15, 9]])).astype(np.float16) + result //= input_x + expect = Tensor(np.array([[3, -1], [5, 3]])) + assert np.all(result.asnumpy() == expect) + + +def test_number_assigndivdiv_tensor(): + result = 3 + input_x = Tensor(np.array([[1, 2], [2, 2]])).astype(np.float16) + result //= input_x + expect = Tensor(np.array([[3, 1], [1, 1]])) + assert np.all(result.asnumpy() == expect) diff --git a/tests/syntax/simple_expression/test_math_ops.py b/tests/syntax/simple_expression/test_math_ops.py new file mode 100644 index 00000000000..5afcb94095a --- /dev/null +++ b/tests/syntax/simple_expression/test_math_ops.py @@ -0,0 +1,587 @@ +# Copyright 2021 Huawei Technologies Co., Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================ +""" test math ops """ +import numpy as np +import mindspore.context as context +import mindspore.nn as nn +from mindspore import Tensor +from mindspore.ops import operations as P + +context.set_context(mode=context.GRAPH_MODE) + + +class Add(nn.Cell): + def __init__(self): + super(Add, self).__init__() + self.add = P.Add() + + def construct(self, x, y): + z = self.add(x, y) + return z + + +def test_number_add_number(): + input_x = 0.1 + input_y = -3.2 + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = -3.1 + assert result1 == expect + assert result2 == expect + + +def test_tensor_add_tensor_int8(): + input_x = Tensor(np.ones(shape=[3])).astype(np.int8) + input_y = Tensor(np.zeros(shape=[3])).astype(np.int8) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_int16(): + input_x = Tensor(np.ones(shape=[3])).astype(np.int16) + input_y = Tensor(np.zeros(shape=[3])).astype(np.int16) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_int32(): + input_x = Tensor(np.ones(shape=[3])).astype(np.int32) + input_y = Tensor(np.zeros(shape=[3])).astype(np.int32) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_int64(): + input_x = Tensor(np.ones(shape=[3])).astype(np.int64) + input_y = Tensor(np.zeros(shape=[3])).astype(np.int64) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_uint8(): + input_x = Tensor(np.ones(shape=[3])).astype(np.uint8) + input_y = Tensor(np.zeros(shape=[3])).astype(np.uint8) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_uint16(): + input_x = Tensor(np.ones(shape=[3])).astype(np.uint16) + input_y = Tensor(np.zeros(shape=[3])).astype(np.uint16) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_uint32(): + input_x = Tensor(np.ones(shape=[3])).astype(np.uint32) + input_y = Tensor(np.zeros(shape=[3])).astype(np.uint32) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_uint64(): + input_x = Tensor(np.ones(shape=[3])).astype(np.uint64) + input_y = Tensor(np.zeros(shape=[3])).astype(np.uint64) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_float16(): + input_x = Tensor(np.ones(shape=[3])).astype(np.float16) + input_y = Tensor(np.zeros(shape=[3])).astype(np.float16) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_float32(): + input_x = Tensor(np.ones(shape=[3])).astype(np.float32) + input_y = Tensor(np.zeros(shape=[3])).astype(np.float32) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_tensor_float64(): + input_x = Tensor(np.ones(shape=[3])).astype(np.float64) + input_y = Tensor(np.zeros(shape=[3])).astype(np.float64) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) + assert np.all(result1.asnumpy() == expect) + assert np.all(result2.asnumpy() == expect) + + +def test_tensor_add_number(): + input_x = Tensor(np.ones(shape=[3])).astype(np.float32) + input_y = -0.4 + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = np.ones(shape=[3]) * 0.6 + assert np.all(result1.asnumpy() == expect.astype(np.float32)) + assert np.all(result2.asnumpy() == expect.astype(np.float32)) + + +def test_tuple_add_tuple(): + input_x = (Tensor(np.ones(shape=[3])).astype(np.float32)) + input_y = (Tensor(np.ones(shape=[3])).astype(np.float32) * 2) + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = (np.ones(shape=[3]) * 3) + assert np.all(result1.asnumpy() == expect.astype(np.float32)) + assert np.all(result2.asnumpy() == expect.astype(np.float32)) + + +def test_tuple_add_tuple_shape(): + input_x = (Tensor(np.ones(shape=[3])).astype(np.float32)) + input_y = (Tensor(np.ones(shape=[4])).astype(np.float32) * 2) + + result1 = input_x + input_y + add_net = Add() + result2 = add_net(input_x, input_y) + expect = (np.ones(shape=[3]) * 3) + assert np.all(result1.asnumpy() == expect.astype(np.float32)) + assert np.all(result2.asnumpy() == expect.astype(np.float32)) + + +def test_string_add_string(): + input_x = "string111_" + input_y = "add_string222" + result = input_x + input_y + expect = "string111_add_string222" + assert result == expect + + +def test_list_add_list(): + input_x = [1, 3, 5, 7, 9] + input_y = ["0", "6"] + result = input_x + input_y + expect = [1, 3, 5, 7, 9, "0", "6"] + assert result == expect + + +class Sub(nn.Cell): + def __init__(self): + super(Sub, self).__init__() + self.sub = P.Sub() + + def construct(self, x, y): + z = self.sub(x, y) + return z + + +def test_number_sub_number(): + input_x = 10.11 + input_y = 902 + result1 = input_x - input_y + sub_net = Sub() + result2 = sub_net(input_x, input_y) + expect = -891.89 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_sub_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + input_y = Tensor(np.array([[1, 2], [-3, 3]])) + result1 = input_x - input_y + sub_net = Sub() + result2 = sub_net(input_x, input_y) + expect = Tensor(np.array([[1, 0], [6, 0]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_sub_number(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + input_y = -2 + result1 = input_x - input_y + sub_net = Sub() + result2 = sub_net(input_x, input_y) + expect = Tensor(np.array([[4, 4], [5, 5]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_sub_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])) + input_y = -2 + result1 = input_x - input_y + sub_net = Sub() + result2 = sub_net(input_x, input_y) + expect = Tensor(np.array([[-4, -4], [-5, -5]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +class Mul(nn.Cell): + def __init__(self): + super(Mul, self).__init__() + self.mul = P.Mul() + + def construct(self, x, y): + z = self.mul(x, y) + return z + + +def test_number_mul_number(): + input_x = 4.91 + input_y = 0.16 + result1 = input_x * input_y + mul_net = Mul() + result2 = mul_net(input_x, input_y) + expect = 0.7856 + diff1 = result1 - expect + diff2 = result2 - expect + error = 1.0e-6 + assert np.all(diff1 < error) + assert np.all(-diff1 < error) + assert np.all(diff2 < error) + assert np.all(-diff2 < error) + + +def test_tensor_mul_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])).astype(np.float32) + input_y = Tensor(np.array([[1, 2], [3, 1]])).astype(np.float32) + result1 = input_x * input_y + mul_net = Mul() + result2 = mul_net(input_x, input_y) + expect = Tensor(np.array([[2, 4], [9, 3]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_mul_number(): + input_x = Tensor(np.array([[2, 2], [3, 3]])).astype(np.float32) + input_y = -1 + result1 = input_x * input_y + mul_net = Mul() + result2 = mul_net(input_x, input_y) + expect = Tensor(np.array([[-2, -2], [-3, -3]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_mul_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])).astype(np.float32) + input_y = -1 + result1 = input_x * input_y + mul_net = Mul() + result2 = mul_net(input_x, input_y) + expect = Tensor(np.array([[-2, -2], [-3, -3]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +class Div(nn.Cell): + def __init__(self): + super(Div, self).__init__() + self.div = P.Div() + + def construct(self, x, y): + z = self.div(x, y) + return z + + +def test_number_div_number(): + input_x = 4 + input_y = -1 + result1 = input_x / input_y + div_net = Div() + result2 = div_net(input_x, input_y) + expect = -4 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_div_tensor(): + input_x = Tensor(np.array([[2, 2], [3, 3]])).astype(np.float32) + input_y = Tensor(np.array([[1, 2], [3, 1]])).astype(np.float32) + result1 = input_x / input_y + div_net = Div() + result2 = div_net(input_x, input_y) + expect = Tensor(np.array([[2, 1], [1, 3]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_div_number(): + input_x = Tensor(np.array([[2, 2], [3, 3]])).astype(np.float32) + input_y = 2 + result1 = input_x / input_y + div_net = Div() + result2 = div_net(input_x, input_y) + expect = Tensor(np.array([[1, 1], [1.5, 1.5]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_div_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 2 + result1 = input_x / input_y + div_net = Div() + result2 = div_net(input_x, input_y) + expect = Tensor(np.array([[1, 1], [0.5, 0.5]])) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +class Mod(nn.Cell): + def __init__(self): + super(Mod, self).__init__() + self.mod = P.Mod() + + def construct(self, x, y): + z = self.mod(x, y) + return z + + +def test_number_mod_number(): + input_x = 19 + input_y = 2 + result1 = input_x % input_y + mod_net = Mod() + result2 = mod_net(input_x, input_y) + expect = 1 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_mod_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + result1 = input_x % input_y + mod_net = Mod() + result2 = mod_net(input_x, input_y) + expect = Tensor(np.array([[0, 0], [0, 0]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_mod_number(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = -1 + result1 = input_x % input_y + mod_net = Mod() + result2 = mod_net(input_x, input_y) + expect = Tensor(np.array([[0, 0], [0, 0]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_mod_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 5 + result1 = input_x % input_y + mod_net = Mod() + result2 = mod_net(input_x, input_y) + expect = Tensor(np.array([[1, 1], [1, 1]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +class Pow(nn.Cell): + def __init__(self): + super(Pow, self).__init__() + self.pow = P.Pow() + + def construct(self, x, y): + z = self.pow(x, y) + return z + + +def test_number_pow_number(): + input_x = 2 + input_y = 5 + result1 = input_x ** input_y + pow_net = Pow() + result2 = pow_net(input_x, input_y) + expect = 32 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_pow_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + result1 = input_x ** input_y + pow_net = Pow() + result2 = pow_net(input_x, input_y) + expect = Tensor(np.array([[4, 4], [256, 256]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_pow_number(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 3 + result1 = input_x ** input_y + pow_net = Pow() + result2 = pow_net(input_x, input_y) + expect = Tensor(np.array([[8, 8], [64, 64]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_pow_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 3 + result1 = input_x ** input_y + pow_net = Pow() + result2 = pow_net(input_x, input_y) + expect = Tensor(np.array([[9, 9], [81, 81]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +class FloorDiv(nn.Cell): + def __init__(self): + super(FloorDiv, self).__init__() + self.floordiv = P.FloorDiv() + + def construct(self, x, y): + z = self.floordiv(x, y) + return z + + +def test_number_floordiv_number(): + input_x = 2 + input_y = 5 + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = 0 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_floordiv_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = Tensor(np.array([[1, 2], [-2, 4]])).astype(np.float32) + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = Tensor(np.array([[2, 1], [-2, 1]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_floordiv_number(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 3 + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = Tensor(np.array([[0, 0], [1, 1]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_floordiv_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 3 + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = Tensor(np.array([[1, 1], [0, 0]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_floormod_number(): + input_x = 2 + input_y = 5 + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = 2 + assert np.all(result1 == expect) + assert np.all(result2 == expect) + + +def test_tensor_floormod_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = Tensor(np.array([[1, 2], [-2, 4]])).astype(np.float32) + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = Tensor(np.array([[1, 0], [-2, 0]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_tensor_floormod_number(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 3 + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = Tensor(np.array([[2, 2], [1, 1]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy()) + + +def test_number_floormod_tensor(): + input_x = Tensor(np.array([[2, 2], [4, 4]])).astype(np.float32) + input_y = 3 + result1 = input_x // input_y + floordiv_net = FloorDiv() + result2 = floordiv_net(input_x, input_y) + expect = Tensor(np.array([[1, 1], [3, 3]])).astype(np.float32) + assert np.all(result1.asnumpy() == expect.asnumpy()) + assert np.all(result2.asnumpy() == expect.asnumpy())