geo_vectors_utils_test.cc File Reference

Test of geo_vectors_utils.h utilities. More...

#include <boost/test/unit_test.hpp>
#include "larcorealg/Geometry/geo_vectors_utils_TVector.h"
#include "larcorealg/Geometry/geo_vectors_utils.h"
#include "larcorealg/CoreUtils/MetaUtils.h"
#include "TVector2.h"
#include "TVector3.h"
#include "TLorentzVector.h"
#include <iostream>
#include <sstream>
#include <string>
#include <array>
#include <vector>
#include <numeric>
#include <type_traits>
#include <stdexcept>
#include <cmath>

Go to the source code of this file.

Classes
struct	test_vectorAccess< Vector >
struct	test_vectorAccess< Vector const >
struct	IsfiniteTester< Vector, Dim >
struct	IsfiniteTester< Vector, 4U >
struct	IsfiniteTester< Vector, 3U >
struct	IsfiniteTester< Vector, 2U >
struct	VectorTraitsTester
struct	VectorTraitsTester::Vector0D< C >
struct	VectorTraitsTester::Vector1D< C >
struct	VectorTraitsTester::Vector2D< C >
struct	VectorTraitsTester::Vector3D< C >
struct	VectorTraitsTester::Vector4D< C >
struct	VectorTraitsTester::Vector5D< C >

Macros
#define	BOOST_TEST_MODULE   ( geo_vectors_test )

Functions
template<typename PointA , typename PointB >
void	CheckPoint (PointA const &test, PointB const &ref, std::string tag="")
void	test_MiddlePointAccumulator_defaultConstructor ()
void	test_MiddlePointAccumulator_sequenceConstructor ()
template<typename Point >
void	test_MiddlePointAccumulator_generic ()
void	test_MiddlePointAccumulator_documentation_class ()
void	test_MiddlePointAccumulator_documentation_middlePointAs ()
void	test_MiddlePointAccumulator_documentation ()
void	test_middlePoint ()
void	test_middlePointAs_documentation ()
void	test_middlePoint_iterators_documentation ()
void	test_middlePoint_initlist_documentation ()
template<typename Vector >
void	test_vectorProcessing ()
template<typename Source , typename Dest >
void	test_vector2Dconvert ()
template<typename Source , typename Dest >
void	test_vector3Dconvert ()
template<typename Source , typename Dest >
void	test_vector4Dconvert ()
void	test_makeFromCoords_documentation ()
template<typename Vector >
void	test_transform ()
void	test_XcoordManager_documentation ()
template<typename Vector >
void	test_CoordConstIterator ()
template<typename Vector >
void	test_fillCoords ()
	BOOST_AUTO_TEST_CASE (MiddlePointAccumulator_test)
	BOOST_AUTO_TEST_CASE (middlePoint_test)
	BOOST_AUTO_TEST_CASE (middlePoint_documentation_test)
	BOOST_AUTO_TEST_CASE (vectorAccess_test)
	BOOST_AUTO_TEST_CASE (vectorUtilDocumentation_test)
	BOOST_AUTO_TEST_CASE (vectorProperties_test)
	BOOST_AUTO_TEST_CASE (vectorProcessing_test)
	BOOST_AUTO_TEST_CASE (vectorConversion_test)
	BOOST_AUTO_TEST_CASE (vectorCoordinateIteration_test)

Detailed Description

Test of geo_vectors_utils.h utilities.

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

March 23, 2017

Definition in file geo_vectors_utils_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( geo_vectors_test )

Definition at line 10 of file geo_vectors_utils_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

MiddlePointAccumulator_test

)

Definition at line 1094 of file geo_vectors_utils_test.cc.

                                                  {
  test_MiddlePointAccumulator_defaultConstructor();
  test_MiddlePointAccumulator_sequenceConstructor();
  test_MiddlePointAccumulator_documentation();
  test_MiddlePointAccumulator_generic<TVector3>();
  test_MiddlePointAccumulator_generic<geo::Vector_t>();
  test_MiddlePointAccumulator_generic<geo::Point_t>();
} // BOOST_AUTO_TEST_CASE(MiddlePointAccumulator_test)

