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