detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-23 01:58:00 +02:00
Code Issues Actions Packages Releases Activity

trimEn now takes vector

Browse Source
This commit is contained in:
Erik Frojdh
2019-04-04 12:19:30 +02:00
parent c284b24397
commit 85516e42c0
14 changed files with 318 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
slsSupportLib/include/container_utils.h
View File

@ -2,17 +2,15 @@
#define CONTAINER_UTILS_H
#include <algorithm>
#include <memory>
#include <numeric>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
#include <sstream>
#include <memory>
namespace sls {
// C++11 make_unique implementation for exception safety
// already available as std::make_unique in C++14
template <typename T, typename... Args>
@ -23,94 +21,88 @@ make_unique(Args &&... args) {
template <typename T>
typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
make_unique(std::size_t n)
{
make_unique(std::size_t n) {
typedef typename std::remove_extent<T>::type RT;
return std::unique_ptr<T>(new RT[n]);
}
template <typename T>
bool allEqual(const std::vector<T>& container)
{
template <typename T> bool allEqual(const std::vector<T> &container) {
if (container.empty())
return false;
const auto& first = container[0];
const auto &first = container[0];
return std::all_of(container.cbegin(), container.cend(),
[first](const T& element) { return element == first; });
[first](const T &element) { return element == first; });
}
template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
allEqualWithTol(const std::vector<T>& container, const T tol)
{
allEqualWithTol(const std::vector<T> &container, const T tol) {
if (container.empty())
return false;
const auto& first = container[0];
const auto &first = container[0];
return std::all_of(container.cbegin(), container.cend(),
[first, tol](const T& element) {
return (std::abs(element - first) < tol);
});
[first, tol](const T &element) {
return (std::abs(element - first) < tol);
});
}
template <typename T>
bool allEqualTo(const std::vector<T>& container, const T value)
{
bool allEqualTo(const std::vector<T> &container, const T value) {
if (container.empty())
return false;
return std::all_of(container.cbegin(), container.cend(),
[value](const T& element) { return element == value; });
[value](const T &element) { return element == value; });
}
template <typename T>
bool allEqualToWithTol(const std::vector<T>& container, const T value,
const T tol)
{
bool allEqualToWithTol(const std::vector<T> &container, const T value,
const T tol) {
if (container.empty())
return false;
return std::all_of(container.cbegin(), container.cend(),
[value, tol](const T& element) {
return (std::abs(element - value) < tol);
});
[value, tol](const T &element) {
return (std::abs(element - value) < tol);
});
}
template <typename T>
bool anyEqualTo(const std::vector<T>& container, const T value)
{
bool anyEqualTo(const std::vector<T> &container, const T value) {
return std::any_of(container.cbegin(), container.cend(),
[value](const T& element) { return element == value; });
[value](const T &element) { return element == value; });
}
template <typename T>
bool anyEqualToWithTol(const std::vector<T>& container, const T value,
const T tol)
{
bool anyEqualToWithTol(const std::vector<T> &container, const T value,
const T tol) {
return std::any_of(container.cbegin(), container.cend(),
[value, tol](const T& element) { return (std::abs(element - value) < tol); });
[value, tol](const T &element) {
return (std::abs(element - value) < tol);
});
}
template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
sum(const std::vector<T>& container)
{
return std::accumulate(container.cbegin(), container.cend(), T{ 0 });
sum(const std::vector<T> &container) {
return std::accumulate(container.cbegin(), container.cend(), T{0});
}
template <typename T> T minusOneIfDifferent(const std::vector<T> &container) {
if (allEqual(container))
return container.front();
return static_cast<T>(-1);
}
template <typename T>
T minusOneIfDifferent(const std::vector<T>& container)
{
if (allEqual(container)) {
std::vector<T>
minusOneIfDifferent(const std::vector<std::vector<T>> &container) {
if (allEqual(container))
return container.front();
} else {
return static_cast<T>(-1);
}
return std::vector<T>{-1};
}
} // namespace sls
#endif // CONTAINER_UTILS_H

11
slsSupportLib/src/string_utils.cpp
View File

@ -47,17 +47,8 @@ std::string concatenateIfDifferent(const std::vector<T> &container) {
}
}
template std::string concatenateIfDifferent(const std::vector<IpAddr> &);
template std::string concatenateIfDifferent(const std::vector<MacAddr> &);
std::string stringIpToHex(const std::string &ip) {
std::istringstream iss(ip);
std::ostringstream oss;
std::string item;
while (std::getline(iss, item, '.')) {
oss << std::setw(2) << std::setfill('0') << std::hex << std::stoi(item);
}
return oss.str();
}
}; // namespace sls

186
slsSupportLib/tests/test-container_utils.cpp
View File

@ -4,103 +4,111 @@
#include <string>
#include <vector>
using sls::allEqual;
using sls::allEqualTo;
using sls::anyEqualTo;
using sls::allEqualToWithTol;
using sls::allEqualWithTol;
using sls::anyEqualToWithTol;
using namespace sls;
using sls::sum;
TEST_CASE("Equality of an empty vector") {
std::vector<int> v;
REQUIRE(v.empty());
REQUIRE_FALSE(allEqual(v));
REQUIRE_FALSE(allEqualWithTol(v, 2));
REQUIRE_FALSE(allEqualTo(v, 5));
REQUIRE_FALSE(anyEqualTo(v, 5));
REQUIRE_FALSE(anyEqualToWithTol(v, 5, 1));
}
TEST_CASE("Equality of a vector with one element") {
std::vector<int> v{5};
REQUIRE(v.size() == 1);
REQUIRE(allEqual(v));
REQUIRE(allEqualWithTol(v, 1));
REQUIRE(allEqualTo(v, 5));
REQUIRE(allEqualToWithTol(v, 5, 2));
REQUIRE(anyEqualTo(v, 5));
REQUIRE(anyEqualToWithTol(v, 5, 1));
}
TEST_CASE("A larger vector of the same elements") {
std::vector<int> v(101, 5);
REQUIRE(v.size() == 101);
REQUIRE(allEqual(v));
REQUIRE(allEqualWithTol(v, 1));
REQUIRE(allEqualTo(v, 5));
REQUIRE(anyEqualTo(v, 5));
SECTION(
"Push back another element to create a vector where not all are equal") {
v.push_back(7);
REQUIRE(v.size() == 102);
TEST_CASE("Equality of an empty vector", "[support]") {
std::vector<int> v;
REQUIRE(v.empty());
REQUIRE_FALSE(allEqual(v));
REQUIRE_FALSE(allEqualWithTol(v, 1));
REQUIRE(allEqualWithTol(v, 3));
REQUIRE_FALSE(allEqualWithTol(v, 2));
REQUIRE_FALSE(allEqualTo(v, 5));
REQUIRE_FALSE(allEqualToWithTol(v, 5, 1));
REQUIRE(allEqualToWithTol(v, 5, 3));
REQUIRE(anyEqualTo(v, 5));
}
REQUIRE_FALSE(anyEqualTo(v, 5));
REQUIRE_FALSE(anyEqualToWithTol(v, 5, 1));
}
TEST_CASE("A vector of double with different values") {
std::vector<double> v{1.2, 2., 4.2, 4, 1.1};
REQUIRE(allEqual(v) == false);
REQUIRE(allEqualWithTol(v, 0.3) == false);
REQUIRE(allEqualWithTol(v, 3.2));
}
TEST_CASE("Sum of empty vector") {
std::vector<float> v;
REQUIRE(sls::sum(v) == Approx(0));
}
TEST_CASE("Sum of vector") {
std::vector<double> v{1.2, 2., 4.2, 4, 1.13};
REQUIRE(sls::sum(v) == Approx(12.53));
}
TEST_CASE("Minus one if different") {
std::vector<double> v;
REQUIRE(v.empty());
double d = -1;
REQUIRE(sls::minusOneIfDifferent(v) == d);
SECTION("single element") {
v.push_back(7.3);
TEST_CASE("Equality of a vector with one element", "[support]") {
std::vector<int> v{5};
REQUIRE(v.size() == 1);
REQUIRE(sls::minusOneIfDifferent(v) == Approx(7.3));
}
SECTION("different elements") {
v.push_back(7.3);
v.push_back(1.0);
v.push_back(62.1);
REQUIRE(sls::minusOneIfDifferent(v) == Approx(-1.0));
}
REQUIRE(allEqual(v));
REQUIRE(allEqualWithTol(v, 1));
REQUIRE(allEqualTo(v, 5));
REQUIRE(allEqualToWithTol(v, 5, 2));
REQUIRE(anyEqualTo(v, 5));
REQUIRE(anyEqualToWithTol(v, 5, 1));
}
TEST_CASE("minus one does not have side effects"){
std::vector<int> v{1,1,1};
TEST_CASE("A larger vector of the same elements", "[support]") {
std::vector<int> v(101, 5);
REQUIRE(v.size() == 101);
REQUIRE(allEqual(v));
REQUIRE(allEqualWithTol(v, 1));
REQUIRE(allEqualTo(v, 5));
REQUIRE(anyEqualTo(v, 5));
SECTION("Push back another element to create a vector where not all are "
"equal") {
v.push_back(7);
REQUIRE(v.size() == 102);
REQUIRE_FALSE(allEqual(v));
REQUIRE_FALSE(allEqualWithTol(v, 1));
REQUIRE(allEqualWithTol(v, 3));
REQUIRE_FALSE(allEqualTo(v, 5));
REQUIRE_FALSE(allEqualToWithTol(v, 5, 1));
REQUIRE(allEqualToWithTol(v, 5, 3));
REQUIRE(anyEqualTo(v, 5));
}
}
TEST_CASE("A vector of double with different values", "[support]") {
std::vector<double> v{1.2, 2., 4.2, 4, 1.1};
REQUIRE(allEqual(v) == false);
REQUIRE(allEqualWithTol(v, 0.3) == false);
REQUIRE(allEqualWithTol(v, 3.2));
}
TEST_CASE("Sum of empty vector", "[support]") {
std::vector<float> v;
REQUIRE(sls::sum(v) == Approx(0));
}
TEST_CASE("Sum of vector", "[support]") {
std::vector<double> v{1.2, 2., 4.2, 4, 1.13};
REQUIRE(sls::sum(v) == Approx(12.53));
}
TEST_CASE("Minus one if different", "[support]") {
std::vector<double> v;
REQUIRE(v.empty());
double d = -1;
REQUIRE(sls::minusOneIfDifferent(v) == d);
SECTION("single element") {
v.push_back(7.3);
REQUIRE(v.size() == 1);
REQUIRE(sls::minusOneIfDifferent(v) == Approx(7.3));
}
SECTION("different elements") {
v.push_back(7.3);
v.push_back(1.0);
v.push_back(62.1);
REQUIRE(sls::minusOneIfDifferent(v) == Approx(-1.0));
}
}
TEST_CASE("minus one does not have side effects", "[support]") {
std::vector<int> v{1, 1, 1};
int i = sls::minusOneIfDifferent(v);
REQUIRE(i==1);
i=5;
REQUIRE(v[0]==1);
REQUIRE(i == 1);
i = 5;
REQUIRE(v[0] == 1);
}
TEST_CASE("Compare a vector containing two vectors", "[support]") {
std::vector<std::vector<int>> a{{0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 4, 5}};
std::vector<std::vector<int>> b{{0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 3, 5}};
std::vector<std::vector<int>> c{{0, 1, 2, 3, 4}, {0, 1, 2, 3, 3, 5}};
std::vector<std::vector<int>> d{
{0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}};
std::vector<int> e{0, 1, 2, 3, 4, 5};
CHECK(minusOneIfDifferent(a) == a[0]);
CHECK(minusOneIfDifferent(a) == e);
CHECK(minusOneIfDifferent(b) == std::vector<int>{-1});
CHECK(minusOneIfDifferent(c) == std::vector<int>{-1});
CHECK(minusOneIfDifferent(d) == d[2]);
}

5
slsSupportLib/tests/test-string_utils.cpp
View File

@ -90,11 +90,6 @@ TEST_CASE("concatenate non empty strings with one element"){
REQUIRE(ret=="hej+");
}
TEST_CASE("Convert ip address"){
std::string address = "101.255.103.1";
REQUIRE(sls::stringIpToHex(address) == "65ff6701");
}
TEST_CASE("Remove char from string"){
char str[] = "sometest";

3
slsSupportLib/tests/test.cpp
View File

@ -1,3 +0,0 @@
// tests-main.cpp
#define CATCH_CONFIG_MAIN
#include "catch.hpp"