BOOST_AUTO_TEST_CASE

(

middlePoint_test

)

Definition at line 1103 of file geo_vectors_utils_test.cc.

                                       {
  test_middlePoint();
}

BOOST_AUTO_TEST_CASE

(

middlePoint_documentation_test

)

Definition at line 1107 of file geo_vectors_utils_test.cc.

                                                     {
  test_middlePointAs_documentation();
  test_middlePoint_iterators_documentation();
  test_middlePoint_initlist_documentation();
}

BOOST_AUTO_TEST_CASE

(

vectorAccess_test

)

Definition at line 1114 of file geo_vectors_utils_test.cc.

                                        {
  test_vectorAccess<TVector3>();
  test_vectorAccess<geo::Point_t>();
  test_vectorAccess<geo::Vector_t>();
  test_vectorAccess<TVector3 const>();
  test_vectorAccess<geo::Point_t const>();
  test_vectorAccess<geo::Vector_t const>();
} // BOOST_AUTO_TEST_CASE(vectorAccess_test)

BOOST_AUTO_TEST_CASE

(

vectorUtilDocumentation_test

)

Definition at line 1124 of file geo_vectors_utils_test.cc.

                                                   {
  test_XcoordManager_documentation();
  test_makeFromCoords_documentation();
} // BOOST_AUTO_TEST_CASE(vectorUtilDocumentation_test)

BOOST_AUTO_TEST_CASE

(

vectorProperties_test

)

Definition at line 1131 of file geo_vectors_utils_test.cc.

                                            {
  (void) VectorTraitsTester();
} // BOOST_AUTO_TEST_CASE(vectorConversion_test)

BOOST_AUTO_TEST_CASE

(

vectorProcessing_test

)

Definition at line 1137 of file geo_vectors_utils_test.cc.

                                            {
  test_vectorProcessing<TVector2>();
  test_vectorProcessing<geo::Point_t>();
  test_vectorProcessing<geo::Vector_t>();
  test_vectorProcessing<TVector3>();
  test_vectorProcessing<TLorentzVector>();
} // BOOST_AUTO_TEST_CASE(vectorProcessing_test)

BOOST_AUTO_TEST_CASE

(

vectorConversion_test

)

Definition at line 1147 of file geo_vectors_utils_test.cc.

                                            {
  // BUG until clang bug 21629 is fixed, the amount of work to make the *test*
  //     work on double[N] vectors is not worth; HERE are some things to restore
  //     when the bug is fixed:
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)

  // 2D
  test_vector2Dconvert<TVector2              , TVector2              >();
  test_vector2Dconvert<std::array<double, 2U>, TVector2              >();
  // HERE
  // test_vector2Dconvert<double[2U]            , TVector2              >();

  // 3D
  test_vector3Dconvert<std::array<double, 3U>, TVector3     >();

  // HERE
  // test_vector3Dconvert<double[3U]            , TVector3     >();
  test_vector3Dconvert<TVector3              , TVector3     >();
  test_vector3Dconvert<geo::Point_t          , TVector3     >();
  test_vector3Dconvert<geo::Vector_t         , TVector3     >();
  test_vector3Dconvert<std::array<double, 3U>, geo::Point_t >();
  // HERE
  // test_vector3Dconvert<double[3U]            , geo::Point_t >();
  test_vector3Dconvert<TVector3              , geo::Point_t >();
  test_vector3Dconvert<geo::Point_t          , geo::Point_t >();
  test_vector3Dconvert<geo::Vector_t         , geo::Point_t >();
  test_vector3Dconvert<std::array<double, 3U>, geo::Vector_t>();
  // HERE
  // test_vector3Dconvert<double[3U]            , geo::Vector_t>();
  test_vector3Dconvert<TVector3              , geo::Vector_t>();
  test_vector3Dconvert<geo::Point_t          , geo::Vector_t>();
  test_vector3Dconvert<geo::Vector_t         , geo::Vector_t>();

  test_transform<TVector3>();

  // 4D
  test_vector4Dconvert<TLorentzVector        , TLorentzVector>();
  test_vector4Dconvert<std::array<double, 4U>, TLorentzVector>();
  // HERE
  // test_vector4Dconvert<double[4U]            , TLorentzVector>();

} // BOOST_AUTO_TEST_CASE(vectorAccess_test)

