first version

cpp/functional.cpp

@@ -0,0 +1,112 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <algorithm>
+#include <utility>
+#include <cmath>
+#include <map>
+#include <queue>
+#include <cassert>
+#include <functional>
+
+#include "code.h"
+
+namespace neighbors {
+
+    using Neighborhood = std::function< neighbors_t(const point_t&) >;
+
+    template<typename F, typename...Fargs>
+    Neighborhood make(F f, const point_t& pmin, const point_t& pmax, double grid_step, Fargs...args)
+    {
+        return [f,pmin,pmax,grid_step,args...]
+            (const point_t& p)
+            ->neighbors_t
+            { return f(p, pmin, pmax, grid_step, args...); };
+    }
+
+    neighbors_t quad_grid(const point_t& p, const point_t& pmin, const point_t& pmax, double grid_step)
+    {
+        // neighborhood (list) of relative locations (vector)
+        // Should be given in [clockwise] order.
+        std::vector<point_t> directions{{1,0},{0,-1},{-1,0},{0,1}};
+        return neighbors_grid(p,grid_step,pmin,pmax,directions);
+    }
+
+    neighbors_t octo_grid(const point_t& p, const point_t& pmin, const point_t& pmax, double grid_step)
+    {
+        std::vector<point_t> directions{{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1},{0,1},{1,1}};
+        return neighbors_grid(p,grid_step,pmin,pmax,directions);
+    }
+}
+
+namespace transit {
+
+    using HopfLax = std::function< double(const point_t &, const neighbors_t  , const costs_t &) >;
+
+    template<typename F, typename...Fargs>
+    HopfLax make(F f, Fargs...args)
+    {
+        return [f,args...]
+            (const point_t & p, const neighbors_t neighbors, const costs_t & costs)
+            ->double
+            { return f(p, neighbors, costs, args...); };
+    }
+
+    double on_edge(const point_t & p, const neighbors_t & neighbors, const costs_t & costs)
+    {
+        return transit_on_edge(p,neighbors,costs);
+    }
+
+    double in_simplex(const point_t & p, const neighbors_t & neighbors, const costs_t & costs, double epsilon)
+    {
+        return transit_in_simplex(p,neighbors,costs,epsilon);
+    }
+
+}
+
+costs_t algo(neighbors::Neighborhood neighbors, transit::HopfLax transit, point_t seed, unsigned int iterations)
+{
+    return algo_run(seed, iterations, neighbors, transit);
+}
+
+
+int main()
+{
+    point_t seed; x(seed)= 0;y(seed)= 0;
+    point_t pmin; x(pmin)=-5;y(pmin)=-5;
+    point_t pmax; x(pmax)=15;y(pmax)=15;
+        assert(x(seed) <= x(pmax));
+        assert(x(seed) >= x(pmin));
+        assert(y(seed) <= y(pmax));
+        assert(y(seed) >= y(pmin));
+    double step = 1;
+    unsigned int maxit=300;
+    double eps = 1/100.0;
+
+    auto four  = neighbors::make(neighbors::quad_grid, pmin, pmax, step);
+    auto eight = neighbors::make(neighbors::octo_grid, pmin, pmax, step);
+
+    auto graph = transit::make(transit::on_edge);
+    auto mesh  = transit::make(transit::in_simplex, eps);
+
+    std::cout << "Dijkstra, 4 neighbors" << std::endl;
+    costs_t cd4 = algo(four, graph, seed, maxit);
+    std::cout << std::endl;
+    grid_print(cd4, pmin, pmax, step);
+
+    std::cout << "Fast marching, 4 neighbors" << std::endl;
+    costs_t cfm4 = algo(four, mesh, seed, maxit);
+    std::cout << std::endl;
+    grid_print(cfm4, pmin, pmax, step);
+
+    std::cout << "Dijkstra, 8 neighbors" << std::endl;
+    costs_t cd8 = algo(eight, graph, seed, maxit);
+    std::cout << std::endl;
+    grid_print(cd8, pmin, pmax, step);
+
+    std::cout << "Fast marching, 8 neighbors" << std::endl;
+    costs_t cfm8 = algo(eight, mesh, seed, maxit);
+    std::cout << std::endl;
+    grid_print(cfm8, pmin, pmax, step);
+}