From 418f66e7ee6861769da33ee6e61837a8cdec5c80 Mon Sep 17 00:00:00 2001 From: "Dipl.-Phys. Frank Haferkorn" Date: Mon, 23 May 2022 07:39:26 +0200 Subject: [PATCH] minor, misc changes - added std-viiew-iota iteart - all test give out "..DONE" at end of Tesr --- cxxloop.alternatives/CMakeLists.txt | 10 + .../std-view-iota/CMakeLists.txt | 32 +++ cxxloop.alternatives/std-view-iota/README.md | 9 + .../std-view-iota/view-iota.cpp | 67 ++++++ .../asciishapes/CMakeLists.txt | 2 +- .../using-loop-postops/CMakeLists.txt | 2 +- .../asciishapes/using-loop/CMakeLists.txt | 2 +- .../cxxloop.examples/matrix/main_matrix.cpp | 5 +- .../cxxloop.examples/matrix/matrix.hpp | 28 ++- cxxloop.tests/testing-loops/CMakeLists.txt | 5 + cxxloop.tests/testing-loops/macro.h | 18 +- .../test_cxxloop_macros.cpp | 85 ++++++-- .../test_cxxloop_macros_postops.cpp | 42 ++-- .../test_cxxloop_postops.cpp | 62 ++++-- .../test_cxxloop_slice/CMakeLists.txt | 22 ++ .../test_cxxloop_slice/test_cxxloop_slice.cpp | 194 ++++++++++++++++++ .../test_cxxloop_templates.cpp | 152 ++++++++++++-- .../CMakeLists.txt | 4 +- ...cpp => test_cxxloop_templates_postops.cpp} | 140 ++++++++++++- cxxloop/CMakeLists.txt | 5 + cxxloop/include/cxxloop.h | 27 ++- cxxloop/include/cxxloop_postops.h | 18 +- cxxloop/include/cxxloop_prereqs.h | 92 ++++++--- cxxloop/include/loop.h | 5 +- qtcsettings.cmake | 2 + 25 files changed, 866 insertions(+), 164 deletions(-) create mode 100644 cxxloop.alternatives/CMakeLists.txt create mode 100644 cxxloop.alternatives/std-view-iota/CMakeLists.txt create mode 100644 cxxloop.alternatives/std-view-iota/README.md create mode 100644 cxxloop.alternatives/std-view-iota/view-iota.cpp create mode 100644 cxxloop.tests/testing-loops/test_cxxloop_slice/CMakeLists.txt create mode 100644 cxxloop.tests/testing-loops/test_cxxloop_slice/test_cxxloop_slice.cpp rename cxxloop.tests/testing-loops/test_cxxloop_templates_postops/{test_cxxloop_templates.cpp => test_cxxloop_templates_postops.cpp} (68%) create mode 100644 qtcsettings.cmake diff --git a/cxxloop.alternatives/CMakeLists.txt b/cxxloop.alternatives/CMakeLists.txt new file mode 100644 index 0000000..3e9fde2 --- /dev/null +++ b/cxxloop.alternatives/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required(VERSION 3.18 FATAL_ERROR) + +project(ogis-cxx-loop.example LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED YES) + + +add_subdirectory(asciishapes) +add_subdirectory(matrix) diff --git a/cxxloop.alternatives/std-view-iota/CMakeLists.txt b/cxxloop.alternatives/std-view-iota/CMakeLists.txt new file mode 100644 index 0000000..72ed1b1 --- /dev/null +++ b/cxxloop.alternatives/std-view-iota/CMakeLists.txt @@ -0,0 +1,32 @@ +cmake_minimum_required(VERSION 3.18 FATAL_ERROR) + +set(THE_PROJECT cxxloop-alternative-view-iota) + +project(${THE_PROJECT} LANGUAGES CXX) + + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED YES) + +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + +# Input +set(MATRIX_HDR matrix.hpp matrix_io.hpp) +set(MATRIX_SRC example_matrix.cpp main_matrix.cpp ) + + +add_executable(${THE_PROJECT} ${MATRIX_HDR} ${MATRIX_SRC} ) +target_link_libraries(${THE_PROJECT} cxxloop) + +target_include_directories(${THE_PROJECT} PRIVATE + $ + $ +) + + diff --git a/cxxloop.alternatives/std-view-iota/README.md b/cxxloop.alternatives/std-view-iota/README.md new file mode 100644 index 0000000..b5e318b --- /dev/null +++ b/cxxloop.alternatives/std-view-iota/README.md @@ -0,0 +1,9 @@ +## Matrix-Examples for the Compound-Group "LOOP" ## + +- [main_matrix.cpp](main_matrix.cpp) : is the main entry point. + +- [matrix.hpp](matrix.hpp) : Header-only functions to operate on the matrcies as descrtibed above using LOOP-compounds. + +- [matrix_io.hpp](matrix_io.hpp) : Contains functions to print native double 2D-Arrays (matrices like double a[M][N]) of given size N x M. +- [example_matrix.cpp](example_matrix.cpp) : example calls to the functions of matrix.hpp and matrix_io.hpp. Is invoked by main.cpp. + diff --git a/cxxloop.alternatives/std-view-iota/view-iota.cpp b/cxxloop.alternatives/std-view-iota/view-iota.cpp new file mode 100644 index 0000000..af197c6 --- /dev/null +++ b/cxxloop.alternatives/std-view-iota/view-iota.cpp @@ -0,0 +1,67 @@ +#include +#include + +#include "matrix.hpp" +#include "matrix_io.hpp" + +void example_matrix() { + + const int N = 4; // number-of rows + const int M = 10; // number-of columns + + int A[N][M] = {}; + int B[N * M] = {}; + int C[N * M] = {}; + + int *a = &A[0][0]; + { + matrix_set(a, 1, N, M); + + std::cout << std::endl << "A" << std::endl; + matrix_print(a, N, M); + + matrix_set(B, 0, N, M); + std::cout << std::endl << "B" << std::endl; + matrix_print(B, N, M); + + std::cout << std::endl << "C" << std::endl; + matrix_set(C, 2, N, M); + matrix_print(C, N, M); + } + + loop(2) { + std::cout << std::endl << "C+=A" << std::endl; + matrix_add(C, a, N, M); + matrix_print(C, N, M); + } + + { + std::cout << std::endl << "B=C" << std::endl; + matrix_copy(B, C, N, M); + matrix_print(B, N, M); + } + + { + std::cout << std::endl << "C+=B" << std::endl; + matrix_add(C, B, N, M); + matrix_print(C, N, M); + } + + { + int n = N / 2; + int m = M / 2; + std::cout << std::endl + << "C[0:" << n - 1 << "][0:" << m - 1 << "]+=10" << std::endl; + matrix_incr_w_stride(C, 10, n, m, M - m); + matrix_print(C, N, M); + } + + { + int n = N / 2 + 1; + int m = M / 2 + 1; + std::cout << std::endl + << "C[0:" << n - 1 << "][0:" << m - 1 << "]+=100" << std::endl; + matrix_incr_w_stride(C, 100, n, m, M - m); + matrix_print(C, N, M); + } +} diff --git a/cxxloop.examples/cxxloop.examples/asciishapes/CMakeLists.txt b/cxxloop.examples/cxxloop.examples/asciishapes/CMakeLists.txt index 714dc85..551f19f 100644 --- a/cxxloop.examples/cxxloop.examples/asciishapes/CMakeLists.txt +++ b/cxxloop.examples/cxxloop.examples/asciishapes/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.18 FATAL_ERROR) -project(ogis-cxxloop-ascciishapes LANGUAGES CXX) +project(ogis-cxxloop-examples-ascciishapes LANGUAGES CXX) #set(CMAKE_CXX_STANDARD 11) #set(CMAKE_CXX_STANDARD_REQUIRED NO) diff --git a/cxxloop.examples/cxxloop.examples/asciishapes/using-loop-postops/CMakeLists.txt b/cxxloop.examples/cxxloop.examples/asciishapes/using-loop-postops/CMakeLists.txt index eb97c54..64ea530 100644 --- a/cxxloop.examples/cxxloop.examples/asciishapes/using-loop-postops/CMakeLists.txt +++ b/cxxloop.examples/cxxloop.examples/asciishapes/using-loop-postops/CMakeLists.txt @@ -10,7 +10,7 @@ set(FILES cmake_minimum_required(VERSION 3.18 FATAL_ERROR) -set(THE_PROJECT cxxloop-asciishapes-for-postops) +set(THE_PROJECT cxxloop-examples-asciishapes-loop-postops) #set(CMAKE_CXX_STANDARD ${CXXLOOP_CXX_STANDARD}) #set(CMAKE_CXX_STANDARD_REQUIRED ${CXXLOOP_CXX_STANDARD_REQUIRED}) diff --git a/cxxloop.examples/cxxloop.examples/asciishapes/using-loop/CMakeLists.txt b/cxxloop.examples/cxxloop.examples/asciishapes/using-loop/CMakeLists.txt index 48a6f10..bad33ee 100644 --- a/cxxloop.examples/cxxloop.examples/asciishapes/using-loop/CMakeLists.txt +++ b/cxxloop.examples/cxxloop.examples/asciishapes/using-loop/CMakeLists.txt @@ -7,7 +7,7 @@ set(FILES main.cpp ) -set(THE_PROJECT cxxloop-asciishapes-loop) +set(THE_PROJECT cxxloop-examples-asciishapes-loop) #set(CMAKE_CXX_STANDARD 11) #set(CMAKE_CXX_STANDARD_REQUIRED NO) diff --git a/cxxloop.examples/cxxloop.examples/matrix/main_matrix.cpp b/cxxloop.examples/cxxloop.examples/matrix/main_matrix.cpp index 0ec92d7..cfe3a22 100644 --- a/cxxloop.examples/cxxloop.examples/matrix/main_matrix.cpp +++ b/cxxloop.examples/cxxloop.examples/matrix/main_matrix.cpp @@ -7,8 +7,9 @@ void example_matrix(); int main() { - // some more realistic examples of matrix operations - // using the new compound-statement + std::cout << "############ matrix-exammples " << std::endl; example_matrix(); + std::cout << "..DONE" << std ::endl; + return 0; } diff --git a/cxxloop.examples/cxxloop.examples/matrix/matrix.hpp b/cxxloop.examples/cxxloop.examples/matrix/matrix.hpp index 95a4566..4d9ddc2 100644 --- a/cxxloop.examples/cxxloop.examples/matrix/matrix.hpp +++ b/cxxloop.examples/cxxloop.examples/matrix/matrix.hpp @@ -49,15 +49,25 @@ inline void matrix_mpy(TTgtValuePtr tgt, TSrcAValuePtr srcA, TSrcBValuePtr srcB, auto pCol = srcA; auto pRow = srcB; - loop(nbofColums * nbofRows) // for each matrix element - loop_up_postops(nbofRows, row, pRow = srcB + row * nbofColums) - loop_postops(nbofColums, pRow += nbofColums) *tgt++ = - (*pCol++) * (*pRow); + loop(sizeA * sizeB) // for each matrix element + loop_up_postops(sizeB, row, pRow = srcB + row * sizeA) + loop_postops(sizeA, pRow += sizeA) *tgt++ = (*pCol++) * (*pRow); } -template -inline void dotproduct(TSize size, TValueA *pA, TValue *pB, - TIndexA indexA = char, TIndexA indexB = char) { - decltype(TValueA * TValueB) result = 0; - loop_postops(size, A += indexA, B += index) += (*pA++) * (*pB); +template +inline TValueTgt *dotproduct(TSize size, TValueTgt *tgt, TValueA *pA, + TValueB *pB) { + decltype(*pA * *pB) result = 0; + loop_postops(size, pA++, pB++, tgt++) tgt += (*pA) * (*pB); + return tgt; +} + +template +inline void dotproduct(TSize size, TValueA *pA, TValueB *pB, TIndexA indexA, + TIndexA indexB) { + decltype(*pA * *pB) result = 0; + loop_slice_postops(0, size, indexA, id, pB += indexB) result += + (*pA++) * (*pB); } diff --git a/cxxloop.tests/testing-loops/CMakeLists.txt b/cxxloop.tests/testing-loops/CMakeLists.txt index e5ddd1d..784d5f5 100644 --- a/cxxloop.tests/testing-loops/CMakeLists.txt +++ b/cxxloop.tests/testing-loops/CMakeLists.txt @@ -13,4 +13,9 @@ add_subdirectory(test_cxxloop) add_subdirectory(test_cxxloop_typed) #POSTOPS + add_subdirectory(test_cxxloop_postops) +add_subdirectory(test_cxxloop_templates_postops) + +#special +add_subdirectory(test_cxxloop_slice) diff --git a/cxxloop.tests/testing-loops/macro.h b/cxxloop.tests/testing-loops/macro.h index 2957e19..18f9319 100644 --- a/cxxloop.tests/testing-loops/macro.h +++ b/cxxloop.tests/testing-loops/macro.h @@ -1,14 +1,18 @@ #pragma once #include +#include -#define ASSERT_COUNTS(count, tobe_count) \ - if (count != tobe_count) \ - std::cout << __FUNCTION__ << "\t" << std::endl \ - << "\t" \ - << "count " << count << " is NOT the expeted: " << tobe_count \ - << std::endl +#define ASSERT_NOTED(as_is, to_be, text) \ + if (as_is != to_be) \ + std::cout << __FILE__ << "\n" \ + << __FUNCTION__ << "\t" << std::endl \ + << "\t" << text << "\t" << as_is \ + << " is NOT the expeted: " << to_be << std::endl + +#define ASSERT_COUNTS(as_is, to_be) ASSERT_NOTED(as_is, to_be, "count") inline void ASSERT_CONDITION(bool condition, const std::string &msg) { - if (!condition) std::cout << __FUNCTION__ << "\t" << msg << std::endl; + if (!condition) + std::cout << __FILE__ << "\n" << __FUNCTION__ << "\t" << msg << std::endl; return; } diff --git a/cxxloop.tests/testing-loops/test_cxxloop_macros/test_cxxloop_macros.cpp b/cxxloop.tests/testing-loops/test_cxxloop_macros/test_cxxloop_macros.cpp index 35d268f..86a1044 100644 --- a/cxxloop.tests/testing-loops/test_cxxloop_macros/test_cxxloop_macros.cpp +++ b/cxxloop.tests/testing-loops/test_cxxloop_macros/test_cxxloop_macros.cpp @@ -4,6 +4,33 @@ #include "../macro.h" namespace test_cxxloop_macros { +namespace { + +long long sumup_slice(std::slice slice) { + size_t sum = 0; + auto id = slice.start(); + loop_postops(slice.size(), id += slice.stride()) { sum += id; } + return sum; +} +size_t sumup_slice(size_t start, size_t size, size_t stride) { + auto slice = std::slice(start, size, stride); + return sumup_slice(slice); +} + +void test_loop_macro_slice_base(size_t start, size_t size, size_t stride) { + // std::cout << "CPPMACRO_SLICE(std::slice(" << start << "," << size << "," + // << stride << "), id) " << std::endl; + size_t sum = 0, count = 0; + CPPMACRO_SLICED(int, start, size, stride, id) { + count++; + sum += id; + } + ASSERT_COUNTS(count, size); + ASSERT_NOTED(sum, sumup_slice(std::slice(start, size, stride)), + "summup of ids"); +} +} // namespace + void test_loop_macro_NTIMES() { int count = 0; using T = int; @@ -21,19 +48,31 @@ void test_loop_macro_NTIMES() { ASSERT_COUNTS(count, 3000); } +void test_loop_macro_SLICE() { + int count = 0; + size_t sum = 0; + using T = int; + + CPPMACRO_SLICED(int, 10, 1000, 2, id) { count++; } + ASSERT_COUNTS(count, 1000); + + test_loop_macro_slice_base(0, 10, 2); + test_loop_macro_slice_base(10, 10, 5); +} + void test_loop_macro_LOOP() { int count = 0; count = 0; - CPPMACRO_LOOP(UP, 1000, id) count++; + CPPMACRO_LOOP(NTIMES_UP, 1000, id) count++; ASSERT_COUNTS(count, 1000); count = 0; - CPPMACRO_LOOP(DOWN, 2000, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, 2000, id) count++; ASSERT_COUNTS(count, 2000); count = 0; - CPPMACRO_LOOP(FASTEST, 3000, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, 3000, id) count++; ASSERT_COUNTS(count, 3000); } @@ -41,15 +80,15 @@ void test_loop_macro_LOOP_const() { int count = 0; const int N = 100; count = 0; - CPPMACRO_LOOP(UP, N, id) count++; + CPPMACRO_LOOP(NTIMES_UP, N, id) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP(DOWN, N, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, N, id) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP(FASTEST, N, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, N, id) count++; ASSERT_COUNTS(count, N); } @@ -58,15 +97,15 @@ void test_loop_macro_LOOP_expr() { const int N = 100; count = 0; - CPPMACRO_LOOP(UP, N + 1, id) count++; + CPPMACRO_LOOP(NTIMES_UP, N + 1, id) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP(DOWN, N + 1, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, N + 1, id) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP(FASTEST, N + 1, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, N + 1, id) count++; ASSERT_COUNTS(count, N + 1); } @@ -75,15 +114,15 @@ void test_loop_macro_LOOP_TYPED_const() { const int N = 100; count = 0; - CPPMACRO_LOOP_TYPED(UP, N, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, N, id, char) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, N, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, N, id, char) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, N, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, N, id, char) count++; ASSERT_COUNTS(count, N); } @@ -92,29 +131,29 @@ void test_loop_macro_LOOP_TYPED_expr() { const int N = 100; count = 0; - CPPMACRO_LOOP_TYPED(UP, N + 1, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, N + 1, id, char) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, N + 1, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, N + 1, id, char) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, N + 1, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, N + 1, id, char) count++; ASSERT_COUNTS(count, N + 1); } void test_loop_macro_LOOP_TYPED_char() { int count = 0; - CPPMACRO_LOOP_TYPED(UP, 10, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, 10, id, char) count++; ASSERT_COUNTS(count, 10); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, 20, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, 20, id, char) count++; ASSERT_COUNTS(count, 20); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, 30, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, 30, id, char) count++; ASSERT_COUNTS(count, 30); } @@ -122,21 +161,23 @@ void test_loop_macro_LOOP_TYPED_short() { int count = 0; count = 0; - CPPMACRO_LOOP_TYPED(UP, 1000, id, short) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, 1000, id, short) count++; ASSERT_COUNTS(count, 1000); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, 2000, id, short) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, 2000, id, short) count++; ASSERT_COUNTS(count, 2000); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, 3000, id, short) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, 3000, id, short) count++; ASSERT_COUNTS(count, 3000); } void test() { test_loop_macro_NTIMES(); + test_loop_macro_SLICE(); + test_loop_macro_LOOP(); test_loop_macro_LOOP_const(); test_loop_macro_LOOP_TYPED_const(); @@ -145,7 +186,7 @@ void test() { test_loop_macro_LOOP_TYPED_expr(); } } // namespace test_cxxloop_macros -main() { +int main() { std::cout << "# testing" << __FILE__ << std::endl; test_cxxloop_macros::test(); std::cout << "...EOTest" << std::endl; diff --git a/cxxloop.tests/testing-loops/test_cxxloop_macros_postops/test_cxxloop_macros_postops.cpp b/cxxloop.tests/testing-loops/test_cxxloop_macros_postops/test_cxxloop_macros_postops.cpp index 35d268f..cf28210 100644 --- a/cxxloop.tests/testing-loops/test_cxxloop_macros_postops/test_cxxloop_macros_postops.cpp +++ b/cxxloop.tests/testing-loops/test_cxxloop_macros_postops/test_cxxloop_macros_postops.cpp @@ -25,15 +25,15 @@ void test_loop_macro_LOOP() { int count = 0; count = 0; - CPPMACRO_LOOP(UP, 1000, id) count++; + CPPMACRO_LOOP(NTIMES_UP, 1000, id) count++; ASSERT_COUNTS(count, 1000); count = 0; - CPPMACRO_LOOP(DOWN, 2000, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, 2000, id) count++; ASSERT_COUNTS(count, 2000); count = 0; - CPPMACRO_LOOP(FASTEST, 3000, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, 3000, id) count++; ASSERT_COUNTS(count, 3000); } @@ -41,15 +41,15 @@ void test_loop_macro_LOOP_const() { int count = 0; const int N = 100; count = 0; - CPPMACRO_LOOP(UP, N, id) count++; + CPPMACRO_LOOP(NTIMES_UP, N, id) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP(DOWN, N, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, N, id) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP(FASTEST, N, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, N, id) count++; ASSERT_COUNTS(count, N); } @@ -58,15 +58,15 @@ void test_loop_macro_LOOP_expr() { const int N = 100; count = 0; - CPPMACRO_LOOP(UP, N + 1, id) count++; + CPPMACRO_LOOP(NTIMES_UP, N + 1, id) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP(DOWN, N + 1, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, N + 1, id) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP(FASTEST, N + 1, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, N + 1, id) count++; ASSERT_COUNTS(count, N + 1); } @@ -75,15 +75,15 @@ void test_loop_macro_LOOP_TYPED_const() { const int N = 100; count = 0; - CPPMACRO_LOOP_TYPED(UP, N, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, N, id, char) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, N, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, N, id, char) count++; ASSERT_COUNTS(count, N); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, N, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, N, id, char) count++; ASSERT_COUNTS(count, N); } @@ -92,29 +92,29 @@ void test_loop_macro_LOOP_TYPED_expr() { const int N = 100; count = 0; - CPPMACRO_LOOP_TYPED(UP, N + 1, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, N + 1, id, char) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, N + 1, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, N + 1, id, char) count++; ASSERT_COUNTS(count, N + 1); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, N + 1, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, N + 1, id, char) count++; ASSERT_COUNTS(count, N + 1); } void test_loop_macro_LOOP_TYPED_char() { int count = 0; - CPPMACRO_LOOP_TYPED(UP, 10, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, 10, id, char) count++; ASSERT_COUNTS(count, 10); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, 20, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, 20, id, char) count++; ASSERT_COUNTS(count, 20); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, 30, id, char) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, 30, id, char) count++; ASSERT_COUNTS(count, 30); } @@ -122,15 +122,15 @@ void test_loop_macro_LOOP_TYPED_short() { int count = 0; count = 0; - CPPMACRO_LOOP_TYPED(UP, 1000, id, short) count++; + CPPMACRO_LOOP_TYPED(NTIMES_UP, 1000, id, short) count++; ASSERT_COUNTS(count, 1000); count = 0; - CPPMACRO_LOOP_TYPED(DOWN, 2000, id, short) count++; + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, 2000, id, short) count++; ASSERT_COUNTS(count, 2000); count = 0; - CPPMACRO_LOOP_TYPED(FASTEST, 3000, id, short) count++; + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, 3000, id, short) count++; ASSERT_COUNTS(count, 3000); } diff --git a/cxxloop.tests/testing-loops/test_cxxloop_postops/test_cxxloop_postops.cpp b/cxxloop.tests/testing-loops/test_cxxloop_postops/test_cxxloop_postops.cpp index 2f329d1..e9ac171 100644 --- a/cxxloop.tests/testing-loops/test_cxxloop_postops/test_cxxloop_postops.cpp +++ b/cxxloop.tests/testing-loops/test_cxxloop_postops/test_cxxloop_postops.cpp @@ -26,11 +26,11 @@ void test_loop_macro_one_postops() { { // 1 post-expression int count = 0; CPPMACRO_NTIMES_UP_POSTOPS(int, 1000, id, count++) count++; - ASSERT_COUNTS(count, 3 * 1000); + ASSERT_COUNTS(count, 2 * 1000); count = 0; - CPPMACRO_NTIMES_DOWN_POSTOPS(int, 2000, id, count++, count++) count++; - ASSERT_COUNTS(count, 3 * 2000); + CPPMACRO_NTIMES_DOWN_POSTOPS(int, 2000, id, count++) count++; + ASSERT_COUNTS(count, 2 * 2000); } } void test_loop_macro_two_postops() { @@ -42,7 +42,7 @@ void test_loop_macro_two_postops() { ASSERT_COUNTS(count, 3 * 1000); count = 0; CPPMACRO_NTIMES_DOWN_POSTOPS(int, 2000, id, count++, count++) count++; - ASSERT_COUNTS(count, 3 * 4000); + ASSERT_COUNTS(count, 3 * 2000); } } // namespace macro @@ -58,9 +58,9 @@ namespace reps_size_t { void test_loop_postops_reps_const_size_t() { const size_t rows = 4, columns = 2; size_t count = 0; - loop_up_postops(rows, row, count += 100) - loop_down_postops(columns, column, count += 10) loop(2) count++; - ASSERT_COUNTS(count, 2000); + loop_up_postops(rows, row, count += 5) + loop_down_postops(columns, column, count += 5) loop(2) count++; + ASSERT_COUNTS(count, (rows * 5) + (rows * columns * 5) + rows * columns * 2); } void test_loop_postops_reps_size_t() { @@ -68,9 +68,11 @@ void test_loop_postops_reps_size_t() { size_t count = 0; loop_up_postops(rows, row, count += 100) - loop_down_postops(columns, column, count += 10) loop_postops(5, count++); - ASSERT_COUNTS(count, 425); + loop_down_postops(columns, column, count += 10) loop_postops(N, count++); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * N * 1); } + void test_loops() { test_loop_postops_reps_size_t(); test_loop_postops_reps_const_size_t(); @@ -82,35 +84,44 @@ void test_loops() { namespace reps_signed { void test_loop_postops_reps_integral_long_long() { long long count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4LL, row, count += 100) loop_down_postops(2LL, column, count += 10) loop_postops(5LL, count++); - ASSERT_COUNTS(count, 425LL); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_long() { size_t count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4L, row, count += 100) loop_down_postops(2L, column, count += 10) loop_postops(5L, count++); - ASSERT_COUNTS(count, 425); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_int() { size_t count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4, row, count += 100) loop_down_postops(2, column, count += 10) loop_postops(5, count++); - ASSERT_COUNTS(count, 425); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_short() { size_t count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4, row, count += 100) loop_hh_postops(2, count += 10) loop_postops(5, count++); - ASSERT_COUNTS(count, 425); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_char() { size_t count = 0; + size_t rows = 2, columns = 5; loop_hh_postops(2, count += 10) loop_hh_postops(5, count++); - ASSERT_COUNTS(count, 25); + ASSERT_COUNTS(count, (rows * 10) + (rows * columns * 1)); } void test_loops() { test_loop_postops_reps_integral_long_long(); @@ -126,36 +137,45 @@ void test_loops() { namespace reps_unsigned { void test_loop_postops_reps_integral_unsigned_long_long() { long long count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4LL, row, count += 100) loop_down_postops(2LL, column, count += 10) loop_postops(5LL, count++); - ASSERT_COUNTS(count, 425LL); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_unsigned_long() { size_t count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4L, row, count += 100) loop_down_postops(2L, column, count += 10) loop_postops(5L, count++); - ASSERT_COUNTS(count, 425); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_unsigned_int() { size_t count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4, row, count += 100) loop_down_postops(2, column, count += 10) loop_postops(5, count++); - ASSERT_COUNTS(count, 425); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_unsigned_short() { size_t count = 0; + size_t rows = 4, columns = 2, N = 5; loop_up_postops(4, row, count += 100) loop_hh_postops(2, count += 10) loop_postops(5, count++); - ASSERT_COUNTS(count, 425); + ASSERT_COUNTS(count, + (rows * 100) + (rows * columns * 10) + rows * columns * 5); } void test_loop_postops_reps_integral_unsigned_char() { size_t count = 0; + size_t rows = 2, columns = 5; loop_hh_postops(2, count += 10) loop_hh_postops(5, count++); - ASSERT_COUNTS(count, 25); + ASSERT_COUNTS(count, (rows * 10) + (rows * columns * 1)); } void test_loops() { @@ -172,7 +192,7 @@ namespace plain_tests { void test_loop_010() { unsigned int count = 0; loop_down(10U, i) count++; - ASSERT_COUNTS(count, 0); + ASSERT_COUNTS(count, 10); loop_up_postops(20, row, count++); ASSERT_COUNTS(count, 10 + 20); @@ -249,7 +269,7 @@ void test_loop_023_typed_loop() { void test_loop_030() { int count = 0; loop_postops(4, count += 1000) loop_postops(2, count += 10); - ASSERT_COUNTS(count, 4020); + ASSERT_COUNTS(count, 4 * 1000 + 4 * 2 * 10); } void test_loop_040_loop() { diff --git a/cxxloop.tests/testing-loops/test_cxxloop_slice/CMakeLists.txt b/cxxloop.tests/testing-loops/test_cxxloop_slice/CMakeLists.txt new file mode 100644 index 0000000..f4d4741 --- /dev/null +++ b/cxxloop.tests/testing-loops/test_cxxloop_slice/CMakeLists.txt @@ -0,0 +1,22 @@ +cmake_minimum_required(VERSION 3.20 FATAL_ERROR) + +set(THE_PROJECT cxxloop-testing-cxxloop-slice) + +project(${THE_PROJECT} LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED YES) + +set(TEST_CXXLOOP_SLICE test_cxxloop_slice.cpp ../macro.h) + +############### +add_executable(${THE_PROJECT} ${TEST_CXXLOOP_SLICE} ) +target_link_libraries(${THE_PROJECT} cxxloop ) + +target_include_directories(${THE_PROJECT} PUBLIC + $ + $ + $ + $ +) + diff --git a/cxxloop.tests/testing-loops/test_cxxloop_slice/test_cxxloop_slice.cpp b/cxxloop.tests/testing-loops/test_cxxloop_slice/test_cxxloop_slice.cpp new file mode 100644 index 0000000..34ec6f1 --- /dev/null +++ b/cxxloop.tests/testing-loops/test_cxxloop_slice/test_cxxloop_slice.cpp @@ -0,0 +1,194 @@ +#include +#include + +#include "macro.h" +namespace test_cxxloop_special { // namespace test_cxxloop + +namespace slice { + +namespace { +long long sumup_slice(std::slice slice) { + size_t sum = 0; + auto id = slice.start(); + loop_postops(slice.size(), id += slice.stride()) { sum += id; } + return sum; +} +size_t sumup_slice(size_t start, size_t size, size_t stride) { + auto slice = std::slice(start, size, stride); + return sumup_slice(slice); +} + +template +void test_loop_slice_plain(T start, int size, int stride) { + auto be_verbose = 1; + + auto v0 = std::vector(); + + for (int i = 0; i < size; i++) v0.push_back(start + i * stride); + + if (be_verbose > 0) + std::cout << "CPPMACRO_SLICE(std::slice(" << int(start) << "," << int(size) + << "," << stride << "), id) " << std::endl; + size_t sum = 0, count = 0; + char tab = '\t'; + + auto v1 = std::vector(); + loop_slice(start, size, stride, id) { + v1.push_back(id); + count++; + sum += id; + if (be_verbose > 1) + std::cout << start << tab << size << tab << id << tab << count << tab + << sum << std::endl; + } + if (count == 0) { + count = count + 1; + count = count - 1; + } + + ASSERT_COUNTS(count, size); + ASSERT_NOTED(sum, sumup_slice(std::slice(start, size, stride)), + "summup of ids"); + ASSERT_CONDITION(v0 == v1, "index vars do not match!"); + if (be_verbose > 0 || v0 != v1) { + std::cout << "v0: "; + for (auto v : v0) std::cout << v << "\t"; + std::cout << std::endl; + + std::cout << "v1: "; + for (auto v : v1) std::cout << v << "\t"; + std::cout << std::endl; + } +} + +template +void test_loop_slice_postops(T start, int size, int stride) { + auto be_verbose = 1; + + auto v0 = std::vector(); + + for (int i = 0; i < size; i++) v0.push_back(start + i * stride); + + if (be_verbose > 0) + std::cout << "CPPMACRO_SLICE(std::slice(" << int(start) << "," << int(size) + << "," << stride << "), id) " << std::endl; + size_t sum = 0, count = 0; + char tab = '\t'; + + auto v1 = std::vector(); + loop_slice_postops(start, size, stride, id, count++, count++, count++) { + v1.push_back(id); + count++; + sum += id; + if (be_verbose > 1) + std::cout << start << tab << size << tab << id << tab << count << tab + << sum << std::endl; + } + if (count == 0) { + count = count + 1; + count = count - 1; + } + + ASSERT_COUNTS(count, 4 * size); + ASSERT_NOTED(sum, sumup_slice(std::slice(start, size, stride)), + "summup of ids"); + ASSERT_CONDITION(v0 == v1, "index vars do not match!"); + if (be_verbose > 0 || v0 != v1) { + std::cout << "v0: "; + for (auto v : v0) std::cout << v << "\t"; + std::cout << std::endl; + + std::cout << "v1: "; + for (auto v : v1) std::cout << v << "\t"; + std::cout << std::endl; + } +} + +template +void test_loop_slice_postops2(T start, int size, int stride) { + bool be_verbose = false; + + if (be_verbose) + std::cout << "CPPMACRO_SLICE(std::slice(" << int(start) << "," << int(size) + << "," << stride << "), id) " << std::endl; + size_t sum = 0, count = 0; + char tab = '\t'; + loop_slice_postops(start, size, stride, id, count++, count++) { + count++; + sum += id; + if (be_verbose) + std::cout << start << tab << size << tab << id << tab << count << tab + << sum << std::endl; + } + + ASSERT_COUNTS(count, 3 * size); + ASSERT_NOTED(sum, sumup_slice(std::slice(start, size, stride)), + "summup of ids"); +} + +} // namespace + +template +void test_loop_slice() { + int count = 0; + size_t sum = 0; + T start = 10; + + auto slice = std::slice(); + loop_slice(10, 1000, 2, id) { count++; } + ASSERT_COUNTS(count, 1000); + + test_loop_slice_plain(start, 2, 2); + test_loop_slice_plain(start, 2, 1); + test_loop_slice_plain(start, 2, -1); + test_loop_slice_plain(start, 2, 2); + + std::cout << std::endl << "test_loop_slice_postops" << std::endl; + test_loop_slice_postops(start, 2, 3); + test_loop_slice_postops(start, 2, 3); + test_loop_slice_postops(start, 2, -2); + test_loop_slice_postops(start, 5, 5); +} + +void test() { + /// signed + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + + /// unsigned + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + + /// const signed + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + + /// const unsigned + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + test_loop_slice(); + + /// all CPPMACRO_NTIMES_DOWN_* do not sopport CONST indexTypes! +} + +} // namespace slice +void test() { slice::test(); } +} // namespace test_cxxloop_special + +int main() { + std::cout << "# testing" << __FILE__ << std::endl; + test_cxxloop_special::test(); + std::cout << "... END-of-Test" << std::endl; + std::cout.flush(); +} diff --git a/cxxloop.tests/testing-loops/test_cxxloop_templates/test_cxxloop_templates.cpp b/cxxloop.tests/testing-loops/test_cxxloop_templates/test_cxxloop_templates.cpp index 2e3f228..2f3e8bd 100644 --- a/cxxloop.tests/testing-loops/test_cxxloop_templates/test_cxxloop_templates.cpp +++ b/cxxloop.tests/testing-loops/test_cxxloop_templates/test_cxxloop_templates.cpp @@ -62,20 +62,20 @@ template void test_loop_macro_up() { int count = 0; - CPPMACRO_LOOP(UP, 10, id) count++; + CPPMACRO_LOOP(NTIMES_UP, 10, id) count++; ASSERT_COUNTS(count, 10); } template void test_loop_macro_down() { int count = 0; - CPPMACRO_LOOP(DOWN, 20, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, 20, id) count++; ASSERT_COUNTS(count, 20); } template void test_loop_macro_fast() { int count = 0; - CPPMACRO_LOOP(FASTEST, 30, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, 30, id) count++; ASSERT_COUNTS(count, 30); } template @@ -116,6 +116,119 @@ void test() { } } // namespace LOOP +namespace BASIC { +namespace plain { + +template +void test_basic_macro_plain() { + int count = 0; + T N = 10; + loop(N) count++; + ASSERT_COUNTS(count, N); + + count = 0; + loop_up(N, id) count++; + ASSERT_COUNTS(count, N); + + count = 0; + loop_hh(N) count++; + ASSERT_COUNTS(count, N); +} + +template +void test() { + test_basic_macro_plain(); +} +} // namespace plain + +namespace up { + +template +void test_basic_macro_up() { + int count = 0; + T N = 10; + loop_up(N, id) count++; + ASSERT_COUNTS(count, N); + + count = 0; + loop_up_h(N, id) count++; + ASSERT_COUNTS(count, N); + + count = 0; + loop_up_hh(N, id) count++; + ASSERT_COUNTS(count, N); +} + +template +void test() { + test_basic_macro_up(); +} +} // namespace up + +namespace down { + +template +void test_basic_macro_down() { + int count = 0; + T N = 10; + + loop_down(N, id) count++; + ASSERT_COUNTS(count, N); + + count = 0; + loop_down_h(N, id) count++; + ASSERT_COUNTS(count, N); + + count = 0; + loop_down_hh(N, id) count++; + ASSERT_COUNTS(count, N); +} + +template +void test() { + test_basic_macro_down(); +} +} // namespace down + +template +void test_basic() { + plain::test(); + up::test(); + down::test(); +} + +void test() { + /// signed + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); + + /// unsigned + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); + + /// const signe + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); + + /// const unsig + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); +} + +} // namespace BASIC + ////////////////////////////////// /// \brief test_loop_reps_const_size_t /// @@ -204,45 +317,47 @@ namespace SCOPE { template void test_scope_regular() { - T rows = 100, columns = 40; + T rows = 100, columns = 40, N = 5; size_t count = 0; - loop_up(rows, row) loop_up(columns, col) count = - row > 0 ? (col > 0 ? 1 : 0) : 0; - ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); + loop_up(rows, row) loop_up(columns, col) loop(N) { + count += row > 0 ? (col > 0 ? 1 : 0) : 0; + } + ASSERT_COUNTS(count, (rows - 1) * (columns - 1) * (N)); } template void test_scope_reference() { - T rows_ = 100, columns_ = 40; + T rows_ = 100, columns_ = 40, N = 5; T &rows = rows_, &columns = columns_; int count = 0; - loop_up(rows, row) loop_up(columns, col) count = + loop_up(rows, row) loop_up(columns, col) loop(N) count += row > 0 ? (col > 0 ? 1 : 0) : 0; - ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); + ASSERT_COUNTS(count, (rows - 1) * (columns - 1) * N); } template void test_scope_rvalue() { - T &&rows = 100, &&columns = 40; + T &&rows = 100, &&columns = 40, N = 5; int count = 0; - loop_up(rows, row) loop_up(columns, col) count = + loop_up(rows, row) loop_up(columns, col) loop(N) count += row > 0 ? (col > 0 ? 1 : 0) : 0; - ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); + ASSERT_COUNTS(count, (rows - 1) * (columns - 1) * (N)); count = 0; - loop_up(100, row) loop_up(40, col) count = row > 0 ? (col > 0 ? 1 : 0) : 0; - ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); + loop_up(100, row) loop_up(40, col) loop(5) count += + row > 0 ? (col > 0 ? 1 : 0) : 0; + ASSERT_COUNTS(count, (rows - 1) * (columns - 1) * (N)); } template void test_scope_expr() { - T rows = 100, columns = 20, N = 4; + T rows = 100, columns = 20, N = 5; size_t count = 0; - loop_up(rows + 1, row) loop_down(columns + 1, col) count = + loop_up(rows + 1, row) loop_down(columns + 1, col) loop(N) count += row > 0 ? (col > 0 ? 1 : 0) : 0; - ASSERT_COUNTS(count, (rows + 1 - 1) * (columns + 1 - 1)); + ASSERT_COUNTS(count, (rows + 1 - 1) * (columns + 1 - 1) * N); } template @@ -289,6 +404,7 @@ void test() { void test_loops() { NTIMES::test(); LOOP::test(); + BASIC::test(); templates::test(); SCOPE::test(); } diff --git a/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/CMakeLists.txt b/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/CMakeLists.txt index 6509360..0ebef02 100644 --- a/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/CMakeLists.txt +++ b/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/CMakeLists.txt @@ -1,13 +1,13 @@ cmake_minimum_required(VERSION 3.20 FATAL_ERROR) -set(THE_PROJECT cxxloop-testing-cxxloop-templates) +set(THE_PROJECT cxxloop-testing-cxxloop-templates-postops) project(${THE_PROJECT} LANGUAGES CXX) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED YES) -set(TEST_CXXLOOP test_cxxloop_templates.cpp ../macro.h) +set(TEST_CXXLOOP test_cxxloop_templates_postops.cpp ../macro.h) ############### add_executable(${THE_PROJECT} ${TEST_CXXLOOP} ) diff --git a/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/test_cxxloop_templates.cpp b/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/test_cxxloop_templates_postops.cpp similarity index 68% rename from cxxloop.tests/testing-loops/test_cxxloop_templates_postops/test_cxxloop_templates.cpp rename to cxxloop.tests/testing-loops/test_cxxloop_templates_postops/test_cxxloop_templates_postops.cpp index 9b83983..79b5830 100644 --- a/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/test_cxxloop_templates.cpp +++ b/cxxloop.tests/testing-loops/test_cxxloop_templates_postops/test_cxxloop_templates_postops.cpp @@ -62,20 +62,20 @@ template void test_loop_macro_up() { int count = 0; - CPPMACRO_LOOP(UP, 10, id) count++; + CPPMACRO_LOOP(NTIMES_UP, 10, id) count++; ASSERT_COUNTS(count, 10); } template void test_loop_macro_down() { int count = 0; - CPPMACRO_LOOP(DOWN, 20, id) count++; + CPPMACRO_LOOP(NTIMES_DOWN, 20, id) count++; ASSERT_COUNTS(count, 20); } template void test_loop_macro_fast() { int count = 0; - CPPMACRO_LOOP(FASTEST, 30, id) count++; + CPPMACRO_LOOP(NTIMES_FASTEST, 30, id) count++; ASSERT_COUNTS(count, 30); } template @@ -116,6 +116,118 @@ void test() { } } // namespace LOOP +namespace BASIC { +namespace plain { + +template +void test_basic_macro_plain_postops() { + int count = 0; + T N = 10; + loop_postops(N, count += 2) count++; + ASSERT_COUNTS(count, 3 * N); + + count = 0; + loop_h_postops(N, count += 2) count++; + ASSERT_COUNTS(count, 3 * N); + + count = 0; + loop_hh_postops(N, count += 2) count++; + ASSERT_COUNTS(count, 3 * N); +} + +template +void test() { + test_basic_macro_plain_postops(); +} +} // namespace plain +namespace up { + +template +void test_basic_macro_up_postops() { + int count = 0; + T N = 10; + + loop_up_postops(N, id, count++) count++; + ASSERT_COUNTS(count, 2 * N); + + count = 0; + loop_up_h_postops(N, id, count++) count++; + ASSERT_COUNTS(count, 2 * N); + + count = 0; + loop_up_hh_postops(N, id, count++) count++; + ASSERT_COUNTS(count, 2 * N); +} + +template +void test() { + test_basic_macro_up_postops(); +} +} // namespace up + +namespace down { + +template +void test_basic_macro_down_postops() { + int count = 0; + T N = 10; + + loop_down_postops(N, id, count++) count++; + ASSERT_COUNTS(count, 2 * N); + + count = 0; + loop_down_h_postops(N, id, count++) count++; + ASSERT_COUNTS(count, 2 * N); + + count = 0; + loop_down_hh_postops(N, id, count++) count++; + ASSERT_COUNTS(count, 2 * N); +} + +template +void test() { + test_basic_macro_down_postops(); +} +} // namespace down + +template +void test_basic() { + up::test(); + down::test(); +} + +void test() { + /// signed + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); + + /// unsigned + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); + + /// const signe + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); + + /// const unsig + test_basic(); + test_basic(); + test_basic(); + test_basic(); + test_basic(); +} + +} // namespace BASIC + ////////////////////////////////// /// \brief test_loop_reps_const_size_t /// @@ -207,7 +319,7 @@ void test_scope_regular() { T rows = 100, columns = 40; size_t count = 0; - loop_up(rows, row) loop_up(columns, col) count = + loop_up(rows, row) loop_up(columns, col) count += row > 0 ? (col > 0 ? 1 : 0) : 0; ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); } @@ -217,7 +329,7 @@ void test_scope_reference() { T rows_ = 100, columns_ = 40; T &rows = rows_, &columns = columns_; int count = 0; - loop_up(rows, row) loop_up(columns, col) count = + loop_up(rows, row) loop_up(columns, col) count += row > 0 ? (col > 0 ? 1 : 0) : 0; ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); } @@ -227,12 +339,12 @@ void test_scope_rvalue() { T &&rows = 100, &&columns = 40; int count = 0; - loop_up(rows, row) loop_up(columns, col) count = + loop_up(rows, row) loop_up(columns, col) count += row > 0 ? (col > 0 ? 1 : 0) : 0; ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); count = 0; - loop_up(100, row) loop_up(40, col) count = row > 0 ? (col > 0 ? 1 : 0) : 0; + loop_up(100, row) loop_up(40, col) count += row > 0 ? (col > 0 ? 1 : 0) : 0; ASSERT_COUNTS(count, (rows - 1) * (columns - 1)); } @@ -240,7 +352,7 @@ template void test_scope_expr() { T rows = 100, columns = 20, N = 4; size_t count = 0; - loop_up(rows + 1, row) loop_down(columns + 1, col) count = + loop_up(rows + 1, row) loop_down(columns + 1, col) count += row > 0 ? (col > 0 ? 1 : 0) : 0; ASSERT_COUNTS(count, (rows + 1 - 1) * (columns + 1 - 1)); } @@ -292,11 +404,21 @@ void test_loops() { SCOPE::test(); } +} // namespace SCOPE + +void test() { + NTIMES::test(); + LOOP::test(); + BASIC::test(); + templates::test(); + SCOPE::test(); +} + } // namespace test_cxxloop_templates int main() { std::cout << "# testing" << __FILE__ << std::endl; - test_cxxloop_templates::test_loops(); + test_cxxloop_templates::test(); std::cout << "... END-of-Test" << std::endl; std::cout.flush(); diff --git a/cxxloop/CMakeLists.txt b/cxxloop/CMakeLists.txt index 357b9b8..c8944e9 100644 --- a/cxxloop/CMakeLists.txt +++ b/cxxloop/CMakeLists.txt @@ -18,9 +18,14 @@ set(CPPLOOP_HDR include/cxxloop.h include/cxxloop_postops.h include/cxxloop_prereqs.h + + #include/cxxloop_slice.h + i#nclude/cxxloop_slice_postops.h + include/cxxloop_slice_prereqs.h ) add_library(cxxloop INTERFACE) +#target_sources(cxxloop INTERFACE ${CPPLOOP_HDR}) target_include_directories(cxxloop INTERFACE diff --git a/cxxloop/include/cxxloop.h b/cxxloop/include/cxxloop.h index 4100276..7adf4cc 100644 --- a/cxxloop/include/cxxloop.h +++ b/cxxloop/include/cxxloop.h @@ -28,42 +28,51 @@ loop_down_hh(rep, id){} /// // ... loop block-statement nbrOfRepetitions-times #define loop(nbrOfRepetitions) \ - CPPMACRO_LOOP(FASTEST, nbrOfRepetitions, CPPMACRO_UNIQUE_ID(__COUNTER__)) + CPPMACRO_LOOP(NTIMES_FASTEST, nbrOfRepetitions, CPPMACRO_UNIQUE_ID(__COUNTER__)) // ... counting up-wards #define loop_up(nbrOfRepetitions, indexVarName) \ - CPPMACRO_LOOP(UP, nbrOfRepetitions, indexVarName) + CPPMACRO_LOOP(NTIMES_UP, nbrOfRepetitions, indexVarName) // ... counting down-wards #define loop_down(nbrOfRepetitions, indexVarName) \ - CPPMACRO_LOOP(DOWN, nbrOfRepetitions, indexVarName) + CPPMACRO_LOOP(NTIMES_DOWN, nbrOfRepetitions, indexVarName) ///////////////////////// CPPMACRO_LOOP__TYPED, ushort // ... loop block-statement nbrOfRepetitions-times #define loop_h(nbrOfRepetitions) \ - CPPMACRO_LOOP_TYPED(FASTEST, nbrOfRepetitions, \ + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, nbrOfRepetitions, \ CPPMACRO_UNIQUE_ID(__COUNTER__), short) // ... counting up-wards #define loop_up_h(nbrOfRepetitions, indexVarName) \ - CPPMACRO_LOOP_TYPED(UP, nbrOfRepetitions, indexVarName, short) + CPPMACRO_LOOP_TYPED(NTIMES_UP, nbrOfRepetitions, indexVarName, short) // ... counting down-wards #define loop_down_h(nbrOfRepetitions, indexVarName) \ - CPPMACRO_LOOP_TYPED(DOWN, nbrOfRepetitions, indexVarName, short) + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, nbrOfRepetitions, indexVarName, short) ///////////////////////// CPPMACRO_LOOP__TYPED, uchar // ... loop block-statement nbrOfRepetitions-times #define loop_hh(nbrOfRepetitions) \ - CPPMACRO_LOOP_TYPED(FASTEST, nbrOfRepetitions, \ + CPPMACRO_LOOP_TYPED(NTIMES_FASTEST, nbrOfRepetitions, \ CPPMACRO_UNIQUE_ID(__COUNTER__), char) // ... counting up-wards #define loop_up_hh(nbrOfRepetitions, indexVarName) \ - CPPMACRO_LOOP_TYPED(UP, nbrOfRepetitions, indexVarName, char) + CPPMACRO_LOOP_TYPED(NTIMES_UP, nbrOfRepetitions, indexVarName, char) // ... counting down-wards #define loop_down_hh(nbrOfRepetitions, indexVarName) \ - CPPMACRO_LOOP_TYPED(DOWN, nbrOfRepetitions, indexVarName, char) + CPPMACRO_LOOP_TYPED(NTIMES_DOWN, nbrOfRepetitions, indexVarName, char) + +#endif + +#if defined __cpp_has_cpploop_slice +#define loop_slice( start, size, stride, indexVarName) \ + CPPMACRO_SLICED(int , start, size, stride, indexVarName) + +#define loop_slice_postops( start, size, stride, indexVarName, ...) \ + CPPMACRO_SLICED_POSTOPS(int , start, size, stride, indexVarName, __VA_ARGS__) #endif diff --git a/cxxloop/include/cxxloop_postops.h b/cxxloop/include/cxxloop_postops.h index 5627703..aea4485 100644 --- a/cxxloop/include/cxxloop_postops.h +++ b/cxxloop/include/cxxloop_postops.h @@ -31,49 +31,49 @@ loop_down_hh_postops(rep, id) /// // ... loop block-statement nbrOfRepetitions-times #define loop_postops(nbrOfRepetitions, ...) \ - CPPMACRO_LOOP_POSTOPS(FASTEST, nbrOfRepetitions, \ + CPPMACRO_LOOP_POSTOPS(NTIMES_FASTEST, nbrOfRepetitions, \ CPPMACRO_UNIQUE_ID(__COUNTER__), __VA_ARGS__) // ... counting up-wards #define loop_up_postops(nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_LOOP_POSTOPS(UP, nbrOfRepetitions, indexVarName, __VA_ARGS__) + CPPMACRO_LOOP_POSTOPS(NTIMES_UP, nbrOfRepetitions, indexVarName, __VA_ARGS__) // ... counting down-wards #define loop_down_postops(nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_LOOP_POSTOPS(DOWN, nbrOfRepetitions, indexVarName, __VA_ARGS__) + CPPMACRO_LOOP_POSTOPS(NTIMES_DOWN, nbrOfRepetitions, indexVarName, __VA_ARGS__) ///////////////////////// CPPMACRO_LOOP__TYPED, ushort // ... loop block-statement nbrOfRepetitions-times #define loop_h_postops(nbrOfRepetitions, ...) \ - CPPMACRO_LOOP_TYPED_POSTOPS(FASTEST, nbrOfRepetitions, \ + CPPMACRO_LOOP_TYPED_POSTOPS(NTIMES_FASTEST, nbrOfRepetitions, \ CPPMACRO_UNIQUE_ID(__COUNTER__), short, \ __VA_ARGS__) // ... counting up-wards #define loop_up_h_postops(nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_LOOP_TYPED_POSTOPS(UP, nbrOfRepetitions, indexVarName, short, \ + CPPMACRO_LOOP_TYPED_POSTOPS(NTIMES_UP, nbrOfRepetitions, indexVarName, short, \ __VA_ARGS__) // ... counting down-wards #define loop_down_h_postops(nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_LOOP_TYPED_POSTOPS(DOWN, nbrOfRepetitions, indexVarName, short, \ + CPPMACRO_LOOP_TYPED_POSTOPS(NTIMES_DOWN, nbrOfRepetitions, indexVarName, short, \ __VA_ARGS__) ///////////////////////// CPPMACRO_LOOP__TYPED, uchar // ... loop block-statement nbrOfRepetitions-times #define loop_hh_postops(nbrOfRepetitions, ...) \ - CPPMACRO_LOOP_TYPED_POSTOPS(FASTEST, nbrOfRepetitions, \ + CPPMACRO_LOOP_TYPED_POSTOPS(NTIMES_FASTEST, nbrOfRepetitions, \ CPPMACRO_UNIQUE_ID(__COUNTER__), char, \ __VA_ARGS__) // ... counting up-wards #define loop_up_hh_postops(nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_LOOP_TYPED_POSTOPS(UP, nbrOfRepetitions, indexVarName, char, \ + CPPMACRO_LOOP_TYPED_POSTOPS(NTIMES_UP, nbrOfRepetitions, indexVarName, char, \ __VA_ARGS__) // ... counting down-wards #define loop_down_hh_postops(nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_LOOP_TYPED_POSTOPS(DOWN, nbrOfRepetitions, indexVarName, char, \ + CPPMACRO_LOOP_TYPED_POSTOPS(NTIMES_DOWN, nbrOfRepetitions, indexVarName, char, \ __VA_ARGS__) #endif diff --git a/cxxloop/include/cxxloop_prereqs.h b/cxxloop/include/cxxloop_prereqs.h index 86eeaeb..5d7cff7 100644 --- a/cxxloop/include/cxxloop_prereqs.h +++ b/cxxloop/include/cxxloop_prereqs.h @@ -1,5 +1,10 @@ #pragma once +#ifndef __cpp_has_cpploop +#define __cpp_has_cpploop +#define __cpp_has_cpploop_postops +#define __cpp_has_cpploop_slice +#endif #ifdef __cpp_has_cpploop /////////////////////////////////////////////////////////////////////////// @@ -10,7 +15,6 @@ #error("the compound group LOOP will not work with C99 or later") #endif - // cpp-macro to generate an unique ID #ifndef CPPMACRO_UNIQUE_ID #define CPPMACRO_XCAT2(a, b) a##b @@ -23,63 +27,59 @@ namespace ogis { -// strip off any of const, volatile or references (T&, T&&) -/*template -using remove_cvref = typename std::remove_reference<\ - typename std::remove_const::type>::type; -*/ - template using remove_cvref_t = typename std::remove_cv::type>::type; template -using copy_unsigendness_conditional_t = +using copy_signedness_from_basetype_t = typename std::conditional::value, typename std::make_unsigned::type, TgtType>::type; template using copy_unsigendness_to_char_t = - copy_unsigendness_conditional_t; + copy_signedness_from_basetype_t; template using copy_unsigendness_to_short_t = - copy_unsigendness_conditional_t; + copy_signedness_from_basetype_t; } // namespace ogis // //:CPPMACRO_NTIMES_* +////////////////////////////// +//////// NTIMES +////////////////////////////// // //:CPPMACRO_NTIMES_[UP|DOWN|FASTEST] // cpp-macro to count upwards (from 0 to nbrOfRepetitions-1) #define CPPMACRO_NTIMES_UP(indexType, nbrOfRepetitions, indexVarName) \ for (indexType indexVarName = static_cast(0); \ - indexVarName < nbrOfRepetitions; indexVarName++) + indexVarName < static_cast(nbrOfRepetitions); indexVarName++) // cpp-macro to count downwards (from nbrOfRepetitions-1 to 0) #define CPPMACRO_NTIMES_DOWN(indexType, nbrOfRepetitions, indexVarName) \ for (indexType indexVarName = static_cast(nbrOfRepetitions); \ - indexVarName-- > 0;) + indexVarName-- != 0;) +// cpp-macro to count in any direction (preferring fastetst counting downwards) #define CPPMACRO_NTIMES_FASTEST(indexType, nbrOfRepetitions, indexVarName) \ - for (indexType indexVarName = static_cast(nbrOfRepetitions); \ - indexVarName-- > 0;) - + CPPMACRO_NTIMES_DOWN(indexType, nbrOfRepetitions, indexVarName) ////////////////////////////// // //:CPPMACRO_LOOP[_TYPED]_POSTOPS -#define CPPMACRO_LOOP(direction, nbrOfRepetitions, indexVarName) \ - CPPMACRO_NTIMES_##direction( \ - typename ogis::remove_cvref_t, \ - nbrOfRepetitions, indexVarName) - -#define CPPMACRO_LOOP_TYPED(direction, nbrOfRepetitions, indexVarName, type) \ - CPPMACRO_NTIMES_##direction( \ - ogis::copy_unsigendness_to_##type##_t< \ - typename ogis::remove_cvref_t>, \ +#define CPPMACRO_LOOP(TAG, nbrOfRepetitions, indexVarName) \ + CPPMACRO_##TAG(typename ogis::remove_cvref_t, \ + nbrOfRepetitions, indexVarName) + +#define CPPMACRO_LOOP_TYPED(TAG, nbrOfRepetitions, indexVarName, type) \ + CPPMACRO_##TAG( \ + typename ogis::copy_unsigendness_to_##type##_t< \ + typename ogis::remove_cvref_t>, \ nbrOfRepetitions, indexVarName) +////////////////////////////// //////// POSTOPS ////////////////////////////// #ifdef __cpp_has_cpploop_postops @@ -102,17 +102,49 @@ using copy_unsigendness_to_short_t = indexVarName-- > 0; __VA_ARGS__) // //:CPPMACRO_LOOP[_TYPED]_POSTOPS -#define CPPMACRO_LOOP_POSTOPS(direction, nbrOfRepetitions, indexVarName, ...) \ - CPPMACRO_NTIMES_##direction##_POSTOPS( \ - typename ogis::remove_cvref_t, \ +#define CPPMACRO_LOOP_POSTOPS(TAG, nbrOfRepetitions, indexVarName, ...) \ + CPPMACRO_##TAG##_POSTOPS( \ + typename ogis::remove_cvref_t, \ nbrOfRepetitions, indexVarName, __VA_ARGS__) -#define CPPMACRO_LOOP_TYPED_POSTOPS(direction, nbrOfRepetitions, indexVarName, \ - type, ...) \ - CPPMACRO_NTIMES_##direction##_POSTOPS( \ +#define CPPMACRO_LOOP_TYPED_POSTOPS(TAG, nbrOfRepetitions, indexVarName, type, \ + ...) \ + CPPMACRO_##TAG##_POSTOPS( \ ogis::copy_unsigendness_to_##type##_t< \ typename ogis::remove_cvref_t>, \ nbrOfRepetitions, indexVarName, __VA_ARGS__) #endif + +#if defined __cpp_has_cpploop_slice + +#include + +//:CPPMACRO_SLICES +// cpp-macro looping slice(start, size, step ) +#define DUMMY_CPPMACRO_SLICE(slice, index) \ + for (size_t index = slice.start(), \ + __cppmacro_loop_##index##_index_limit = \ + slice.start() + slice.size() * slice.stride(); \ + index < __cppmacro_loop_##index##_index_limit; index += slice.stride()) + +#define CPPMACRO_SLICED(indexType, start, size, stride, indexVarName) \ + for (indexType \ + indexVarName = start, \ + __cppmacro_loop_##indexVarName##_limit = start + size * stride; \ + (stride > 0) ? indexVarName < __cppmacro_loop_##indexVarName##_limit \ + : indexVarName > __cppmacro_loop_##indexVarName##_limit; \ + indexVarName += stride) + +#define CPPMACRO_SLICED_POSTOPS(indexType, start, size, stride, indexVarName, \ + ...) \ + for (indexType \ + indexVarName = start, \ + __cppmacro_loop_##indexVarName##_limit = start + size * stride; \ + (stride > 0) ? indexVarName < __cppmacro_loop_##indexVarName##_limit \ + : indexVarName > __cppmacro_loop_##indexVarName##_limit; \ + indexVarName += stride, __VA_ARGS__) + +#endif + #endif diff --git a/cxxloop/include/loop.h b/cxxloop/include/loop.h index 8c80e6e..8c10677 100644 --- a/cxxloop/include/loop.h +++ b/cxxloop/include/loop.h @@ -2,10 +2,11 @@ #define __cpp_has_cpploop 20220301UL #define __cpp_has_cpploop_postops __cpp_has_cpploop +#define __cpp_has_cpploop_slice __cpp_has_cpploop #if !defined __cplusplus #error("the compound group LOOP does not work with any version of C like C99, C11 or others") #endif -#include "cxxloop.h" -#include "cxxloop_postops.h" +#include "cxxloop.h" +#include "cxxloop_postops.h" diff --git a/qtcsettings.cmake b/qtcsettings.cmake new file mode 100644 index 0000000..1649748 --- /dev/null +++ b/qtcsettings.cmake @@ -0,0 +1,2 @@ +# This file is managed by Qt Creator, do not edit! +