BOOST_AUTO_TEST_CASE

(

vectorCoordinateIteration_test

)

Definition at line 1191 of file geo_vectors_utils_test.cc.

                                                     {

  test_CoordConstIterator<TVector2      >();
  test_CoordConstIterator<TVector3      >();
  test_CoordConstIterator<geo::Point_t  >();
  test_CoordConstIterator<geo::Vector_t >();
  test_CoordConstIterator<TLorentzVector>();

  test_fillCoords<TVector2      >();
  test_fillCoords<TVector3      >();
  test_fillCoords<geo::Point_t  >();
  test_fillCoords<geo::Vector_t >();
  test_fillCoords<TLorentzVector>();

} // BOOST_AUTO_TEST_CASE(vectorCoordinateIteration_test)

template<typename PointA , typename PointB >

void CheckPoint	(	PointA const &	test,
		PointB const &	ref,
		std::string	tag = ""
	)

Definition at line 38 of file geo_vectors_utils_test.cc.

{
  auto const tol = 0.001% tolerance();

  if (!tag.empty()) BOOST_TEST_CHECKPOINT(tag);

  for (auto ic: geo::vect::indices(test)) {
    BOOST_TEST_CHECKPOINT("  coordinate #" << ic);
    BOOST_TEST
      (geo::vect::coord(test, ic)() == geo::vect::coord(ref, ic)(), tol);
  }

} // CheckPoint()

template<typename Vector >

void test_CoordConstIterator

(

)

Definition at line 1043 of file geo_vectors_utils_test.cc.

                               {

  using Vector_t = Vector;
  using Coord_t = geo::vect::coordinate_t<Vector_t>;

  std::array<Coord_t, geo::vect::dimension<Vector_t>()> expected;
  std::iota(expected.begin(), expected.end(), Coord_t(1));
  auto const v = geo::vect::makeFromCoords<Vector_t>(expected);

  unsigned int index = 0;
  for (Coord_t c: geo::vect::iterateCoords(v)) {
    BOOST_TEST(c == expected[index]);
    ++index;
  } // for

  // same test as above,
  // but implicitly using ROOT::Math::cbegin()/cend() we provide
  index = 0;
  for (Coord_t c: v) {
    BOOST_TEST(c == expected[index]);
    ++index;
  } // for

} // test_CoordConstIterator()

template<typename Vector >

void test_fillCoords

(

)

Definition at line 1071 of file geo_vectors_utils_test.cc.

                       {

  using Vector_t = Vector;
  using Coord_t = geo::vect::coordinate_t<Vector_t>;

  std::array<Coord_t, geo::vect::dimension<Vector_t>()> expected;
  std::iota(expected.begin(), expected.end(), Coord_t(1));
  auto const v = geo::vect::makeFromCoords<Vector_t>(expected);

  Coord_t coords[geo::vect::dimension<Vector_t>()];
  auto const dim = geo::vect::fillCoords(coords, v);

  BOOST_TEST(dim == expected.size());

  for (unsigned int index = 0; index < dim; ++index)
    BOOST_TEST(coords[index] == expected[index]);

} // test_fillCoords()

void test_makeFromCoords_documentation

(

)

