Merge remote-tracking branch 'upstream/master'

Author: jiegillet

chapters/computational_geometry/gift_wrapping/jarvis_march/code/jarvis.jl

@@ -0,0 +1,69 @@
+# Struct to hold an x, y position. A tuple would also be fine.
+struct Pos
+    x::Float64
+    y::Float64
+end
+
+# This returns a measure of how far "left" the vector is with a cross product
+function cross(point1::Pos, point2::Pos, point3::Pos)
+    vec1 = Pos(point2.x - point1.x, point2.y - point1.y)
+    vec2 = Pos(point3.x - point2.x, point3.y - point2.y)
+    ret_angle = vec1.x*vec2.y - vec1.y*vec2.x
+    return ret_angle*ret_angle
+end
+
+function jarvis_march(points::Vector{Pos})
+    hull = Vector{Pos}()
+
+    # sorting array based on leftmost point
+    sort!(points, by = item -> item.x)
+    push!(hull, points[1])
+
+    i = 1
+    curr_point = points[2]
+
+    # Find angle between points
+    curr_product = cross(Pos(0,0), hull[1], curr_point)
+
+    # We will hold a temp variable with the highest cross product as we iterate
+    # through all the points and move our hull vector forward.
+    while (curr_point != hull[1])
+        for point in points
+            product = 0.0
+
+            # Special case for the first element when there is no hull[i-1]
+            if (i == 1)
+                if (hull[i] != point)
+                    product = cross(Pos(0,0), hull[i], point)
+                end
+            else
+                if (hull[i] != point && hull[i-1] != point)
+                    product = cross(hull[i-1], hull[i], point)
+                end
+            end
+            if (product > curr_product)
+                curr_point = point
+                curr_product = product
+            end
+        end
+
+        # Pushing to hull, moving simulation forward and resetting the product
+        push!(hull, curr_point)
+        curr_product = 0
+        i += 1
+    end
+
+    return hull
+end
+
+function main()
+
+    # These points are chosen such that there is a clearly defined hull with
+    # several interior points. As a note, these will be generated either 
+    # randomly or via some mesh in practice.
+    points = [Pos(2,1.5), Pos(1, 1), Pos(2, 4), Pos(3, 1), Pos(2,2), Pos(2,0.5)]
+    hull = jarvis_march(points)
+    println(hull)
+end
+
+main()

chapters/convolutions/convolutions.md

@@ -64,7 +64,7 @@ In code, this looks something like:
 {% sample lang="hs" %}
 [import:1-5, lang:"haskell"](code/haskell/convolution.hs)
 {% sample lang="c"%}
-[import:46-58, lang:"c_cpp"](code/c/convolutions.c)
+[import:44-57, lang:"c_cpp"](code/c/convolutions.c)
 {% sample lang="cpp"%}
 [import:68-88, lang:"c_cpp"](code/c++/convolutions.cpp)
 {% endmethod %}
@@ -113,7 +113,7 @@ The FFT-based convolution in Haskell is complicated, so here is some simple juli
 [import:19-22, lang:"julia"](code/julia/conv.jl)
 Where the `.*` operator is an element-wise multiplication.
 {% sample lang="c"%}
-[import:60-69, lang:"c_cpp"](code/c/convolutions.c)
+[import:59-69, lang:"c_cpp"](code/c/convolutions.c)
 {% sample lang="cpp"%}
 [import:90-105, lang:"c_cpp"](code/c++/convolutions.cpp)
 {% endmethod %}

chapters/data_compression/huffman/code/c++/huffman.cpp

