search

sonible / VCTR

A powerful C++ 20 wrapper around your favorite standard library containers
https://sonible.github.io/VCTR/
Other
25 stars 1 forks source link

Update to recent version breaks division operator (Ubuntu, gcc) #121

Closed TheWaveWarden closed 12 months ago

TheWaveWarden commented 1 year ago

Updating to develop tip seems to make division operator not play nicely anymore. Consider the following code:

vctr::Array<float, 2> foo{1.0f, 2.0f};
foo /= 2.0f;

for (auto& val : foo)
    DBG (val);

The output is

inf
inf

Ubuntu 20.04 gcc 11.4.0

Happy to provide more details if needed :slightly_smiling_face:

JanosGit commented 1 year ago

Could you verify if the corresponding unit test also fails with your setup?

TheWaveWarden commented 1 year ago

@JanosGit yes it fails... among other tests :grimacing:

For around half my runs, the test will abort with SIGABRT: Screenshot from 2023-10-17 16-17-30

For the other runs, there are a lot more failing tests. Here is a full log:

✘ fred@frotron3  ~/spline/VCTR/build/test/TestMain   develop  ./vctr_test
Randomness seeded to: 4121597294

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
vctr_test is a Catch2 v3.4.0 host application.
Run with -? for options

-------------------------------------------------------------------------------
Addition - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:38: FAILED:
  REQUIRE_THAT( sum1, vctr::EqualsTransformedBy<addition> (srcA, c) )
with expansion:
  vctr::Vector<float> with size 10 and content [ -38.222, -12.0987, -14.5897, -
  57.2018, 1.12489e+23, 5.20638, -1.30107e+37, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = addition<float>; std::string_view = std::
  basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.2879, 5.
  20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.4394, -50.
  3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -14.6781,
  30.7891 ]

-------------------------------------------------------------------------------
Addition - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:38: FAILED:
  REQUIRE_THAT( sum1, vctr::EqualsTransformedBy<addition> (srcA, c) )
with expansion:
  vctr::Vector<double> with size 10 and content [ -38.222, -12.0987, -14.5897,
  -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = addition<double>; std::string_view =
  std::basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.
  2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.
  4394, -50.3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -
  14.6781, 30.7892 ]

-------------------------------------------------------------------------------
Addition - AVX<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:38: FAILED:
  REQUIRE_THAT( sum1, vctr::EqualsTransformedBy<addition> (srcA, c) )
with expansion:
  vctr::Vector<int32_t> with size 10 and content [ -39, -13, -15, -58,
  1706987594, 32538, -48356627, 21823, 23, 69 ] Equals: consteval std::
  string_view vctr::detail::functionNameWrappedInFunctionTemplateName() [with R
  = int; ArgA = int; ArgB = int; R (* t)(ArgA, ArgB) = addition<int>; std::
  string_view = std::basic_string_view<char> ([ -39, -13, -15, -58, 10, 5, -83,
  -74, 23, 69 ], -39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16, 30 ]

-------------------------------------------------------------------------------
Addition - AVX<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:38: FAILED:
  REQUIRE_THAT( sum1, vctr::EqualsTransformedBy<addition> (srcA, c) )
with expansion:
  vctr::Vector<uint32_t> with size 10 and content [ 4294967257, 4294967283,
  4294967281, 4294967238, 1706987594, 32538, 4246611629, 21823, 23, 69 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = addition<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967283, 4294967281, 4294967238, 10, 5, 4294967213, 4294967222, 23, 69 ],
  4294967257) = [ 4294967218, 4294967244, 4294967242, 4294967199, 4294967267,
  4294967262, 4294967174, 4294967183, 4294967280, 30 ]

-------------------------------------------------------------------------------
Addition - AVX<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:38: FAILED:
  REQUIRE_THAT( sum1, vctr::EqualsTransformedBy<addition> (srcA, c) )
with expansion:
  vctr::Vector<int64_t> with size 10 and content [ -39, -13, 139729878028337,
  94051145495110, 10, 5, 139729878028269, 94051145495094, 23, 69 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long int; ArgA = long
  int; ArgB = long int; R (* t)(ArgA, ArgB) = addition<long int>; std::
  string_view = std::basic_string_view<char> ([ -39, -13, -15, -58, 10, 5, -83,
  -74, 23, 69 ], -39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16, 30 ]

-------------------------------------------------------------------------------
Addition - AVX<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:38: FAILED:
  REQUIRE_THAT( sum1, vctr::EqualsTransformedBy<addition> (srcA, c) )
with expansion:
  vctr::Vector<uint64_t> with size 10 and content [ 18446744073709551577,
  18446744073709551603, 139729878028337, 94051145497798, 10, 5,
  139729878028269, 94051145497782, 23, 69 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long
  unsigned int; ArgA = long unsigned int; ArgB = long unsigned int; R (* t)
  (ArgA, ArgB) = addition<long unsigned int>; std::string_view = std::
  basic_string_view<char> ([ 18446744073709551577, 18446744073709551603,
  18446744073709551601, 18446744073709551558, 10, 5, 18446744073709551533,
  18446744073709551542, 23, 69 ], 18446744073709551577) = [
  18446744073709551538, 18446744073709551564, 18446744073709551562,
  18446744073709551519, 18446744073709551587, 18446744073709551582,
  18446744073709551494, 18446744073709551503, 18446744073709551600, 30 ]

-------------------------------------------------------------------------------
Addition in place - PlatformVectorOps<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -38.222, -12.0987, -1.
  30781e+37, -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = addition<float>; std::string_view = std::
  basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.2879, 5.
  20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.4394, -50.
  3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -14.6781,
  30.7891 ]

-------------------------------------------------------------------------------
Addition in place - PlatformVectorOps<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -38.222, -12.0987, -14.
  5897, -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = addition<double>; std::string_view =
  std::basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.
  2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.
  4394, -50.3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -
  14.6781, 30.7892 ]