Definition at line 846 of file geo_vectors_utils_test.cc.

                                         {

  /*
   * constexpr std::array<float, 5U> data { 2.0, 5.0, 7.0, 11.0, 15.5 };
   * constexpr auto p = geo::vect::makeFromCoords<geo::Point_t>(data);
   * auto v = geo::vect::makeFromCoords<geo::Vector_t>(data.data() + 1);
   */
  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  constexpr std::array<float, 5U> data {{ 2.0, 5.0, 7.0, 11.0, 15.5 }};
  auto const p = geo::vect::makeFromCoords<geo::Point_t>(data);
  auto const v = geo::vect::makeFromCoords<geo::Vector_t>(data.data() + 1);

  BOOST_TEST(p == (geo::Point_t { 2.0, 5.0,  7.0 }));
  BOOST_TEST(v == (geo::Vector_t{ 5.0, 7.0, 11.0 }));

} // test_makeFromCoords_documentation()

void test_middlePoint

(

)

Definition at line 288 of file geo_vectors_utils_test.cc.

                        {

  geo::Point_t expected(2., 4., 6.);

  std::vector<geo::Point_t> points {
    geo::Point_t(1., 2., 3.),
    geo::Point_t(2., 4., 6.),
    geo::Point_t(3., 6., 9.)
  };

  //
  // sequence
  //
  CheckPoint
    (geo::vect::middlePoint(points.begin(), points.end()), expected, "iterators");


  //
  // points (initializer list)
  //
  CheckPoint(
    geo::vect::middlePoint({ points[0], points[1], points[2] }), expected,
    "initializer list"
    );


  //
  // middlePointAs() (sequence)
  //
  auto const mp3 = geo::vect::middlePointAs<TVector3>(points.begin(), points.end());
  static_assert(
    std::is_same<std::decay_t<decltype(mp3)>, TVector3>::value,
    "geo::vect::middlePointAs<TVector3> does not return a TVector3!"
    );
  CheckPoint(mp3, expected, "geo::vect::middlePointAs(sequence)");


} // test_middlePoint()

void test_middlePoint_initlist_documentation

(

)

Definition at line 379 of file geo_vectors_utils_test.cc.

                                               {

  /*
   * auto mp = geo::vect::middlePoint
   *   ({ geo::Point_t(1., 2., 3.), geo::Point_t(3., 6., 9.) });
   *
   */

  auto mp = geo::vect::middlePoint
    ({ geo::Point_t(1., 2., 3.), geo::Point_t(3., 6., 9.) });

  static_assert(std::is_same<std::decay_t<decltype(mp)>, geo::Point_t>::value,
    "geo::vect::middlePoint() result is not geo::Point_t");
  CheckPoint(mp, geo::Point_t(2., 4., 6.));

} // test_middlePoint_initlist_documentation()

void test_middlePoint_iterators_documentation

(

)

Definition at line 352 of file geo_vectors_utils_test.cc.

                                                {

  /*
   * std::vector<geo::Point_t> points {
   *   geo::Point_t(1., 2., 3.),
   *   geo::Point_t(2., 4., 6.),
   *   geo::Point_t(3., 6., 9.)
   *   };
   *
   * auto mp = geo::vect::middlePoint(points.begin(), points.end());
   */

  std::vector<geo::Point_t> points {
    geo::Point_t(1., 2., 3.),
    geo::Point_t(2., 4., 6.),
    geo::Point_t(3., 6., 9.)
    };

  auto mp = geo::vect::middlePoint(points.begin(), points.end());

  static_assert(std::is_same<std::decay_t<decltype(mp)>, geo::Point_t>::value,
    "geo::vect::middlePoint() result is not geo::Point_t");
  CheckPoint(mp, geo::Point_t(2., 4., 6.));

} // test_middlePoint_iterators_documentation()

void test_MiddlePointAccumulator_defaultConstructor

(

)