@@ -0,0 +1,280 @@
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cassert>
+#include <cctype>
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <iostream>
+
+using std::begin;
+using std::end;
+
+namespace huffman {
+
+[[noreturn]] inline void unreachable() {
+  std::cerr << "this should never happen\n";
+  std::abort();
+}
+
+// --- interface ---
+class codebook {
+  struct node {
+    int frequency;
+
+    node(int freq) : frequency(freq) {}
+    virtual ~node() = 0;
+  };
+
+  // never null
+  using node_ptr = std::unique_ptr<node const>;
+  using bitstring = std::vector<bool>;
+
+  // this is a flatmap between char and a bitstring
+  // there should only ever be one character with a given
+  // value at any time.
+  using encoder_t = std::vector<std::pair<char, bitstring>>;
+
+  struct leaf final : node {
+    char key;
+
+    leaf(int freq, char key) : node(freq), key(key) {}
+  };
+
+  struct branch final : node {
+    node_ptr lhs;
+    node_ptr rhs;
+
+    branch(node_ptr lhs, node_ptr rhs)
+        : node(lhs->frequency + rhs->frequency), lhs(std::move(lhs)),
+          rhs(std::move(rhs)) {}
+  };
+
+  // this allows us to share [codebook]s among encoded strings
+  struct data {
+    node_ptr decoder;
+    encoder_t encoder;
+  };
+  std::shared_ptr<data const> underlying_;
+
+public:
+  template <class Iter>
+  codebook(Iter const first, Iter const last);
+
+  template <class Iter>
+  std::vector<bool> encode(Iter first, Iter last) const;
+
+  template <class Iter>
+  std::string decode(Iter first, Iter last) const;
+};
+
+struct encoded_string {
+  codebook codes;
+  std::vector<bool> string;
+
+  explicit encoded_string(std::string const& s)
+      : codes(begin(s), end(s)), string(codes.encode(begin(s), end(s))) {}
+
+  encoded_string(codebook codes, std::string const& s)
+      : codes(codes), string(codes.encode(begin(s), end(s))) {}
+
+  std::string decoded() const {
+    return codes.decode(begin(string), end(string));
+  }
+};
+
+// --- implementation ---
+inline codebook::node::~node() {}
+
+inline std::vector<bool> with_new_bit(std::vector<bool> bits, bool b) {
+  bits.push_back(b);
+  return bits;
+}
+
+template <class Iter>
+codebook::codebook(Iter const first, Iter const last) {
+  struct helper {
+    static node_ptr make_decoder(Iter const first, Iter const last) {
+      // in this part of the function, we build up a frequency list
+      // sorted by frequency, descending
+      auto freq = std::vector<leaf>();
+
+      std::for_each(first, last, [&freq](char c) {
+        auto const it = std::find_if(
+            begin(freq), end(freq), [c](auto const& p) { return p.key == c; });
+        if (it != end(freq)) {
+          // it's already in the list
+          it->frequency += 1;
+        } else {
+          // it's not already in the list
+          freq.emplace_back(1, c);
+        }
+      });
+
+      if (freq.empty()) {
+        throw std::invalid_argument("attempted to codebook an empty range");
+      }
+
+      std::sort(begin(freq), end(freq), [](auto const& lhs, auto const& rhs) {
+        return lhs.frequency > rhs.frequency;
+      });
+
+      auto ret = std::vector<std::unique_ptr<node>>();
+      std::transform(
+          begin(freq), end(freq), std::back_inserter(ret), [](auto const l) {
+            return std::make_unique<leaf>(l);
+          });
+
+      while (ret.size() > 1) {
+        auto rhs = std::move(ret.back());
+        ret.pop_back();
+        auto lhs = std::move(ret.back());
+        ret.pop_back();
+
+        auto new_node =
+            std::make_unique<branch>(std::move(lhs), std::move(rhs));
+        auto const new_freq = new_node->frequency;
+
+        // look for the first element with a smaller frequency
+        auto const it =
+            std::find_if(begin(ret), end(ret), [new_freq](auto const& n) {
+              return n->frequency < new_freq;
+            });
+        // and insert the new_node before that element
+        ret.insert(it, std::move(new_node));
+        // in this way, we keep the list sorted by frequency
+      }
+
+      return std::move(ret.back());
+    }
+
+    static void
+    encoder_rec(node const* cur, std::vector<bool> bits, encoder_t& out) {
+      if (auto l = dynamic_cast<leaf const*>(cur)) {
+        out.push_back(std::make_pair(l->key, std::move(bits)));
+      } else if (auto b = dynamic_cast<branch const*>(cur)) {
+        encoder_rec(b->lhs.get(), with_new_bit(bits, 0), out);
+        encoder_rec(b->rhs.get(), with_new_bit(std::move(bits), 1), out);
+      } else {
+        unreachable();
+      }
+    }
+
+    static encoder_t make_encoder(node const& decoder) {
+      auto ret = encoder_t();
+
+      encoder_rec(&decoder, std::vector<bool>(), ret);
+
+      return ret;
+    }
+  };
+
+  auto decoder = helper::make_decoder(first, last);
+  auto encoder = helper::make_encoder(*decoder);
+  underlying_ = std::make_shared<data const>(
+      data{std::move(decoder), std::move(encoder)});
+}
+
+template <class Iter>
+std::vector<bool> codebook::encode(Iter const first, Iter const last) const {
+  std::vector<bool> ret;
+
+  auto& encoder = underlying_->encoder;
+  std::for_each(first, last, [&ret, &encoder](char c) {
+    auto const it =
+        std::find_if(begin(encoder), end(encoder), [c](auto const& p) {
+          return p.first == c;
+        });
+    if (it != end(encoder)) {
+      auto const& code = it->second;
+      std::copy(begin(code), end(code), std::back_inserter(ret));
+    } else {
+      throw std::invalid_argument(
+          "The range has a character which was not in the huffman set");
+    }
+  });
+
+  return ret;
+}
+
+template <class Iter>
+std::string codebook::decode(Iter const first, Iter const last) const {
+  std::string ret;
+
+  node const* const top = underlying_->decoder.get();
+
+  // returns a pair:
+  // the second member is the decoded character
+  // the first member is the place we've gotten to in the range
+  // i.e., if [0] is an 'a', and we have
+  // [it, last) = { 0, 1, 1, 0 }
+  // we return (it', 'a') such that
+  // [it', last) = { 1, 1, 0 }
+  auto decode_single =
+      [top](Iter it, Iter const last) -> std::pair<Iter, char> {
+    node const* current_node = top;
+
+    for (; it != last; ++it) {
+      if (auto l = dynamic_cast<leaf const*>(current_node)) {
+        return std::make_pair(it, l->key);
+      } else if (auto b = dynamic_cast<branch const*>(current_node)) {
+        if (*it) {
+          current_node = b->rhs.get();
+        } else {
+          current_node = b->lhs.get();
+        }
+      } else {
+        unreachable();
+      }
+    }
+
+    if (auto l = dynamic_cast<leaf const*>(current_node)) {
+      return std::make_pair(last, l->key);
+    } else {
+      throw std::invalid_argument(
+          "The range was not encoded with this huffman set");
+    }
+  };
+
+  for (auto it = first; it != last;) {
+    auto p = decode_single(it, last);
+    it = p.first;
+    ret.push_back(p.second);
+  }
+
+  return ret;
+}
+
+} // namespace huffman
+
+int main() {
+  std::string to_be_encoded =
+      R"(She should have died hereafter.
+There would have been a time for such a word.
+Tomorrow, and tomorrow, and tomorrow,
+Creeps in this petty pace from day to day
+To the last syllable of recorded time,
+And all our yesterdays have lighted fools
+The way to dusty death. Out, out, brief candle!
+Life's but a walking shadow, a poor player
+That struts and frets his hour upon the stage
+And then is heard no more. It is a tale
+Told by an idiot, full of sound and fury,
+Signifying nothing.)";
+
+  auto encoded = huffman::encoded_string(to_be_encoded);
+
+  std::cout << "Encoded, the string looks like: ";
+  for (bool b : encoded.string) {
+    std::cout << b;
+  }
+  std::cout << "\nand decoded, the string looks like: " << encoded.decoded();
+  std::cout << "\n\nAs opposed to the original, which is "
+            << to_be_encoded.size() * 8 << " bits, the encoded has size "
+            << encoded.string.size() << ".\n";
+}

chapters/data_compression/huffman/huffman.md

@@ -86,4 +86,7 @@ Whether you use a stack or straight-up recursion also depends on the language, b
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/haskell/huffman.hs)
+{% sample lang="cpp" %}
+### C++
+[import, lang:"cpp"](code/c++/huffman.cpp)
 {% endmethod %}