1 /***************************************************************************
2 * Copyright (c) Johan Mabille, Sylvain Corlay and Wolf Vollprecht          *
3 * Copyright (c) QuantStack                                                 *
4 *                                                                          *
5 * Distributed under the terms of the BSD 3-Clause License.                 *
6 *                                                                          *
7 * The full license is in the file LICENSE, distributed with this software. *
8 ****************************************************************************/
9 
10 #include "gtest/gtest.h"
11 #include "zarray/zarray.hpp"
12 #include "xtensor-io/xchunk_store_manager.hpp"
13 #include "xtensor-io/xio_binary.hpp"
14 #include "xtensor-io/xio_disk_handler.hpp"
15 #include "xtensor/xview.hpp"
16 #include "test_init.hpp"
17 
18 namespace xt
19 {
20     namespace fs = ghc::filesystem;
21 
TEST(zview,strided_view)22     TEST(zview, strided_view)
23     {
24         initialize_dispatchers();
25 
26         xarray<double> a = {{1., 2.}, {3., 4.}};
27         xstrided_slice_vector sv1({xt::all(), 1});
28         xstrided_slice_vector sv2({1});
29         xarray<double> expected1 = xt::strided_view(a, sv1);
30         xarray<double> expected2 = xt::strided_view(expected1, sv2);
31 
32         zarray za(a);
33 
34         zarray zres1 = strided_view(za, sv1);
35         zarray zres2 = strided_view(zres1, sv2);
36 
37         EXPECT_EQ(zres1.get_array<double>(), expected1);
38         EXPECT_EQ(zres2.get_array<double>(), expected2);
39     }
40 
TEST(zview,chunked_strided_view)41     TEST(zview, chunked_strided_view)
42     {
43         initialize_dispatchers();
44 
45         std::vector<size_t> shape = {4, 4};
46         std::vector<size_t> chunk_shape = {2, 2};
47         std::string chunk_dir = "chunk_dir";
48         fs::create_directory(chunk_dir);
49         double init_value = 123.456;
50         auto ca = chunked_file_array<double, xio_disk_handler<xio_binary_config>>(shape, chunk_shape, chunk_dir, init_value);
51         xarray<double> a = {{1., 2.}, {3., 4.}};
52         view(ca, range(0, 2), range(0, 2)) = a;
53         xt::xstrided_slice_vector sv({xt::all(), 1});
54         xarray<double> expected = {2, 4, init_value, init_value};
55 
56         zarray za(ca);
57 
58         zarray zres = strided_view(za, sv);
59 
60         EXPECT_EQ(zres.get_array<double>(), expected);
61     }
62 
TEST(zview,assign_strided_view)63     TEST(zview, assign_strided_view)
64     {
65         xarray<double> a = {{1., 2.}, {3., 4.}};
66         xstrided_slice_vector sv({all(), 1});
67         xarray<double> b = {{1., 5.}, {3., 6.}};
68         xarray<double> expected = {{1., 5.}, {3., 6.}};
69 
70         zarray za(a), zb(b);
71         strided_view(za, sv) = strided_view(zb, sv);
72         EXPECT_EQ(za.get_array<double>(), expected);
73 
74         xarray<double> expected2 = {{2., 5.}, {6., 6.}};
75         xstrided_slice_vector sv2({all(), 0});
76         strided_view(za, sv2) = strided_view(zb, sv2) + strided_view(zb, sv2);
77         EXPECT_EQ(za.get_array<double>(), expected2);
78 
79         xarray<double> c = {7., 8.};
80         xarray<double> expected3 = {{7., 8.}, {6., 6.}};
81         xstrided_slice_vector sv3({0, all()});
82         strided_view(za, sv3) = c;
83         EXPECT_EQ(za.get_array<double>(), expected3);
84     }
85 
TEST(zview,assign_chunked_strided_view)86     TEST(zview, assign_chunked_strided_view)
87     {
88         std::vector<size_t> shape = {4, 4};
89         std::vector<size_t> chunk_shape = {2, 2};
90         std::string chunk_dir = "chunk_dir2";
91         fs::create_directory(chunk_dir);
92         double init_value = 123.456;
93         auto ca = chunked_file_array<double, xio_disk_handler<xio_binary_config>>(shape, chunk_shape, chunk_dir, init_value);
94 
95         xarray<double> a = {{1., 2.}, {3., 4.}};
96         xstrided_slice_vector sv({range(2, 4), range(2, 4)});
97         xarray<double> expected = ones<double>({4, 4}) * init_value;
98         strided_view(expected, sv) = a;
99 
100         zarray za(ca);
101         strided_view(za, sv) = a;
102 
103         EXPECT_EQ(za.get_array<double>(), expected);
104     }
105 }
106