Definition at line 54 of file geo_vectors_utils_test.cc.

                                                      {

  geo::Point_t expected(2., 4., 6.);

  std::vector<geo::Point_t> points {
    geo::Point_t(1., 2., 3.),
    geo::Point_t(2., 4., 6.),
    geo::Point_t(3., 6., 9.)
  };
  TVector3 another(expected.X(), expected.Y(), expected.Z());

  //
  // default construction, then bulk addition
  //
  geo::vect::MiddlePointAccumulator acc;
  BOOST_TEST(acc.empty());
  BOOST_TEST(acc.weight() == 0.0, 0.001% tolerance());
  // add a single point
  acc.add(another);
  BOOST_TEST(!acc.empty());
  BOOST_TEST(acc.weight() == 1.0, 0.001% tolerance());
  CheckPoint(acc.middlePoint(), expected, "Single add");
  // add many points
  acc.add(points.begin(), points.end());
  BOOST_TEST(!acc.empty());
  BOOST_TEST(acc.weight() == 1.0 + points.size(), 0.001% tolerance());
  CheckPoint(acc.middlePoint(), expected, "Single add plus sequence");

  //
  // clear test
  //
  acc.clear();
  BOOST_TEST(acc.empty());
  acc.add(geo::Point_t{ expected.X() + 1.0, expected.Z(), expected.Y() });
  CheckPoint(
    acc.middlePoint(),
    geo::Point_t{ expected.X() + 1.0, expected.Z(), expected.Y() },
    "clear test"
    );

  //
  // start over (same accumulator)
  //
  acc.clear();
  // add many points
  acc.add(points.begin(), points.end());
  BOOST_TEST(!acc.empty());
  CheckPoint(acc.middlePoint(), expected, "Sequence add");
  // add another one
  acc.add(another);
  BOOST_TEST(!acc.empty());
  CheckPoint(acc.middlePoint(), expected, "Sequence add plus single point");

} // test_MiddlePointAccumulator_defaultConstructor()

void test_MiddlePointAccumulator_documentation

(

)

Definition at line 279 of file geo_vectors_utils_test.cc.

                                                 {

  test_MiddlePointAccumulator_documentation_class();
  test_MiddlePointAccumulator_documentation_middlePointAs();

} // test_MiddlePointAccumulator_documentation()

void test_MiddlePointAccumulator_documentation_class

(

)

Definition at line 210 of file geo_vectors_utils_test.cc.

                                                       {

  geo::Point_t expected { 0.0, 1.0, 0.0 };
  /*
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
   * std::array<geo::Point_t, 4> const points = {
   *   geo::Point_t{ 0.0,  1.0,  2.0 },
   *   geo::Point_t{ 0.0, -1.0,  2.0 },
   *   geo::Point_t{ 0.0,  1.0, -2.0 },
   *   geo::Point_t{ 0.0, -1.0, -2.0 }
   * };
   *
   * geo::vect::MiddlePointAccumulator pointsAboveGround;
   * for (auto const& point: points)
   *   if (point.Y() > 0.0) pointsAboveGround.add(point);
   *
   * if (pointsAboveGround.empty())
   *   throw std::runtime_error("No point above ground!");
   *
   * auto middleAboveGround = pointsAboveGround.middlePoint();
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   */
  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<geo::Point_t, 4> const points = {{
    geo::Point_t{ 0.0,  1.0,  2.0 },
    geo::Point_t{ 0.0, -1.0,  2.0 },
    geo::Point_t{ 0.0,  1.0, -2.0 },
    geo::Point_t{ 0.0, -1.0, -2.0 }
  }};

  geo::vect::MiddlePointAccumulator pointsAboveGround;
  for (auto const& point: points)
    if (point.Y() > 0.0) pointsAboveGround.add(point);

  if (pointsAboveGround.empty())
    throw std::runtime_error("No point above ground!");

  auto middleAboveGround = pointsAboveGround.middlePoint();


  static_assert(std::is_same<decltype(middleAboveGround), geo::Point_t>::value,
    "unexpected return type for geo::vect::MiddlePointAccumulator::middlePoint()");
  CheckPoint
    (middleAboveGround, expected, "MiddlePointAccumulator::middlePoint()");

} // test_MiddlePointAccumulator_documentation_middlePointAs()

