Merge pull request #187 from codereport/dev

Adding `algorithm.hpp` with `zip_find`, `zip_found` & `is_mismatched`

Author: codereport

jsrc/CMakeLists.txt

@@ -16,7 +16,6 @@ target_sources(j PRIVATE
         adverbs/ar.c
         adverbs/as.c
         adverbs/au.c
-        array.hpp
         conjunctions/c.c
         conjunctions/ca.c
         conjunctions/cc.c

jsrc/algorithm.hpp

@@ -0,0 +1,36 @@
+
+#include <tuple>
+#include <algorithm>
+
+namespace algo {
+
+/**
+ * @brief Variadic version of `std::mismatch`
+ */
+template <typename P, typename I, typename... Is>
+auto zip_find(P pred, I f, I l, Is... fs) {
+    while (f != l) {
+        if (pred(*f, *fs...)) break;
+        ++f, ((void)++fs,...);
+    }
+    return std::tuple{f, fs...};
+}
+
+/**
+ * @brief Predicate version of `algo::zip_found`
+ */
+template <typename P, typename I, typename... Is>
+auto zip_found(P pred, I f, I l, Is... fs) {
+    auto const t = zip_find(pred, f, l, fs...);
+    return std::get<0>(t) != l;
+}
+
+/**
+ * @brief Predicate version of `std::mismatch`
+ */
+template <typename I, typename I2>
+auto is_mismatched(I f, I l, I2 f2) {
+    return std::mismatch(f, l, f2).first != l;
+}
+
+}

jsrc/verbs/dyadic/take_drop.cpp

@@ -1,7 +1,9 @@
 
 #include <algorithm>
+#include <functional>
 #include <iterator>
 
+#include "algorithm.hpp"
 #include "array.hpp"
 
 /** @file */
@@ -75,7 +77,7 @@ jttks(J jt, array a, array w) { // take_sparse
     s = AV(y);
 
     // TODO: rename b when we figure out what it is doing
-    auto const b = std::mismatch(u + m, u + r, s + m).first != u + r; 
+    auto const b = algo::is_mismatched(u + m, u + r, s + m);
 
     if (b) {
         jt->fill = SPA(wp, e);
@@ -87,7 +89,7 @@ jttks(J jt, array a, array w) { // take_sparse
         x = SPA(wp, x);
 
     // TODO: rename c when we figure out what it is doing
-    if (auto const c = std::mismatch(u, u + m, s).first != u + m; c) {
+    if (auto const c = algo::is_mismatched(u, u + m, s); c) {
         A j;
         C *xv, *yv;
         I d, i, *iv, *jv, k, n, t;
@@ -104,22 +106,19 @@ jttks(J jt, array a, array w) { // take_sparse
         xv = CAV(x);
         for (i = 0; i < n; ++i) {
 
-            // this is std::mismatch3 (or std::zip_find3)
-            bool cc = 0;
-            for (int64_t i = 0; i < m; ++i) {
-                t = u[i]; 
-                if (0 > t ? iv[i] < t + s[i] : iv[i] >= t) {
-                    cc = true;
-                    break;
-                }
-            }
+            auto const cc = algo::zip_found(
+                [](auto a, auto b, auto c) { return 0 > a ? c < a + b : c >= a; },
+                u, u + m, s, iv);
 
             if (!cc) {
                 ++d;
                 memcpy(yv, xv, k);
                 yv += k;
-                // TODO: use algorithm created above
-                DO(m, t = u[i]; *jv++ = 0 > t ? iv[i] - (t + s[i]) : iv[i];);
+                // TODO: create variadic `algo::transform`
+                for (int64_t i = 0; i < m; ++i) {
+                    t = u[i];
+                    *jv++ = 0 > u[i] ? iv[i] - (u[i] + s[i]) : iv[i];
+                }
             }
             iv += m;
             xv += k;

learning/LIVESTREAM_LESSONS.md

@@ -127,3 +127,10 @@ Prelude> let innerProduct = blackbird sum (zipWith (*))
 * IRS = Integral/Integrated Rank Support (optimizations for certain verbs - see [this paper](https://www.jsoftware.com/papers/rank.htm))
 * Discrovered [Try J](http://tryj.freeddns.org/) site set up by Nathan
 * Used our first C++ Standard Algorithm (`std::mismatch` x2)
+
+### Livestream #9 2021-02-24
+
+* Learned about J's `trace` function from Bob's video
+* Learned this fancy incantation `((void)++fs,...)`
+* Learned can't be in a deduced context then variadic template is not the last template
+* Added `algorithm.hpp` with `zip_find`, `zip_found` and `is_mismatched`