Line data    Source code

       1             : /******************************************************************************
       2             :  * Project:  GDAL Vector abstraction
       3             :  * Purpose:  Tests for the VectorX class
       4             :  * Author:   Javier Jimenez Shaw
       5             :  *
       6             :  ******************************************************************************
       7             :  * Copyright (c) 2024, Javier Jimenez Shaw
       8             :  *
       9             :  * SPDX-License-Identifier: MIT
      10             :  ****************************************************************************/
      11             : 
      12             : #include "gdal_unit_test.h"
      13             : 
      14             : #include "gdal_vectorx.h"
      15             : 
      16             : #include <array>
      17             : #include <cmath>
      18             : #include <complex>
      19             : #include <limits>
      20             : #include <type_traits>
      21             : 
      22             : #include "gtest_include.h"
      23             : 
      24             : namespace
      25             : {
      26             : 
      27             : // Common fixture with test data
      28             : struct test_vectorx : public ::testing::Test
      29             : {
      30             : };
      31             : 
      32             : // Dummy test
      33           4 : TEST_F(test_vectorx, simple_int)
      34             : {
      35           1 :     gdal::Vector2i a;
      36           1 :     EXPECT_EQ(0, a.x());
      37           1 :     EXPECT_EQ(0, a.y());
      38             :     static_assert(std::is_same_v<decltype(a)::value_type, int> == true);
      39             : 
      40           1 :     gdal::Vector2i p2(2, 3);
      41           1 :     EXPECT_EQ(2, p2.x());
      42           1 :     EXPECT_EQ(3, p2.y());
      43             : 
      44           1 :     gdal::Vector3i p3(12, 13, 14);
      45           1 :     EXPECT_EQ(12, p3.x());
      46           1 :     EXPECT_EQ(13, p3.y());
      47           1 :     EXPECT_EQ(14, p3.z());
      48             : 
      49           1 :     gdal::VectorX<int, 1> p1{2};
      50           1 :     EXPECT_EQ(2, p1.x());
      51             : 
      52           1 :     gdal::VectorX<int, 4> p4(12, 13, -14, 150);
      53           1 :     EXPECT_EQ(12, p4.x());
      54           1 :     EXPECT_EQ(13, p4.y());
      55           1 :     EXPECT_EQ(-14, p4.z());
      56           1 :     EXPECT_EQ(150, p4[3]);
      57           1 : }
      58             : 
      59           4 : TEST_F(test_vectorx, simple_double)
      60             : {
      61           1 :     gdal::Vector2d a;
      62           1 :     EXPECT_EQ(0.0, a.x());
      63           1 :     EXPECT_EQ(0.0, a.y());
      64           1 :     EXPECT_EQ(2, a.size());
      65             :     static_assert(std::is_same_v<decltype(a)::value_type, double> == true);
      66             : 
      67           1 :     gdal::Vector2d p2(2.1, 3.6);
      68           1 :     EXPECT_EQ(2.1, p2.x());
      69           1 :     EXPECT_EQ(3.6, p2.y());
      70           1 :     EXPECT_EQ(2, p2.size());
      71             : 
      72           1 :     gdal::Vector3d p3(12e-2, -13.0, 14e3);
      73           1 :     EXPECT_EQ(12e-2, p3.x());
      74           1 :     EXPECT_EQ(-13.0, p3.y());
      75           1 :     EXPECT_EQ(14e3, p3.z());
      76           1 :     EXPECT_EQ(3, p3.size());
      77             : 
      78           1 :     gdal::VectorX<double, 1> p1{2.1};
      79           1 :     EXPECT_EQ(2.1, p1.x());
      80           1 :     EXPECT_EQ(1, p1.size());
      81             : 
      82           1 :     gdal::VectorX<double, 4> p4(12.0, 13.1, -14.2, 150.0);
      83           1 :     EXPECT_EQ(12.0, p4.x());
      84           1 :     EXPECT_EQ(13.1, p4.y());
      85           1 :     EXPECT_EQ(-14.2, p4.z());
      86           1 :     EXPECT_EQ(150.0, p4[3]);
      87           1 :     EXPECT_EQ(4, p4.size());
      88           1 : }
      89             : 
      90           4 : TEST_F(test_vectorx, simple_float)
      91             : {
      92           1 :     gdal::VectorX<float, 1> p1{2.1f};
      93           1 :     EXPECT_EQ(2.1f, p1.x());
      94             :     static_assert(std::is_same_v<decltype(p1)::value_type, float> == true);
      95             : 
      96           1 :     gdal::VectorX<float, 4> p4(12.0f, 13.1f, -14.2f, 150.0f);
      97           1 :     EXPECT_EQ(12.0f, p4.x());
      98           1 :     EXPECT_EQ(13.1f, p4.y());
      99           1 :     EXPECT_EQ(-14.2f, p4.z());
     100           1 :     EXPECT_EQ(150.0f, p4[3]);
     101           1 : }
     102             : 
     103           4 : TEST_F(test_vectorx, simple_complex)
     104             : {
     105             :     using namespace std::complex_literals;
     106           1 :     gdal::VectorX<std::complex<double>, 2> p2{2.1 + 3.0i, -9.0 + -7.0i};
     107           1 :     EXPECT_EQ(2.1 + 3.0i, p2.x());
     108           1 :     EXPECT_EQ(-9.0 + -7.0i, p2.y());
     109             :     static_assert(
     110             :         std::is_same_v<decltype(p2)::value_type, std::complex<double>> == true);
     111           1 : }
     112             : 
     113           4 : TEST_F(test_vectorx, array)
     114             : {
     115           1 :     gdal::Vector2d p2(2.1, 3.6);
     116           1 :     const std::array<double, 2> arr = p2.array();
     117           1 :     EXPECT_EQ(2.1, arr[0]);
     118           1 :     EXPECT_EQ(3.6, arr[1]);
     119           1 : }
     120             : 
     121           4 : TEST_F(test_vectorx, fill)
     122             : {
     123           1 :     const gdal::Vector3d a = gdal::Vector3d().fill(42.0);
     124           1 :     EXPECT_EQ(3, a.size());
     125           1 :     EXPECT_EQ(42.0, a[0]);
     126           1 :     EXPECT_EQ(42.0, a[1]);
     127           1 :     EXPECT_EQ(42.0, a[2]);
     128           1 : }
     129             : 
     130           4 : TEST_F(test_vectorx, fill_nan)
     131             : {
     132             :     const gdal::Vector3d a =
     133           1 :         gdal::Vector3d().fill(std::numeric_limits<double>::quiet_NaN());
     134           1 :     EXPECT_EQ(3, a.size());
     135           1 :     EXPECT_TRUE(std::isnan(a[0]));
     136           1 :     EXPECT_TRUE(std::isnan(a[1]));
     137           1 :     EXPECT_TRUE(std::isnan(a[2]));
     138           1 : }
     139             : 
     140           4 : TEST_F(test_vectorx, change)
     141             : {
     142           1 :     gdal::Vector2d p2(2.1, 3.6);
     143           1 :     p2[0] = 7;
     144           1 :     EXPECT_EQ(7, p2.x());
     145           1 :     p2[1] = 10.5;
     146           1 :     EXPECT_EQ(10.5, p2.y());
     147             : 
     148           1 :     gdal::Vector3d p3(12.1, 13.6, -9.0);
     149           1 :     p3.x() = 79;
     150           1 :     EXPECT_EQ(79, p3[0]);
     151           1 :     p3.y() = 10.4;
     152           1 :     EXPECT_EQ(10.4, p3[1]);
     153           1 :     p3.z() = 1.5;
     154           1 :     EXPECT_EQ(1.5, p3[2]);
     155           1 : }
     156             : 
     157           4 : TEST_F(test_vectorx, scalar_prod)
     158             : {
     159           1 :     gdal::Vector2d a(2.1, 3.6);
     160           1 :     gdal::Vector2d b(-2.0, 10.0);
     161           1 :     EXPECT_NEAR(2.1 * -2.0 + 3.6 * 10.0, a.scalarProd(b), 1e-10);
     162           1 : }
     163             : 
     164           4 : TEST_F(test_vectorx, norm2)
     165             : {
     166           1 :     gdal::Vector2d a(2.1, 3.6);
     167           1 :     EXPECT_NEAR(2.1 * 2.1 + 3.6 * 3.6, a.norm2(), 1e-10);
     168           1 : }
     169             : 
     170           4 : TEST_F(test_vectorx, cast)
     171             : {
     172           1 :     gdal::Vector2d a(2.1, -3.6);
     173           1 :     auto b = a.cast<int>();
     174             :     static_assert(std::is_same_v<decltype(b)::value_type, int> == true);
     175           1 :     EXPECT_EQ(2, b.x());
     176           1 :     EXPECT_EQ(-3, b.y());
     177             : 
     178           1 :     gdal::Vector2d c = b.cast<double>();
     179             :     static_assert(std::is_same_v<decltype(c)::value_type, double> == true);
     180           1 :     EXPECT_EQ(2.0, c.x());
     181           1 :     EXPECT_EQ(-3.0, c.y());
     182           1 : }
     183             : 
     184           4 : TEST_F(test_vectorx, floor)
     185             : {
     186           1 :     const gdal::Vector2d a(2.1, -3.6);
     187           1 :     const gdal::Vector2d d = a.floor();
     188           1 :     EXPECT_EQ(2.0, d.x());
     189           1 :     EXPECT_EQ(-4.0, d.y());
     190             : 
     191             :     // just to show how to use the template keyword.
     192           1 :     const gdal::Vector2i i = a.floor().template cast<int>();
     193           1 :     EXPECT_EQ(2, i.x());
     194           1 :     EXPECT_EQ(-4, i.y());
     195           1 : }
     196             : 
     197           4 : TEST_F(test_vectorx, ceil)
     198             : {
     199           1 :     const gdal::Vector2d a(2.1, -3.6);
     200           1 :     const gdal::Vector2d d = a.ceil();
     201           1 :     EXPECT_EQ(3.0, d.x());
     202           1 :     EXPECT_EQ(-3.0, d.y());
     203           1 : }
     204             : 
     205           4 : TEST_F(test_vectorx, apply)
     206             : {
     207           1 :     const gdal::Vector2d a(2.1, -3.6);
     208             :     const gdal::Vector2d d =
     209           3 :         a.apply([](const gdal::Vector2d::value_type v) { return v + 1.0; });
     210           1 :     EXPECT_NEAR(3.1, d.x(), 1e-10);
     211           1 :     EXPECT_NEAR(-2.6, d.y(), 1e-10);
     212           1 : }
     213             : 
     214           4 : TEST_F(test_vectorx, sum)
     215             : {
     216           1 :     const gdal::Vector2d a(2.1, -3.6);
     217           1 :     const gdal::Vector2d b = a + 2.2;
     218           1 :     EXPECT_NEAR(4.3, b.x(), 1e-10);
     219           1 :     EXPECT_NEAR(-1.4, b.y(), 1e-10);
     220           1 : }
     221             : 
     222           4 : TEST_F(test_vectorx, sum_eq)
     223             : {
     224           1 :     gdal::Vector2d a(2.1, -3.6);
     225           1 :     a += 2.0;
     226           1 :     EXPECT_NEAR(4.1, a.x(), 1e-10);
     227           1 :     EXPECT_NEAR(-1.6, a.y(), 1e-10);
     228           1 : }
     229             : 
     230           4 : TEST_F(test_vectorx, sum_eq_int)
     231             : {
     232           1 :     gdal::Vector2i a(2, -3);
     233           1 :     a += 1;
     234           1 :     EXPECT_EQ(3, a.x());
     235           1 :     EXPECT_EQ(-2, a.y());
     236           1 : }
     237             : 
     238           4 : TEST_F(test_vectorx, minus)
     239             : {
     240           1 :     const gdal::Vector2d a(2.1, -3.6);
     241           1 :     const gdal::Vector2d b = a - 2.2;
     242           1 :     EXPECT_NEAR(-0.1, b.x(), 1e-10);
     243           1 :     EXPECT_NEAR(-5.8, b.y(), 1e-10);
     244           1 : }
     245             : 
     246           4 : TEST_F(test_vectorx, minus_eq)
     247             : {
     248           1 :     gdal::Vector2d a(2.1, -3.6);
     249           1 :     a -= 2.0;
     250           1 :     EXPECT_NEAR(0.1, a.x(), 1e-10);
     251           1 :     EXPECT_NEAR(-5.6, a.y(), 1e-10);
     252           1 : }
     253             : 
     254           4 : TEST_F(test_vectorx, minus_eq_int)
     255             : {
     256           1 :     gdal::Vector2i a(2, -3);
     257           1 :     a -= 1;
     258           1 :     EXPECT_EQ(1, a.x());
     259           1 :     EXPECT_EQ(-4, a.y());
     260           1 : }
     261             : 
     262           4 : TEST_F(test_vectorx, minus_op)
     263             : {
     264           1 :     gdal::Vector2d a(2.1, -3.6);
     265           1 :     const auto b = -a;
     266           1 :     EXPECT_NEAR(-2.1, b.x(), 1e-10);
     267           1 :     EXPECT_NEAR(3.6, b.y(), 1e-10);
     268           1 : }
     269             : 
     270           4 : TEST_F(test_vectorx, multiply_int_double)
     271             : {
     272           1 :     gdal::Vector2i a(2, -3);
     273           1 :     const auto b = a * 2.6;
     274             :     static_assert(std::is_same_v<decltype(b)::value_type, int> == true);
     275           1 :     EXPECT_EQ(5, b.x());
     276           1 :     EXPECT_EQ(-7, b.y());
     277           1 : }
     278             : 
     279           4 : TEST_F(test_vectorx, multiply_double)
     280             : {
     281           1 :     gdal::Vector2d a(2.1, -3.2);
     282           1 :     const auto b = a * 2.6;
     283           1 :     EXPECT_NEAR(5.46, b.x(), 1e-10);
     284           1 :     EXPECT_NEAR(-8.32, b.y(), 1e-10);
     285           1 : }
     286             : 
     287           4 : TEST_F(test_vectorx, divide_int_double)
     288             : {
     289           1 :     gdal::Vector2i a(4, -3);
     290           1 :     const auto b = a / 2.2;
     291             :     static_assert(std::is_same_v<decltype(b)::value_type, int> == true);
     292           1 :     EXPECT_EQ(1, b.x());
     293           1 :     EXPECT_EQ(-1, b.y());
     294           1 : }
     295             : 
     296           4 : TEST_F(test_vectorx, divide_double)
     297             : {
     298           1 :     gdal::Vector2d a(2.1, -3.2);
     299           1 :     const auto b = a / 2.5;
     300           1 :     EXPECT_NEAR(0.84, b.x(), 1e-10);
     301           1 :     EXPECT_NEAR(-1.28, b.y(), 1e-10);
     302           1 : }
     303             : 
     304           4 : TEST_F(test_vectorx, plus_vectorx)
     305             : {
     306           1 :     const gdal::Vector2d a(2.1, -3.6);
     307           1 :     const gdal::Vector2d b(10.0, 1.1);
     308           1 :     const auto c = a + b;
     309           1 :     EXPECT_NEAR(12.1, c.x(), 1e-10);
     310           1 :     EXPECT_NEAR(-2.5, c.y(), 1e-10);
     311           1 : }
     312             : 
     313           4 : TEST_F(test_vectorx, minus_vectorx)
     314             : {
     315           1 :     const gdal::Vector2d a(2.1, -3.6);
     316           1 :     const gdal::Vector2d b(10.0, 1.1);
     317           1 :     const auto c = a - b;
     318           1 :     EXPECT_NEAR(-7.9, c.x(), 1e-10);
     319           1 :     EXPECT_NEAR(-4.7, c.y(), 1e-10);
     320           1 : }
     321             : 
     322           4 : TEST_F(test_vectorx, plus_scalar_vectorx)
     323             : {
     324           1 :     const gdal::Vector2d a(2.1, -3.6);
     325           1 :     const auto b = 2.5 + a;
     326           1 :     EXPECT_NEAR(4.6, b.x(), 1e-10);
     327           1 :     EXPECT_NEAR(-1.1, b.y(), 1e-10);
     328           1 : }
     329             : 
     330           4 : TEST_F(test_vectorx, minus_scalar_vectorx)
     331             : {
     332           1 :     const gdal::Vector2d a(2.1, -3.6);
     333           1 :     const auto b = 2.5 - a;
     334           1 :     EXPECT_NEAR(0.4, b.x(), 1e-10);
     335           1 :     EXPECT_NEAR(6.1, b.y(), 1e-10);
     336           1 : }
     337             : 
     338             : }  // namespace