void test_MiddlePointAccumulator_documentation_middlePointAs

(

)

Definition at line 259 of file geo_vectors_utils_test.cc.

                                                               {

  //
  // middlePointAs()
  //
  geo::vect::MiddlePointAccumulator accumulator;
  accumulator.add(geo::Point_t());

  /*
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
   * auto mp = accumulator.middlePointAs<TVector3>();
   * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   */
  auto mp = accumulator.middlePointAs<TVector3>();

  CheckPoint(mp, geo::Point_t(), "MiddlePointAccumulator::middlePointAs()");

} // test_MiddlePointAccumulator_documentation_middlePointAs()

template<typename Point >

void test_MiddlePointAccumulator_generic

(

)

Definition at line 137 of file geo_vectors_utils_test.cc.

                                           {

  constexpr unsigned int Dim = geo::vect::dimension<Point>();
  using Scalar_t = geo::vect::coordinate_t<Point>;

  // prepare the input from larger dimension input data
  constexpr unsigned int MaxDim = 4U;

  static_assert(Dim < MaxDim, "This test supports only up to dimension 4");
  using GenType = std::array<Scalar_t, MaxDim>;
  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  GenType const genExpected{{ 2., 4., 6., 8. }};

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::vector<GenType> genPoints {
    GenType{{ 1., 2., 3.,  4. }},
    GenType{{ 2., 4., 6.,  8. }},
    GenType{{ 3., 6., 9., 12. }}
  };

  std::vector<Point> points;
  for (auto const& genPoint: genPoints)
    points.push_back(geo::vect::makeFromCoords<Point>(genPoint.data()));
  auto const expected = geo::vect::makeFromCoords<Point>(genExpected.data());
  auto const another = expected;

  //
  // default construction, then bulk addition
  //
  geo::vect::MiddlePointAccumulator acc;
  BOOST_TEST(acc.empty());
  BOOST_TEST(acc.weight() == 0.0, 0.001% tolerance());
  // add a single point
  acc.add(another);
  BOOST_TEST(!acc.empty());
  BOOST_TEST(acc.weight() == 1.0, 0.001% tolerance());
  CheckPoint(acc.middlePoint(), expected, "Single add");
  // add many points
  acc.add(points.begin(), points.end());
  BOOST_TEST(!acc.empty());
  BOOST_TEST(acc.weight() == 1.0 + points.size(), 0.001% tolerance());
  CheckPoint(acc.middlePoint(), expected, "Single add plus sequence");

  //
  // clear test
  //
  acc.clear();
  BOOST_TEST(acc.empty());
  acc.add(geo::Point_t{ expected.X() + 1.0, expected.Z(), expected.Y() });
  CheckPoint(
    acc.middlePoint(),
    geo::Point_t{ expected.X() + 1.0, expected.Z(), expected.Y() },
    "clear test"
    );

  //
  // start over (same accumulator)
  //
  acc.clear();
  // add many points
  acc.add(points.begin(), points.end());
  BOOST_TEST(!acc.empty());
  CheckPoint(acc.middlePoint(), expected, "Sequence add");
  // add another one
  acc.add(another);
  BOOST_TEST(!acc.empty());
  CheckPoint(acc.middlePoint(), expected, "Sequence add plus single point");

} // test_MiddlePointAccumulator_generic()

void test_MiddlePointAccumulator_sequenceConstructor

(

)