-------------------------------------------------------------------------------
Addition in place - PlatformVectorOps<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int32_t, 10> with size 10 and content [ 895856169, 32754, -
  65656432, 21839, 895856730, 32772, -83, -74, 895856231, 32836 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = int; ArgA = int; ArgB =
  int; R (* t)(ArgA, ArgB) = addition<int>; std::string_view = std::
  basic_string_view<char> ([ -39, -13, -15, -58, 10, 5, -83, -74, 23, 69 ], -
  39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16, 30 ]

-------------------------------------------------------------------------------
Addition in place - PlatformVectorOps<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint32_t, 10> with size 10 and content [ 895856169, 32754,
  4230052742, 21839, 18, 5, 895856509, 32693, 895856231, 32836 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = addition<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967283, 4294967281, 4294967238, 10, 5, 4294967213, 4294967222, 23, 69 ],
  4294967257) = [ 4294967218, 4294967244, 4294967242, 4294967199, 4294967267,
  4294967262, 4294967174, 4294967183, 4294967280, 30 ]

-------------------------------------------------------------------------------
Addition in place - PlatformVectorOps<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int64_t, 10> with size 10 and content [ -39, 140734089244611,
  140734089244145, 94051127591990, 10, 140734089244629, 140734089244077,
  94051127591974, 23, 140734089244693 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long int;
  ArgA = long int; ArgB = long int; R (* t)(ArgA, ArgB) = addition<long int>;
  std::string_view = std::basic_string_view<char> ([ -39, -13, -15, -58, 10, 5,
  -83, -74, 23, 69 ], -39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16,
  30 ]

-------------------------------------------------------------------------------
Addition in place - PlatformVectorOps<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint64_t, 10> with size 10 and content [ 18446744073709551577,
  140734089244611, 18446744073709551609, 140734089244438, 10, 140734089244629,
  18446744073709551541, 140734089244422, 23, 140734089244693 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long unsigned int; ArgA
  = long unsigned int; ArgB = long unsigned int; R (* t)(ArgA, ArgB) = addition
  <long unsigned int>; std::string_view = std::basic_string_view<char> ([
  18446744073709551577, 18446744073709551603, 18446744073709551601,
  18446744073709551558, 10, 5, 18446744073709551533, 18446744073709551542, 23,
  69 ], 18446744073709551577) = [ 18446744073709551538, 18446744073709551564,
  18446744073709551562, 18446744073709551519, 18446744073709551587,
  18446744073709551582, 18446744073709551494, 18446744073709551503,
  18446744073709551600, 30 ]

-------------------------------------------------------------------------------
Addition in place - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -38.222, -12.0987, -1.
  30771e+37, -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = addition<float>; std::string_view = std::
  basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.2879, 5.
  20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.4394, -50.
  3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -14.6781,
  30.7891 ]

-------------------------------------------------------------------------------
Addition in place - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -38.222, -12.0987, -14.
  5897, -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = addition<double>; std::string_view =
  std::basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.
  2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.
  4394, -50.3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -
  14.6781, 30.7892 ]

-------------------------------------------------------------------------------
Addition in place - AVX<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int32_t, 10> with size 10 and content [ 895856169, 32754, -
  65656432, 21839, 895856730, 32772, -83, -74, 895856231, 32836 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = int; ArgA = int; ArgB =
  int; R (* t)(ArgA, ArgB) = addition<int>; std::string_view = std::
  basic_string_view<char> ([ -39, -13, -15, -58, 10, 5, -83, -74, 23, 69 ], -
  39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16, 30 ]

-------------------------------------------------------------------------------
Addition in place - AVX<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint32_t, 10> with size 10 and content [ 895856169, 32754,
  4230052742, 21839, 18, 5, 895856509, 32693, 895856231, 32836 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = addition<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967283, 4294967281, 4294967238, 10, 5, 4294967213, 4294967222, 23, 69 ],
  4294967257) = [ 4294967218, 4294967244, 4294967242, 4294967199, 4294967267,
  4294967262, 4294967174, 4294967183, 4294967280, 30 ]

