38 #include <visp3/core/vpConfig.h>
40 #ifdef VISP_HAVE_CATCH2
41 #define CATCH_CONFIG_ENABLE_BENCHMARKING
42 #define CATCH_CONFIG_RUNNER
45 #include <visp3/core/vpColVector.h>
47 #ifdef ENABLE_VISP_NAMESPACE
53 static bool g_runBenchmark =
false;
54 static const std::vector<unsigned int> g_sizes = { 23, 127, 233, 419, 1153, 2749 };
56 double getRandomValues(
double min,
double max) {
return (max - min) * ((double)rand() / (double)RAND_MAX) + min; }
58 vpColVector generateRandomVector(
unsigned int rows,
double min = -100,
double max = 100)
62 for (
unsigned int i = 0; i < v.getRows(); i++) {
63 v[i] = getRandomValues(min, max);
69 double stddev(
const std::vector<double> &vec)
71 double sum = std::accumulate(vec.begin(), vec.end(), 0.0);
72 double mean = sum / vec.size();
74 std::vector<double> diff(vec.size());
75 std::transform(vec.begin(), vec.end(), diff.begin(), [mean](
double x) {
77 double sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0);
78 return std::sqrt(sq_sum / vec.size());
85 for (
unsigned int i = 0; i < v.
getRows(); i++) {
92 double computeRegularSumSquare(
const vpColVector &v)
94 double sum_square = 0.0;
96 for (
unsigned int i = 0; i < v.
getRows(); i++) {
97 sum_square += v[i] * v[i];
105 double mean_value = computeRegularSum(v) / v.
getRows();
106 double sum_squared_diff = 0.0;
108 for (
unsigned int i = 0; i < v.
size(); i++) {
109 sum_squared_diff += (v[i] - mean_value) * (v[i] - mean_value);
112 double divisor = (double)v.
size();
114 return std::sqrt(sum_squared_diff / divisor);
117 std::vector<double> computeHadamard(
const std::vector<double> &v1,
const std::vector<double> &v2)
119 std::vector<double> result;
120 std::transform(v1.begin(), v1.end(), v2.begin(), std::back_inserter(result), std::multiplies<double>());
130 for (
unsigned int i = 0; i < v1.
getRows(); i++) {
140 TEST_CASE(
"Benchmark vpColVector::sum()",
"[benchmark]")
144 const double val = 11;
146 CHECK(v.
sum() == Approx(val).epsilon(std::numeric_limits<double>::epsilon()));
149 const unsigned int size = 11;
150 std::vector<double> vec(size);
152 for (
size_t i = 0; i < 11; i++) {
154 v[
static_cast<unsigned int>(i)] = vec[i];
157 Approx(std::accumulate(vec.begin(), vec.end(), 0.0)).epsilon(std::numeric_limits<double>::epsilon()));
160 if (g_runBenchmark) {
161 for (
auto size : g_sizes) {
165 std::ostringstream oss;
166 oss <<
"Benchmark vpColVector::sum() with size: " << size <<
" (ViSP)";
168 BENCHMARK(oss.str().c_str())
175 oss <<
"Benchmark std::accumulate() with size: " << size <<
" (C++)";
177 BENCHMARK(oss.str().c_str())
179 std_sum = std::accumulate(vec.begin(), vec.end(), 0.0);
182 CHECK(vp_sum == Approx(std_sum));
185 oss <<
"Benchmark naive sum() with size: " << size;
186 double naive_sum = 0;
187 BENCHMARK(oss.str().c_str())
189 naive_sum = computeRegularSum(v);
192 CHECK(naive_sum == Approx(std_sum));
197 TEST_CASE(
"Benchmark vpColVector::sumSquare()",
"[benchmark]")
201 const double val = 11;
203 CHECK(v.
sumSquare() == Approx(val * val).epsilon(std::numeric_limits<double>::epsilon()));
206 const unsigned int size = 11;
207 std::vector<double> vec(size);
209 for (
size_t i = 0; i < 11; i++) {
211 v[
static_cast<unsigned int>(i)] = vec[i];
213 CHECK(v.
sumSquare() == Approx(std::inner_product(vec.begin(), vec.end(), vec.begin(), 0.0))
214 .epsilon(std::numeric_limits<double>::epsilon()));
217 if (g_runBenchmark) {
218 for (
auto size : g_sizes) {
222 std::ostringstream oss;
223 oss <<
"Benchmark vpColVector::sumSquare() with size: " << size <<
" (ViSP)";
224 double vp_sq_sum = 0;
225 BENCHMARK(oss.str().c_str())
232 oss <<
"Benchmark std::inner_product with size: " << size <<
" (C++)";
233 double std_sq_sum = 0;
234 BENCHMARK(oss.str().c_str())
236 std_sq_sum = std::inner_product(vec.begin(), vec.end(), vec.begin(), 0.0);
239 CHECK(vp_sq_sum == Approx(std_sq_sum));
242 oss <<
"Benchmark naive sumSquare() with size: " << size;
243 double naive_sq_sum = 0;
244 BENCHMARK(oss.str().c_str())
246 naive_sq_sum = computeRegularSumSquare(v);
249 CHECK(naive_sq_sum == Approx(std_sq_sum));
254 TEST_CASE(
"Benchmark vpColVector::stdev()",
"[benchmark]")
262 CHECK(
vpColVector::stdev(v) == Approx(stddev(vec)).epsilon(std::numeric_limits<double>::epsilon()));
265 const unsigned int size = 11;
266 std::vector<double> vec(size);
268 for (
size_t i = 0; i < 11; i++) {
270 v[
static_cast<unsigned int>(i)] = vec[i];
272 CHECK(
vpColVector::stdev(v) == Approx(stddev(vec)).epsilon(std::numeric_limits<double>::epsilon()));
275 if (g_runBenchmark) {
276 for (
auto size : g_sizes) {
280 std::ostringstream oss;
281 oss <<
"Benchmark vpColVector::stdev() with size: " << size <<
" (ViSP)";
282 double vp_stddev = 0;
283 BENCHMARK(oss.str().c_str())
290 oss <<
"Benchmark C++ stddev impl with size: " << size <<
" (C++)";
291 double std_stddev = 0;
292 BENCHMARK(oss.str().c_str())
294 std_stddev = stddev(vec);
297 CHECK(vp_stddev == Approx(std_stddev));
300 oss <<
"Benchmark naive stdev() with size: " << size;
301 double naive_stddev = 0;
302 BENCHMARK(oss.str().c_str())
304 naive_stddev = computeRegularStdev(v);
307 CHECK(naive_stddev == Approx(std_stddev));
312 TEST_CASE(
"Benchmark vpColVector::hadamard()",
"[benchmark]")
323 CHECK(almostEqual(res1, res2));
326 const unsigned int size = 11;
327 std::vector<double> vec1(size), vec2(size);
328 for (
size_t i = 0; i < 11; i++) {
330 vec2[i] = 3. * i + 5.;
335 CHECK(almostEqual(res1, res2));
338 if (g_runBenchmark) {
339 for (
auto size : g_sizes) {
345 std::ostringstream oss;
346 oss <<
"Benchmark vpColVector::hadamard() with size: " << size <<
" (ViSP)";
348 BENCHMARK(oss.str().c_str())
355 oss <<
"Benchmark C++ element wise multiplication with size: " << size <<
" (C++)";
356 std::vector<double> std_res;
357 BENCHMARK(oss.str().c_str())
359 std_res = computeHadamard(vec1, vec2);
367 int main(
int argc,
char *argv[])
374 Catch::Session session;
377 using namespace Catch::clara;
378 auto cli = session.cli()
379 | Opt(g_runBenchmark)
387 session.applyCommandLine(argc, argv);
389 int numFailed = session.run();
399 int main() {
return EXIT_SUCCESS; }
unsigned int size() const
Return the number of elements of the 2D array.
unsigned int getRows() const
Implementation of column vector and the associated operations.
vpColVector hadamard(const vpColVector &v) const
std::vector< double > toStdVector() const
static double stdev(const vpColVector &v, bool useBesselCorrection=false)
static bool equal(double x, double y, double threshold=0.001)