Definition at line 110 of file geo_vectors_utils_test.cc.

                                                       {

  geo::Point_t expected(2., 4., 6.);

  std::vector<geo::Point_t> points {
    geo::Point_t(1., 2., 3.),
    geo::Point_t(2., 4., 6.),
    geo::Point_t(3., 6., 9.)
  };
  TVector3 another(expected.X(), expected.Y(), expected.Z());

  //
  // sequence constructor
  //
  geo::vect::MiddlePointAccumulator acc(points.begin(), points.end());
  BOOST_TEST(!acc.empty());
  CheckPoint(acc.middlePoint(), expected, "Sequence construction");
  // add another one
  acc.add(another);
  BOOST_TEST(!acc.empty());
  CheckPoint(acc.middlePoint(), expected, "Sequence construction plus single");

} // test_MiddlePointAccumulator_sequenceConstructor()

void test_middlePointAs_documentation

(

)

Definition at line 328 of file geo_vectors_utils_test.cc.

                                        {

  /*
   * std::vector<geo::Point_t> points {
   *   geo::Point_t(1., 2., 3.),
   *   geo::Point_t(2., 4., 6.),
   *   geo::Point_t(3., 6., 9.)
   *   };
   * auto mp = geo::vect::middlePointAs<geo::Vector_t>(points.begin(), points.end());
   */
  std::vector<geo::Point_t> points {
    geo::Point_t(1., 2., 3.),
    geo::Point_t(2., 4., 6.),
    geo::Point_t(3., 6., 9.)
    };
  auto mp = geo::vect::middlePointAs<geo::Vector_t>(points.begin(), points.end());

  static_assert(std::is_same<std::decay_t<decltype(mp)>, geo::Vector_t>::value,
    "geo::vect::middlePointAs<geo::Vector_t> result is not geo::Vector_t");
  CheckPoint(mp, geo::Vector_t(2., 4., 6.));

} // test_middlePointAs_documentation()

template<typename Vector >

void test_transform

(

)

Definition at line 867 of file geo_vectors_utils_test.cc.

                      {

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<float, 5U> data {{ 4.0, 5.0, 7.0, 11.0, 15.5 }};
  auto const v = geo::vect::makeFromCoords<Vector>(data);

  auto const neg_v = geo::vect::transformCoords(v, [](auto c){ return -c; });
  static_assert
    (std::is_same<decltype(neg_v), decltype(v)>(), "Unexpected return type");
  BOOST_TEST(neg_v == -v);

} // test_transform()

template<typename Source , typename Dest >

void test_vector2Dconvert

(

)

Definition at line 757 of file geo_vectors_utils_test.cc.

                            {

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<double, 4U> srcData {{ 1.0, 5.0, 9.0, 16.0 }};

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  // Source const src{ srcData[0], srcData[1] };
  Source srcForClangBug;
  if constexpr (util::is_STLarray_v<Source>)
    srcForClangBug = Source{{ srcData[0], srcData[1] }};
  else
    srcForClangBug = Source{ srcData[0], srcData[1] };
  Source const src { srcForClangBug };

  auto dest = geo::vect::convertTo<Dest>(src);

  static_assert
    (std::is_same<decltype(dest), Dest>(), "Unexpected return type!");

  BOOST_TEST(geo::vect::Xcoord(dest) == srcData[0]);
  BOOST_TEST(geo::vect::Ycoord(dest) == srcData[1]);

} // test_vector2Dconvert()

template<typename Source , typename Dest >

void test_vector3Dconvert

(

)