-------------------------------------------------------------------------------
Addition in place - AVX<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int64_t, 10> with size 10 and content [ -39, 140734089244611,
  140734089244145, 94051127591990, 10, 140734089244629, 140734089244077,
  94051127591974, 23, 140734089244693 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long int;
  ArgA = long int; ArgB = long int; R (* t)(ArgA, ArgB) = addition<long int>;
  std::string_view = std::basic_string_view<char> ([ -39, -13, -15, -58, 10, 5,
  -83, -74, 23, 69 ], -39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16,
  30 ]

-------------------------------------------------------------------------------
Addition in place - AVX<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint64_t, 10> with size 10 and content [ 18446744073709551577,
  140734089244611, 18446744073709551609, 140734089244438, 10, 140734089244629,
  18446744073709551541, 140734089244422, 23, 140734089244693 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long unsigned int; ArgA
  = long unsigned int; ArgB = long unsigned int; R (* t)(ArgA, ArgB) = addition
  <long unsigned int>; std::string_view = std::basic_string_view<char> ([
  18446744073709551577, 18446744073709551603, 18446744073709551601,
  18446744073709551558, 10, 5, 18446744073709551533, 18446744073709551542, 23,
  69 ], 18446744073709551577) = [ 18446744073709551538, 18446744073709551564,
  18446744073709551562, 18446744073709551519, 18446744073709551587,
  18446744073709551582, 18446744073709551494, 18446744073709551503,
  18446744073709551600, 30 ]

-------------------------------------------------------------------------------
Addition in place - SSE<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -38.222, -12.0987, -1.
  3097e+37, -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = addition<float>; std::string_view = std::
  basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.2879, 5.
  20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.4394, -50.
  3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -14.6781,
  30.7891 ]

-------------------------------------------------------------------------------
Addition in place - SSE<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -38.222, -12.0987, -14.
  5897, -57.2018, 10.2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = addition<double>; std::string_view =
  std::basic_string_view<char> ([ -38.222, -12.0987, -14.5897, -57.2018, 10.
  2879, 5.20638, -82.9955, -73.4763, 23.5394, 69.0066 ], -38.2175) = [ -76.
  4394, -50.3161, -52.8071, -95.4193, -27.9296, -33.0111, -121.213, -111.694, -
  14.6781, 30.7892 ]

-------------------------------------------------------------------------------
Addition in place - SSE<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int32_t, 10> with size 10 and content [ 895856169, 32754, -
  65656432, 21839, 895856730, 32772, -83, -74, 895856231, 32836 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = int; ArgA = int; ArgB =
  int; R (* t)(ArgA, ArgB) = addition<int>; std::string_view = std::
  basic_string_view<char> ([ -39, -13, -15, -58, 10, 5, -83, -74, 23, 69 ], -
  39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16, 30 ]

-------------------------------------------------------------------------------
Addition in place - SSE<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint32_t, 10> with size 10 and content [ 895856169, 32754,
  4230052742, 21839, 18, 5, 895856509, 32693, 895856231, 32836 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = addition<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967283, 4294967281, 4294967238, 10, 5, 4294967213, 4294967222, 23, 69 ],
  4294967257) = [ 4294967218, 4294967244, 4294967242, 4294967199, 4294967267,
  4294967262, 4294967174, 4294967183, 4294967280, 30 ]

-------------------------------------------------------------------------------
Addition in place - SSE<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int64_t, 10> with size 10 and content [ -39, 140734089244611,
  140734089244145, 94051127591990, 10, 140734089244629, 140734089244077,
  94051127591974, 23, 140734089244693 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long int;
  ArgA = long int; ArgB = long int; R (* t)(ArgA, ArgB) = addition<long int>;
  std::string_view = std::basic_string_view<char> ([ -39, -13, -15, -58, 10, 5,
  -83, -74, 23, 69 ], -39) = [ -78, -52, -54, -97, -29, -34, -122, -113, -16,
  30 ]

-------------------------------------------------------------------------------
Addition in place - SSE<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Add.cpp:56: FAILED:
  REQUIRE_THAT( sum2, vctr::EqualsTransformedBy<addition> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint64_t, 10> with size 10 and content [ 18446744073709551577,
  140734089244611, 18446744073709551609, 140734089244438, 10, 140734089244629,
  18446744073709551541, 140734089244422, 23, 140734089244693 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long unsigned int; ArgA
  = long unsigned int; ArgB = long unsigned int; R (* t)(ArgA, ArgB) = addition
  <long unsigned int>; std::string_view = std::basic_string_view<char> ([
  18446744073709551577, 18446744073709551603, 18446744073709551601,
  18446744073709551558, 10, 5, 18446744073709551533, 18446744073709551542, 23,
  69 ], 18446744073709551577) = [ 18446744073709551538, 18446744073709551564,
  18446744073709551562, 18446744073709551519, 18446744073709551587,
  18446744073709551582, 18446744073709551494, 18446744073709551503,
  18446744073709551600, 30 ]

-------------------------------------------------------------------------------
Division - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:34
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:45: FAILED:
  REQUIRE_THAT( constantDividedByVec, vctr::EqualsTransformedBy<division> (c, srcA).withEpsilon() )
with expansion:
  vctr::Vector<float> with size 10 and content [ -0, -0, 0, -0, 3.67064e+21, 5.
  05869e-43, 8.56981e+35, -3.92364e-43, -0, 0 ] Equals: consteval std::
  string_view vctr::detail::functionNameWrappedInFunctionTemplateName() [with R
  = float; ArgA = float; ArgB = float; R (* t)(ArgA, ArgB) = division<float>;
  std::string_view = std::basic_string_view<char> (-38.2175, [ -38.1905, -93.
  0532, 27.2699, -57.1641, 30.6455, 90.0289, -15.485, -78.1098, -40.434, 11.
  7712 ]) = [ 1.00071, 0.410705, -1.40145, 0.668557, -1.24708, -0.424502, 2.
  46803, 0.489278, 0.945182, -3.2467 ]

-------------------------------------------------------------------------------
Division - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:34
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:45: FAILED:
  REQUIRE_THAT( constantDividedByVec, vctr::EqualsTransformedBy<division> (c, srcA).withEpsilon() )
with expansion:
  vctr::Vector<double> with size 10 and content [ -0, -0, 2.53158e-311, -8.
  12878e-312, 0, 0, -4.45822e-311, -5.94899e-312, -0, 0 ] Equals: consteval
  std::string_view vctr::detail::functionNameWrappedInFunctionTemplateName()
  [with R = double; ArgA = double; ArgB = double; R (* t)(ArgA, ArgB) =
  division<double>; std::string_view = std::basic_string_view<char> (-38.2175,
  [ -38.1905, -93.0532, 27.2698, -57.1641, 30.6455, 90.0289, -15.485, -78.1098,
  -40.434, 11.7712 ]) = [ 1.00071, 0.410705, -1.40145, 0.668557, -1.24708, -0.
  424502, 2.46803, 0.489278, 0.945182, -3.2467 ]

-------------------------------------------------------------------------------
Divide in place - PlatformVectorOps<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:51
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:64: FAILED:
  REQUIRE_THAT( quotient2, vctr::EqualsTransformedBy<division> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -4.46327e+07, -inf, -2.
  05162e-36, -inf, inf, inf, -1.80973e+07, -inf, -4.72547e+07, inf ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = division<float>; std::string_view = std::
  basic_string_view<char> ([ -38.1905, -93.0532, 27.2699, -57.1641, 30.6455,
  90.0289, -15.485, -78.1098, -40.434, 11.7712 ], -38.2175) = [ 0.999294, 2.
  43484, -0.713544, 1.49576, -0.801872, -2.3557, 0.405182, 2.04383, 1.058, -0.
  308005 ]

-------------------------------------------------------------------------------
Divide in place - PlatformVectorOps<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:51
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:64: FAILED:
  REQUIRE_THAT( quotient2, vctr::EqualsTransformedBy<division> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -inf, -inf, inf, -inf,
  inf, inf, -inf, -inf, -inf, inf ] Equals: consteval std::string_view vctr::
  detail::functionNameWrappedInFunctionTemplateName() [with R = double; ArgA =
  double; ArgB = double; R (* t)(ArgA, ArgB) = division<double>; std::
  string_view = std::basic_string_view<char> ([ -38.1905, -93.0532, 27.2698, -
  57.1641, 30.6455, 90.0289, -15.485, -78.1098, -40.434, 11.7712 ], -38.2175) =
  [ 0.999294, 2.43484, -0.713544, 1.49576, -0.801872, -2.3557, 0.405182, 2.
  04383, 1.058, -0.308005 ]

-------------------------------------------------------------------------------
Divide in place - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:51
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:64: FAILED:
  REQUIRE_THAT( quotient2, vctr::EqualsTransformedBy<division> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -4.46327e+07, -inf, -2.
  05082e-36, -inf, inf, inf, -1.80973e+07, -inf, -4.72547e+07, inf ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = division<float>; std::string_view = std::
  basic_string_view<char> ([ -38.1905, -93.0532, 27.2699, -57.1641, 30.6455,
  90.0289, -15.485, -78.1098, -40.434, 11.7712 ], -38.2175) = [ 0.999294, 2.
  43484, -0.713544, 1.49576, -0.801872, -2.3557, 0.405182, 2.04383, 1.058, -0.
  308005 ]

-------------------------------------------------------------------------------
Divide in place - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:51
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:64: FAILED:
  REQUIRE_THAT( quotient2, vctr::EqualsTransformedBy<division> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -inf, -inf, inf, -inf,
  inf, inf, -inf, -inf, -inf, inf ] Equals: consteval std::string_view vctr::
  detail::functionNameWrappedInFunctionTemplateName() [with R = double; ArgA =
  double; ArgB = double; R (* t)(ArgA, ArgB) = division<double>; std::
  string_view = std::basic_string_view<char> ([ -38.1905, -93.0532, 27.2698, -
  57.1641, 30.6455, 90.0289, -15.485, -78.1098, -40.434, 11.7712 ], -38.2175) =
  [ 0.999294, 2.43484, -0.713544, 1.49576, -0.801872, -2.3557, 0.405182, 2.
  04383, 1.058, -0.308005 ]

-------------------------------------------------------------------------------
Divide in place - SSE<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:51
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:64: FAILED:
  REQUIRE_THAT( quotient2, vctr::EqualsTransformedBy<division> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -4.46327e+07, -inf, -2.
  05022e-36, -inf, inf, inf, -1.80973e+07, -inf, -4.72547e+07, inf ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = division<float>; std::string_view = std::
  basic_string_view<char> ([ -38.1905, -93.0532, 27.2699, -57.1641, 30.6455,
  90.0289, -15.485, -78.1098, -40.434, 11.7712 ], -38.2175) = [ 0.999294, 2.
  43484, -0.713544, 1.49576, -0.801872, -2.3557, 0.405182, 2.04383, 1.058, -0.
  308005 ]

-------------------------------------------------------------------------------
Divide in place - SSE<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:51
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Divide.cpp:64: FAILED:
  REQUIRE_THAT( quotient2, vctr::EqualsTransformedBy<division> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -inf, -inf, inf, -inf,
  inf, inf, -inf, -inf, -inf, inf ] Equals: consteval std::string_view vctr::
  detail::functionNameWrappedInFunctionTemplateName() [with R = double; ArgA =
  double; ArgB = double; R (* t)(ArgA, ArgB) = division<double>; std::
  string_view = std::basic_string_view<char> ([ -38.1905, -93.0532, 27.2698, -
  57.1641, 30.6455, 90.0289, -15.485, -78.1098, -40.434, 11.7712 ], -38.2175) =
  [ 0.999294, 2.43484, -0.713544, 1.49576, -0.801872, -2.3557, 0.405182, 2.
  04383, 1.058, -0.308005 ]

-------------------------------------------------------------------------------
Multiply - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:39: FAILED:
  REQUIRE_THAT( product1, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Vector<float> with size 10 and content [ -0, 0, -0, 0, 9.52272e+24, -1.
  27644e-39, -inf, 9.58998e-40, 0, 0 ] Equals: consteval std::string_view vctr:
  :detail::functionNameWrappedInFunctionTemplateName() [with R = float; ArgA =
  float; ArgB = float; R (* t)(ArgA, ArgB) = multiplication<float>; std::
  string_view = std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349, 45.
  6109, 84.6548, -27.9992, 52.8771, 31.2538, 50.8303, 28.097 ], -38.2175) = [
  1458, -2293.25, 3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -
  1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:39: FAILED:
  REQUIRE_THAT( product1, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Vector<double> with size 10 and content [ -0, 0, -6.23633e-308, 2.
  11942e-308, 0, -0, 3.65041e-308, 1.45228e-308, 0, 0 ] Equals: consteval std::
  string_view vctr::detail::functionNameWrappedInFunctionTemplateName() [with R
  = double; ArgA = double; ArgB = double; R (* t)(ArgA, ArgB) = multiplication
  <double>; std::string_view = std::basic_string_view<char> ([ -38.15, 60.0052,
  -90.3349, 45.6109, 84.6548, -27.9992, 52.8771, 31.2538, 50.8303, 28.0969 ], -
  38.2175) = [ 1458, -2293.25, 3452.37, -1743.13, -3235.29, 1070.06, -2020.83,
  -1194.44, -1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply in place - PlatformVectorOps<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:45
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:58: FAILED:
  REQUIRE_THAT( product2, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -3.26435e-05, 2.75522e-39,
  inf, 1.39954e-39, 9.48679e-43, -0, 4.52446e-05, 1.43506e-39, 4.34935e-05, 1.
  29011e-39 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = multiplication<float>; std::string_view =
  std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349, 45.6109, 84.6548,
  -27.9992, 52.8771, 31.2538, 50.8303, 28.097 ], -38.2175) = [ 1458, -2293.25,
  3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply in place - PlatformVectorOps<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:45
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:58: FAILED:
  REQUIRE_THAT( product2, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -2.65264e-308, 2.78829e-
  308, -3.57209e-321, 3.17141e-308, 5.88621e-308, -1.30105e-308, 2.0899e-321,
  2.17313e-308, 3.53432e-308, 1.30559e-308 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = double;
  ArgA = double; ArgB = double; R (* t)(ArgA, ArgB) = multiplication<double>;
  std::string_view = std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349,
  45.6109, 84.6548, -27.9992, 52.8771, 31.2538, 50.8303, 28.0969 ], -38.2175) =
  [ 1458, -2293.25, 3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -
  1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply in place - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:45
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:58: FAILED:
  REQUIRE_THAT( product2, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -3.26435e-05, 2.75522e-39,
  inf, 1.39954e-39, 9.48679e-43, -0, 4.52446e-05, 1.43506e-39, 4.34935e-05, 1.
  29011e-39 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = multiplication<float>; std::string_view =
  std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349, 45.6109, 84.6548,
  -27.9992, 52.8771, 31.2538, 50.8303, 28.097 ], -38.2175) = [ 1458, -2293.25,
  3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply in place - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:45
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:58: FAILED:
  REQUIRE_THAT( product2, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -2.65264e-308, 2.78829e-
  308, -3.57209e-321, 3.17141e-308, 5.88621e-308, -1.30105e-308, 2.0899e-321,
  2.17313e-308, 3.53432e-308, 1.30559e-308 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = double;
  ArgA = double; ArgB = double; R (* t)(ArgA, ArgB) = multiplication<double>;
  std::string_view = std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349,
  45.6109, 84.6548, -27.9992, 52.8771, 31.2538, 50.8303, 28.0969 ], -38.2175) =
  [ 1458, -2293.25, 3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -
  1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply in place - SSE<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:45
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:58: FAILED:
  REQUIRE_THAT( product2, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -3.26435e-05, 2.75522e-39,
  inf, 1.39954e-39, 9.48679e-43, -0, 4.52446e-05, 1.43506e-39, 4.34935e-05, 1.
  29011e-39 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = multiplication<float>; std::string_view =
  std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349, 45.6109, 84.6548,
  -27.9992, 52.8771, 31.2538, 50.8303, 28.097 ], -38.2175) = [ 1458, -2293.25,
  3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -1942.6, -1073.79 ]

-------------------------------------------------------------------------------
Multiply in place - SSE<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:45
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Multiply.cpp:58: FAILED:
  REQUIRE_THAT( product2, vctr::EqualsTransformedBy<multiplication> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -2.65264e-308, 2.78829e-
  308, -3.57209e-321, 3.17141e-308, 5.88621e-308, -1.30105e-308, 2.0899e-321,
  2.17313e-308, 3.53432e-308, 1.30559e-308 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = double;
  ArgA = double; ArgB = double; R (* t)(ArgA, ArgB) = multiplication<double>;
  std::string_view = std::basic_string_view<char> ([ -38.15, 60.0052, -90.3349,
  45.6109, 84.6548, -27.9992, 52.8771, 31.2538, 50.8303, 28.0969 ], -38.2175) =
  [ 1458, -2293.25, 3452.37, -1743.13, -3235.29, 1070.06, -2020.83, -1194.44, -
  1942.6, -1073.79 ]

-------------------------------------------------------------------------------
NormalizeSum - PlatformVectorOps<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:25
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:37: FAILED:
  REQUIRE_THAT( normalizedSum, vctr::Equals (dividedBySum).withEpsilon (0.00001) )
with expansion:
  vctr::Vector<float> with size 10 and content [ 2.84485e-36, -2.38215e-36, 6.
  64599e-36, -4.46532e-36, -4.9328e-36, 7.26686e-37, -1.00597e-36, -6.0644e-36,
  -2.48885e-36, -6.91065e-36 ] Equals: vctr::Vector<float> with size 10 and
  content [ 0.999984, inf, -inf, inf, 7.40241e+07, -inf, 1, inf, 0.999984, inf
  ]

-------------------------------------------------------------------------------
NormalizeSum - PlatformVectorOps<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:25
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:37: FAILED:
  REQUIRE_THAT( normalizedSum, vctr::Equals (dividedBySum).withEpsilon (0.00001) )
with expansion:
  vctr::Vector<double> with size 10 and content [ -0.163317, 0.136754, -0.
  381532, 0.256344, 0.283181, -0.0417175, 0.0577503, 0.348144, 0.142879, 0.
  396725 ] Equals: vctr::Vector<double> with size 10 and content [ -inf, inf, -
  inf, inf, inf, -inf, inf, inf, inf, inf ]

-------------------------------------------------------------------------------
NormalizeSum - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:25
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:37: FAILED:
  REQUIRE_THAT( normalizedSum, vctr::Equals (dividedBySum).withEpsilon (0.00001) )
with expansion:
  vctr::Vector<float> with size 10 and content [ 2.79013e-36, -2.33633e-36, 6.
  51816e-36, -4.37943e-36, -4.83792e-36, 7.12708e-37, -9.86616e-37, -5.94775e-
  36, -2.44097e-36, -6.77772e-36 ] Equals: vctr::Vector<float> with size 10 and
  content [ 0.999985, inf, -inf, inf, 7.40241e+07, -inf, 1, inf, 0.999985, inf
  ]

-------------------------------------------------------------------------------
NormalizeSum - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:25
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:37: FAILED:
  REQUIRE_THAT( normalizedSum, vctr::Equals (dividedBySum).withEpsilon (0.00001) )
with expansion:
  vctr::Vector<double> with size 10 and content [ -0.163317, 0.136754, -0.
  381532, 0.256344, 0.283181, -0.0417175, 0.0577503, 0.348144, 0.142879, 0.
  396725 ] Equals: vctr::Vector<double> with size 10 and content [ -inf, inf, -
  inf, inf, inf, -inf, inf, inf, inf, inf ]

-------------------------------------------------------------------------------
NormalizeSum - SSE<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:25
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:37: FAILED:
  REQUIRE_THAT( normalizedSum, vctr::Equals (dividedBySum).withEpsilon (0.00001) )
with expansion:
  vctr::Vector<float> with size 10 and content [ 2.78957e-36, -2.33586e-36, 6.
  51684e-36, -4.37855e-36, -4.83695e-36, 7.12565e-37, -9.86417e-37, -5.94655e-
  36, -2.44048e-36, -6.77636e-36 ] Equals: vctr::Vector<float> with size 10 and
  content [ 0.999985, inf, -inf, inf, 7.40241e+07, -inf, 1, inf, 0.999985, inf
  ]

-------------------------------------------------------------------------------
NormalizeSum - SSE<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:25
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/NormalizeSum.cpp:37: FAILED:
  REQUIRE_THAT( normalizedSum, vctr::Equals (dividedBySum).withEpsilon (0.00001) )
with expansion:
  vctr::Vector<double> with size 10 and content [ -0.163317, 0.136754, -0.
  381532, 0.256344, 0.283181, -0.0417175, 0.0577503, 0.348144, 0.142879, 0.
  396725 ] Equals: vctr::Vector<double> with size 10 and content [ -inf, inf, -
  inf, inf, inf, -inf, inf, inf, inf, inf ]

-------------------------------------------------------------------------------
Subtraction - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:38: FAILED:
  REQUIRE_THAT( constantMinusVec, vctr::EqualsTransformedBy<subtraction> (c, srcA) )
with expansion:
  vctr::Vector<float> with size 10 and content [ 38.0826, 84.8975, 86.3547, 28.
  4435, 1.12489e+23, -26.5899, -1.31004e+37, 19.066, -64.1212, 4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = subtraction<float>; std::string_view =
  std::basic_string_view<char> (-38.2175, [ -38.0826, -84.8975, -86.3547, -28.
  4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]) = [ -0.134865,
  46.68, 48.1373, -9.77397, -42.5312, -64.8074, 38.6034, -19.1514, -102.339, -
  33.2361 ]

-------------------------------------------------------------------------------
Subtraction - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:38: FAILED:
  REQUIRE_THAT( constantMinusVec, vctr::EqualsTransformedBy<subtraction> (c, srcA) )
with expansion:
  vctr::Vector<double> with size 10 and content [ 38.0826, 84.8975, 86.3547,
  28.4435, -4.3137, -26.5899, 76.8208, 19.066, -64.1212, 4.98139 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = subtraction<double>; std::string_view =
  std::basic_string_view<char> (-38.2175, [ -38.0826, -84.8975, -86.3547, -28.
  4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]) = [ -0.134868,
  46.68, 48.1373, -9.77397, -42.5312, -64.8074, 38.6034, -19.1514, -102.339, -
  33.2361 ]

-------------------------------------------------------------------------------
Subtraction - AVX<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:38: FAILED:
  REQUIRE_THAT( constantMinusVec, vctr::EqualsTransformedBy<subtraction> (c, srcA) )
with expansion:
  vctr::Vector<int32_t> with size 10 and content [ 39, 85, 87, 29, 1706987580,
  32507, -48407603, 21917, -64, 5 ] Equals: consteval std::string_view vctr::
  detail::functionNameWrappedInFunctionTemplateName() [with R = int; ArgA =
  int; ArgB = int; R (* t)(ArgA, ArgB) = subtraction<int>; std::string_view =
  std::basic_string_view<char> (-39, [ -39, -85, -87, -29, 4, 26, -77, -20, 64,
  -5 ]) = [ 0, 46, 48, -10, -43, -65, 38, -19, -103, -34 ]

-------------------------------------------------------------------------------
Subtraction - AVX<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:38: FAILED:
  REQUIRE_THAT( constantMinusVec, vctr::EqualsTransformedBy<subtraction> (c, srcA) )
with expansion:
  vctr::Vector<uint32_t> with size 10 and content [ 39, 85, 87, 29, 1706987580,
  32507, 4246561101, 21917, 4294967232, 5 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = unsigned
  int; ArgA = unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) =
  subtraction<unsigned int>; std::string_view = std::basic_string_view<char>
  (4294967257, [ 4294967257, 4294967211, 4294967209, 4294967267, 4, 26,
  4294967219, 4294967276, 64, 4294967291 ]) = [ 0, 46, 48, 4294967286,
  4294967253, 4294967231, 38, 4294967277, 4294967193, 4294967262 ]

-------------------------------------------------------------------------------
Subtraction - AVX<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:38: FAILED:
  REQUIRE_THAT( constantMinusVec, vctr::EqualsTransformedBy<subtraction> (c, srcA) )
with expansion:
  vctr::Vector<int64_t> with size 10 and content [ 39, 85, 139729878028439,
  94051145442589, -4, -26, 139729878028429, 94051145442580, -64, 5 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long int; ArgA = long
  int; ArgB = long int; R (* t)(ArgA, ArgB) = subtraction<long int>; std::
  string_view = std::basic_string_view<char> (-39, [ -39, -85, -87, -29, 4, 26,
  -77, -20, 64, -5 ]) = [ 0, 46, 48, -10, -43, -65, 38, -19, -103, -34 ]

-------------------------------------------------------------------------------
Subtraction - AVX<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:28
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:38: FAILED:
  REQUIRE_THAT( constantMinusVec, vctr::EqualsTransformedBy<subtraction> (c, srcA) )
with expansion:
  vctr::Vector<uint64_t> with size 10 and content [ 39, 85, 139729878028439,
  94051145444285, 18446744073709551612, 18446744073709551590, 139729878028429,
  94051145444276, 18446744073709551552, 5 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long
  unsigned int; ArgA = long unsigned int; ArgB = long unsigned int; R (* t)
  (ArgA, ArgB) = subtraction<long unsigned int>; std::string_view = std::
  basic_string_view<char> (18446744073709551577, [ 18446744073709551577,
  18446744073709551531, 18446744073709551529, 18446744073709551587, 4, 26,
  18446744073709551539, 18446744073709551596, 64, 18446744073709551611 ]) = [
  0, 46, 48, 18446744073709551606, 18446744073709551573, 18446744073709551551,
  38, 18446744073709551597, 18446744073709551513, 18446744073709551582 ]

-------------------------------------------------------------------------------
Subtraction in place - PlatformVectorOps<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -38.0826, -84.8975, 1.
  31495e+37, -28.4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = subtraction<float>; std::string_view =
  std::basic_string_view<char> ([ -38.0826, -84.8975, -86.3547, -28.4435, 4.
  3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ], -38.2175) = [ 0.
  134865, -46.68, -48.1373, 9.77397, 42.5312, 64.8074, -38.6034, 19.1514, 102.
  339, 33.2361 ]

-------------------------------------------------------------------------------
Subtraction in place - PlatformVectorOps<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -38.0826, -84.8975, -86.
  3547, -28.4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = subtraction<double>; std::string_view =
  std::basic_string_view<char> ([ -38.0826, -84.8975, -86.3547, -28.4435, 4.
  3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ], -38.2175) = [ 0.
  134868, -46.68, -48.1373, 9.77397, 42.5312, 64.8074, -38.6034, 19.1514, 102.
  339, 33.2361 ]

-------------------------------------------------------------------------------
Subtraction in place - PlatformVectorOps<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int32_t, 10> with size 10 and content [ -895856343, -32852,
  65656330, -21926, -895856780, -32741, -77, -20, -895856240, -32772 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = int; ArgA = int; ArgB =
  int; R (* t)(ArgA, ArgB) = subtraction<int>; std::string_view = std::
  basic_string_view<char> ([ -39, -85, -87, -29, 4, 26, -77, -20, 64, -5 ], -
  39) = [ 0, -46, -48, 10, 43, 65, -38, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - PlatformVectorOps<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint32_t, 10> with size 10 and content [ 3399110953, 4294934444,
  64914452, 4294945370, 4294967292, 26, 3399110531, 4294934509, 3399111056,
  4294934524 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = subtraction<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967211, 4294967209, 4294967267, 4, 26, 4294967219, 4294967276, 64,
  4294967291 ], 4294967257) = [ 0, 4294967250, 4294967248, 10, 43, 65,
  4294967258, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - PlatformVectorOps<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int64_t, 10> with size 10 and content [ -39, -140734089244741, -
  140734089244311, -94051127592077, 4, -140734089244630, -140734089244301, -
  94051127592068, 64, -140734089244661 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long int;
  ArgA = long int; ArgB = long int; R (* t)(ArgA, ArgB) = subtraction<long int>
  ; std::string_view = std::basic_string_view<char> ([ -39, -85, -87, -29, 4,
  26, -77, -20, 64, -5 ], -39) = [ 0, -46, -48, 10, 43, 65, -38, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - PlatformVectorOps<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint64_t, 10> with size 10 and content [ 18446744073709551577,
  18446603339620306875, 18446744073709551521, 18446603339620307027, 4,
  18446603339620306986, 18446744073709551531, 18446603339620307036, 64,
  18446603339620306955 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long unsigned int; ArgA
  = long unsigned int; ArgB = long unsigned int; R (* t)(ArgA, ArgB) =
  subtraction<long unsigned int>; std::string_view = std::basic_string_view
  <char> ([ 18446744073709551577, 18446744073709551531, 18446744073709551529,
  18446744073709551587, 4, 26, 18446744073709551539, 18446744073709551596, 64,
  18446744073709551611 ], 18446744073709551577) = [ 0, 18446744073709551570,
  18446744073709551568, 10, 43, 65, 18446744073709551578, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - AVX<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -38.0826, -84.8975, 1.
  32784e+37, -28.4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = subtraction<float>; std::string_view =
  std::basic_string_view<char> ([ -38.0826, -84.8975, -86.3547, -28.4435, 4.
  3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ], -38.2175) = [ 0.
  134865, -46.68, -48.1373, 9.77397, 42.5312, 64.8074, -38.6034, 19.1514, 102.
  339, 33.2361 ]

-------------------------------------------------------------------------------
Subtraction in place - AVX<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -38.0826, -84.8975, -86.
  3547, -28.4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = subtraction<double>; std::string_view =
  std::basic_string_view<char> ([ -38.0826, -84.8975, -86.3547, -28.4435, 4.
  3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ], -38.2175) = [ 0.
  134868, -46.68, -48.1373, 9.77397, 42.5312, 64.8074, -38.6034, 19.1514, 102.
  339, 33.2361 ]

-------------------------------------------------------------------------------
Subtraction in place - AVX<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int32_t, 10> with size 10 and content [ -895856343, -32852,
  65656330, -21926, -895856780, -32741, -77, -20, -895856240, -32772 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = int; ArgA = int; ArgB =
  int; R (* t)(ArgA, ArgB) = subtraction<int>; std::string_view = std::
  basic_string_view<char> ([ -39, -85, -87, -29, 4, 26, -77, -20, 64, -5 ], -
  39) = [ 0, -46, -48, 10, 43, 65, -38, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - AVX<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint32_t, 10> with size 10 and content [ 3399110953, 4294934444,
  64914452, 4294945370, 4294967292, 26, 3399110531, 4294934509, 3399111056,
  4294934524 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = subtraction<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967211, 4294967209, 4294967267, 4, 26, 4294967219, 4294967276, 64,
  4294967291 ], 4294967257) = [ 0, 4294967250, 4294967248, 10, 43, 65,
  4294967258, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - AVX<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int64_t, 10> with size 10 and content [ -39, -140734089244741, -
  140734089244311, -94051127592077, 4, -140734089244630, -140734089244301, -
  94051127592068, 64, -140734089244661 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long int;
  ArgA = long int; ArgB = long int; R (* t)(ArgA, ArgB) = subtraction<long int>
  ; std::string_view = std::basic_string_view<char> ([ -39, -85, -87, -29, 4,
  26, -77, -20, 64, -5 ], -39) = [ 0, -46, -48, 10, 43, 65, -38, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - AVX<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint64_t, 10> with size 10 and content [ 18446744073709551577,
  18446603339620306875, 18446744073709551521, 18446603339620307027, 4,
  18446603339620306986, 18446744073709551531, 18446603339620307036, 64,
  18446603339620306955 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long unsigned int; ArgA
  = long unsigned int; ArgB = long unsigned int; R (* t)(ArgA, ArgB) =
  subtraction<long unsigned int>; std::string_view = std::basic_string_view
  <char> ([ 18446744073709551577, 18446744073709551531, 18446744073709551529,
  18446744073709551587, 4, 26, 18446744073709551539, 18446744073709551596, 64,
  18446744073709551611 ], 18446744073709551577) = [ 0, 18446744073709551570,
  18446744073709551568, 10, 43, 65, 18446744073709551578, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - SSE<float>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<float, 10> with size 10 and content [ -38.0826, -84.8975, 1.
  30935e+37, -28.4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = float; ArgA = float;
  ArgB = float; R (* t)(ArgA, ArgB) = subtraction<float>; std::string_view =
  std::basic_string_view<char> ([ -38.0826, -84.8975, -86.3547, -28.4435, 4.
  3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ], -38.2175) = [ 0.
  134865, -46.68, -48.1373, 9.77397, 42.5312, 64.8074, -38.6034, 19.1514, 102.
  339, 33.2361 ]

-------------------------------------------------------------------------------
Subtraction in place - SSE<double>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<double, 10> with size 10 and content [ -38.0826, -84.8975, -86.
  3547, -28.4435, 4.3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ]
  Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = double; ArgA = double;
  ArgB = double; R (* t)(ArgA, ArgB) = subtraction<double>; std::string_view =
  std::basic_string_view<char> ([ -38.0826, -84.8975, -86.3547, -28.4435, 4.
  3137, 26.5899, -76.8208, -19.066, 64.1212, -4.98139 ], -38.2175) = [ 0.
  134868, -46.68, -48.1373, 9.77397, 42.5312, 64.8074, -38.6034, 19.1514, 102.
  339, 33.2361 ]

-------------------------------------------------------------------------------
Subtraction in place - SSE<int32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int32_t, 10> with size 10 and content [ -895856343, -32852,
  65656330, -21926, -895856780, -32741, -77, -20, -895856240, -32772 ] Equals:
  consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = int; ArgA = int; ArgB =
  int; R (* t)(ArgA, ArgB) = subtraction<int>; std::string_view = std::
  basic_string_view<char> ([ -39, -85, -87, -29, 4, 26, -77, -20, 64, -5 ], -
  39) = [ 0, -46, -48, 10, 43, 65, -38, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - SSE<uint32_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint32_t, 10> with size 10 and content [ 3399110953, 4294934444,
  64914452, 4294945370, 4294967292, 26, 3399110531, 4294934509, 3399111056,
  4294934524 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = unsigned int; ArgA =
  unsigned int; ArgB = unsigned int; R (* t)(ArgA, ArgB) = subtraction<unsigned
  int>; std::string_view = std::basic_string_view<char> ([ 4294967257,
  4294967211, 4294967209, 4294967267, 4, 26, 4294967219, 4294967276, 64,
  4294967291 ], 4294967257) = [ 0, 4294967250, 4294967248, 10, 43, 65,
  4294967258, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - SSE<int64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<int64_t, 10> with size 10 and content [ -39, -140734089244741, -
  140734089244311, -94051127592077, 4, -140734089244630, -140734089244301, -
  94051127592068, 64, -140734089244661 ] Equals: consteval std::string_view
  vctr::detail::functionNameWrappedInFunctionTemplateName() [with R = long int;
  ArgA = long int; ArgB = long int; R (* t)(ArgA, ArgB) = subtraction<long int>
  ; std::string_view = std::basic_string_view<char> ([ -39, -85, -87, -29, 4,
  26, -77, -20, 64, -5 ], -39) = [ 0, -46, -48, 10, 43, 65, -38, 19, 103, 34 ]

-------------------------------------------------------------------------------
Subtraction in place - SSE<uint64_t>
-------------------------------------------------------------------------------
/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:43
...............................................................................

/home/fred/spline/VCTR/test/TestCases/Expressions/Subtract.cpp:56: FAILED:
  REQUIRE_THAT( diff2, vctr::EqualsTransformedBy<subtraction> (srcA, c).withEpsilon() )
with expansion:
  vctr::Array<uint64_t, 10> with size 10 and content [ 18446744073709551577,
  18446603339620306875, 18446744073709551521, 18446603339620307027, 4,
  18446603339620306986, 18446744073709551531, 18446603339620307036, 64,
  18446603339620306955 ] Equals: consteval std::string_view vctr::detail::
  functionNameWrappedInFunctionTemplateName() [with R = long unsigned int; ArgA
  = long unsigned int; ArgB = long unsigned int; R (* t)(ArgA, ArgB) =
  subtraction<long unsigned int>; std::string_view = std::basic_string_view
  <char> ([ 18446744073709551577, 18446744073709551531, 18446744073709551529,
  18446744073709551587, 4, 26, 18446744073709551539, 18446744073709551596, 64,
  18446744073709551611 ], 18446744073709551577) = [ 0, 18446744073709551570,
  18446744073709551568, 10, 43, 65, 18446744073709551578, 19, 103, 34 ]

===============================================================================
test cases:  800 |  730 passed | 70 failed
assertions: 3448 | 3378 passed | 70 failed
JanosGit commented 1 year ago

Okay, this looks like there is a lot going wrong, can't really tell what from the output, but I assume it's likely a systematic problem rather than all of these expressions being broken individually. I see a lot of failures for SIMD based expression evaluations but not exclusively. Just for the record, do you use VCTR with Intel IPP?

One thing that I noted that you mentioned you used gcc 11.4.0, we use gcc 12 for the Linux based CI builds (and actually specify that compiler as minimum requirement). I'm not aware of any specific issues with gcc 11, it's just that we don't run tests with it. I'll see if I can spin up a gcc 11 test on GitHub Actions to check if that fails in a similar way...

TheWaveWarden commented 1 year ago

I didn't enable IPP so far.

we use gcc 12 for the Linux based CI builds (and actually specify that compiler as minimum requirement)

Ok I didn't know. I could try upgrading to gcc 12 for testing and report back.

What's also weird is that this change only started appearing at some point. I'll try and do a bisect to see where this issue first showed!

JanosGit commented 1 year ago

I started a Actions build using GCC 11.4 and it works fine: https://github.com/sonible/VCTR/pull/122

So the compiler version is not the problem here (tbh. I would have been surprised if that was the case). It would be great if you could bisect it to find the problematic commit. Just a shot in the dark, but commit 6eb5fe81fbb8c9c2af20eafa29854a00c6450f6a was the last big change regarding SIMD evaluation of expressions, maybe you want to start with that one first before really bisecting.

TheWaveWarden commented 1 year ago

@JanosGit 6eb5fe8 is indeed the first commit where the problem appears!

JanosGit commented 1 year ago

Could you try putting a breakpoint into e.g. vctr::expressions:: AddSingleToVec::prepareAVXEvaluation or similar functions and see if it ever gets called during the corresponding unit test? It should be called once before the simd based evaluation loop of the expression is executed. If it is not called, the computation is performed using an uninitialised SIMD register as one operand, which would explain random results as we see above.

JanosGit commented 1 year ago

Okay, I managed to reproduce the fails with GCC 12 on my Windows WSL environment. Will try to find out what's wrong there...

JanosGit commented 1 year ago

I think I found the source of the problem: All those prepareAVXEvaluation and prepareSSEEvaluation functions added with that commit are not prefixed with VCTR_TARGET ("avx") etc. which translates to an __attribute__ ((target ("avx"))) when building with GCC. In those functions, usually SIMD registers are populated with values, using broadcast intrinsics. When the functions are not prefixed with the attribute, I noted that the calls to the broadcast functions populate the registers with random values. Adding the attribute fixes that. I'll try to get a fix out soon, this should be relatively straightforward.

The one thing that I don't understand however is why the GCC builds on GitHub actions seem to not generate such failures...

TheWaveWarden commented 11 months ago

Sorry for the late response! Just wanted to report back that the PR did fix the issue on my machine! Thank you very much!