Move test related to Tensor cpu.

aidge_backend_cpu/unit_tests/test_tensor.py

-import unittest
-import aidge_core
-import aidge_backend_cpu
-import numpy as np
-
-
-class test_tensor(unittest.TestCase):
-    """Test tensor binding
-    """
-    def setUp(self):
-        pass
-    def tearDown(self):
-        pass
-
-    def test_getavailable_backends(self):
-        self.assertTrue("cpu" in aidge_core.Tensor.get_available_backends())
-
-    def test_numpy_int_to_tensor(self):
-        np_array = np.arange(9).reshape(1,1,3,3).astype(np.int32)
-        # Numpy -> Tensor
-        t = aidge_core.Tensor(np_array)
-        self.assertEqual(t.dtype(), aidge_core.DataType.Int32)
-        for i_t, i_n in zip(t, np_array.flatten()):
-            self.assertTrue(i_t == i_n)
-        for i,j in zip(t.dims(), np_array.shape):
-            self.assertEqual(i,j)
-    def test_tensor_int_to_numpy(self):
-        np_array = np.arange(9).reshape(1,1,3,3)
-        # Numpy -> Tensor
-        t = aidge_core.Tensor(np_array)
-        # Tensor -> Numpy
-        nnarray = np.array(t)
-        for i_nn, i_n in zip(nnarray.flatten(), np_array.flatten()):
-            self.assertTrue(i_nn == i_n)
-        for i,j in zip(t.dims(), nnarray.shape):
-            self.assertEqual(i,j)
-
-    def test_numpy_int64_to_tensor(self):
-        np_array = np.arange(9).reshape(1,1,3,3).astype(np.int64)
-        # Numpy -> Tensor
-        t = aidge_core.Tensor(np_array)
-        self.assertEqual(t.dtype(), aidge_core.DataType.Int64)
-        for i_t, i_n in zip(t, np_array.flatten()):
-            self.assertTrue(i_t == i_n)
-        for i,j in zip(t.dims(), np_array.shape):
-            self.assertEqual(i,j)
-
-    def test_numpy_float_to_tensor(self):
-        t = aidge_core.Tensor()
-        np_array = np.random.rand(1, 1, 3, 3).astype(np.float32)
-        # Numpy -> Tensor
-        t = aidge_core.Tensor(np_array)
-        self.assertEqual(t.dtype(), aidge_core.DataType.Float32)
-        for i_t, i_n in zip(t, np_array.flatten()):
-            self.assertTrue(i_t == i_n) # TODO : May need to change this to a difference
-        for i,j in zip(t.dims(), np_array.shape):
-            self.assertEqual(i,j)
-
-    def test_get_set(self):
-        dims = [2,2,2]
-
-        np_array = np.arange(8).reshape(dims).astype(np.int32)
-        # Numpy -> Tensor
-        t = aidge_core.Tensor(np_array)
-        for i in range(8):
-            self.assertEqual(t[i], i)
-            t[i] = 5
-            self.assertEqual(t[i], 5)
-
-if __name__ == '__main__':
-    unittest.main()

unit_tests/data/Test_TensorImpl.cpp