Definition at line 786 of file geo_vectors_utils_test.cc.

                            {

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<double, 4U> srcData {{ 1.0, 5.0, 9.0, 16.0 }};

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  // Source const src{ srcData[0], srcData[1], srcData[2] };
  Source srcForClangBug;
  if constexpr (util::is_STLarray_v<Source>)
    srcForClangBug = Source{{ srcData[0], srcData[1], srcData[2] }};
  else
    srcForClangBug = Source{ srcData[0], srcData[1], srcData[2] };
  Source const src { srcForClangBug };

  auto dest = geo::vect::convertTo<Dest>(src);

  static_assert
    (std::is_same<decltype(dest), Dest>(), "Unexpected return type!");

  BOOST_TEST(geo::vect::Xcoord(dest) == srcData[0]);
  BOOST_TEST(geo::vect::Ycoord(dest) == srcData[1]);
  BOOST_TEST(geo::vect::Zcoord(dest) == srcData[2]);

} // test_vector3Dconvert()

template<typename Source , typename Dest >

void test_vector4Dconvert

(

)

Definition at line 816 of file geo_vectors_utils_test.cc.

                            {

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  std::array<double, 4U> srcData {{ 1.0, 5.0, 9.0, 16.0 }};

  // BUG the double brace syntax is required to work around clang bug 21629
  // (https://bugs.llvm.org/show_bug.cgi?id=21629)
  // Source const src{ srcData[0], srcData[1], srcData[2], srcData[3] };
  Source srcForClangBug;
  if constexpr (util::is_STLarray_v<Source>)
    srcForClangBug = Source{{ srcData[0], srcData[1], srcData[2], srcData[3] }};
  else
    srcForClangBug = Source{ srcData[0], srcData[1], srcData[2], srcData[3] };
  Source const src { srcForClangBug };


  auto dest = geo::vect::convertTo<Dest>(src);

  static_assert
    (std::is_same<decltype(dest), Dest>(), "Unexpected return type!");

  BOOST_TEST(geo::vect::Xcoord(dest) == srcData[0]);
  BOOST_TEST(geo::vect::Ycoord(dest) == srcData[1]);
  BOOST_TEST(geo::vect::Zcoord(dest) == srcData[2]);
  BOOST_TEST(geo::vect::Tcoord(dest) == srcData[3]);

} // test_vector4Dconvert()

template<typename Vector >

void test_vectorProcessing

(

)

Definition at line 748 of file geo_vectors_utils_test.cc.

                             {

  (void) IsfiniteTester<Vector>();

} // test_vectorProcessing()

void test_XcoordManager_documentation

(

)

Definition at line 883 of file geo_vectors_utils_test.cc.

                                        {
  std::ostringstream expected, out;
  /*
   * // constant vectors get a "reader" (read-only manager):
   * geo::Vector_t v { 1.0, 2.0, 3.0 };
   *
   * auto vx = geo::vect::bindCoord(v, geo::vect::XcoordManager<geo::Vector_t const>);
   * std::cout << v << " has x=" << vx() << std::endl;
   */

  // constant vectors get a "reader" (read-only manager):
  geo::Vector_t v { 1.0, 2.0, 3.0 };

  auto vx = geo::vect::bindCoord(v, geo::vect::XcoordManager<geo::Vector_t const>);
  std::cout << v << " has x=" << vx() << std::endl;
  out << v << " has x=" << vx();
  expected << v << " has x=" << v.X();

  BOOST_TEST(out.str() == expected.str());

  out.str("");
  expected.str("");
  /*
   * // mutable vectors get a full-featured "manager":
   * geo::Point_t p { 1.0, 2.0, 3.0 };
   * auto px = geo::vect::bindCoord(p, geo::vect::XcoordManager<geo::Point_t>);
   * px *= 5.0;
   * std::cout << p << " has now x=" << px() << std::endl;
   */

  // mutable vectors get a full-featured "manager":
  geo::Point_t p { 1.0, 2.0, 3.0 };
  auto px = geo::vect::bindCoord(p, geo::vect::XcoordManager<geo::Point_t>);
  px *= 5.0;
  std::cout << p << " has now x=" << px() << std::endl;
  out << p << " has now x=" << px();
  expected << p << " has now x=" << p.X();

  BOOST_TEST(out.str() == expected.str());

} // test_XcoordManager_documentation()