-/********************************************************************************
- * Copyright (c) 2023 CEA-List
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * SPDX-License-Identifier: EPL-2.0
- *
- ********************************************************************************/
-
-#include <array>
-
-#include <catch2/catch_test_macros.hpp>
-
-#include "aidge/data/Tensor.hpp"
-#include "aidge/utils/TensorUtils.hpp"
-#include "aidge/backend/cpu/data/TensorImpl.hpp"
-
-using namespace Aidge;
-
-TEST_CASE("Tensor creation") {
-  SECTION("from const array") {
-    Tensor x = Array3D<int, 2, 2, 2>{{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}};
-
-    Tensor xCopy = Array3D<int, 2, 2, 2>{{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}};
-
-    Tensor xFloat =
-        Array3D<float, 2, 2, 2>{{{{1., 2.}, {3., 4.}}, {{5., 6.}, {7., 8.}}}};
-
-    SECTION("Tensor features") {
-      REQUIRE(x.nbDims() == 3);
-      REQUIRE(x.dims()[0] == 2);
-      REQUIRE(x.dims()[1] == 2);
-      REQUIRE(x.dims()[2] == 2);
-      REQUIRE(x.size() == 8);
-    }
-
-    SECTION("Access to array") {
-      REQUIRE(static_cast<int *>(x.getImpl()->rawPtr())[0] == 1);
-      REQUIRE(static_cast<int *>(x.getImpl()->rawPtr())[7] == 8);
-    }
-
-    SECTION("get function") {
-      REQUIRE(x.get<int>({0, 0, 0}) == 1);
-      REQUIRE(x.get<int>({0, 0, 1}) == 2);
-      REQUIRE(x.get<int>({0, 1, 1}) == 4);
-      REQUIRE(x.get<int>({1, 1, 0}) == 7);
-      x.set<int>({1, 1, 1}, 36);
-      REQUIRE(x.get<int>({1, 1, 1}) == 36);
-    }
-
-    SECTION("Pretty printing for debug") { REQUIRE_NOTHROW(x.print()); }
-
-    SECTION("Tensor (in)equality") {
-      REQUIRE(x == xCopy);
-      REQUIRE_FALSE(x == xFloat);
-    }
-  }
-}
-TEST_CASE("Tensor fill") {
-  SECTION("Instantiate batches independantly") {
-    // initialization with 0s
-    std::shared_ptr<Tensor> concatenatedTensor= std::make_shared<Tensor>(Array2D<int, 3, 5>{});
-    //concatenatedTensor->print();
-
-    std::shared_ptr<Tensor> myTensor1 = std::make_shared<Tensor>(Array1D<int, 5>{{1,2,3,4,5}});
-    std::shared_ptr<Tensor> myTensor2 = std::make_shared<Tensor>(Array1D<int, 5>{{6,7,8,9,10}});
-    std::shared_ptr<Tensor> myTensor3 = std::make_shared<Tensor>(Array1D<int, 5>{{11,12,13,14,15}});
-
-    // use copy function from implementation
-    concatenatedTensor->getImpl()->copy(myTensor1->getImpl()->rawPtr(), 5, 0);
-    concatenatedTensor->getImpl()->copy(myTensor2->getImpl()->rawPtr(), 5, 5);
-    concatenatedTensor->getImpl()->copy(myTensor3->getImpl()->rawPtr(), 5, 10);
-    // concatenatedTensor->print();
-
-    std::shared_ptr<Tensor> expectedTensor= std::make_shared<Tensor>(Array2D<int, 3, 5>{
-      {{1,2,3,4,5},
-      {6,7,8,9,10},
-      {11,12,13,14,15}}
-    });
-    // expectedTensor->print();
-    
-    REQUIRE(*concatenatedTensor == *expectedTensor);
-  }
-}
-
-
-TEST_CASE("Tensor methods") {
-  Tensor x = Array3D<int, 2, 2, 2>{{
-    {{1, 2},
-     {3, 4}},
-    {{5, 6},
-     {7, 8}}
-  }};
-
-  Tensor xCopy = Array3D<int, 2, 2, 2>{{{{1, 2}, {3, 4}}, {{5, 6}, {7, 8}}}};
-
-  Tensor xFloat =
-      Array3D<float, 2, 2, 2>{{{{1., 2.}, {3., 4.}}, {{5., 6.}, {7., 8.}}}};
-
-  SECTION("Tensor sharing") {
-    Tensor xCopyCtor(x);
-    REQUIRE(xCopyCtor.getImpl() == x.getImpl());
-
-    Tensor xEqOp = x;
-    REQUIRE(xEqOp.getImpl() == x.getImpl());
-
-    Tensor xCloned = x.clone();
-    REQUIRE(xCloned.getImpl() != x.getImpl());
-    REQUIRE(xCloned == x);
-  }
-
-  SECTION("Tensor extract") {
-    Tensor y = x.extract({0, 1});
-    REQUIRE(y.getImpl() == x.getImpl());
-    REQUIRE(approxEq<int>(y, Array1D<int, 2>{{3, 4}}));
-    REQUIRE(y.isContiguous());
-    
-    Tensor y2 = x.extract({0, 1, 1}, {2, 1, 1});
-    REQUIRE(y2.getImpl() == x.getImpl());
-    REQUIRE(!y2.isContiguous());
-    Tensor y3 = y2.clone();
-    REQUIRE(y3.isContiguous());
-    REQUIRE(approxEq<int>(y3, Array3D<int, 2, 1, 1>{{{{4}}, {{8}}}}));
-  }
-}