source: launchers/macosx/include/fn.h @ 1a00f73

Last change on this file since 1a00f73 was 281c5f57, checked in by meeh <meeh@…>, 2 years ago

Bugfixes, improvements, more error handling and stability to the osx launcher.

  • Property mode set to 100644
File size: 4.3 KB
Line 
1#ifndef FN_H
2#define FN_H
3
4#include <functional>
5#include <algorithm>
6
7/*
8 * higher-order functions
9 *
10 * Read
11 * http://blog.madhukaraphatak.com/functional-programming-in-c++/
12 *
13 *
14 * Lamda fingerprint:
15namespace {
16  struct f {
17    void operator()(int) {
18      // do something
19    }
20  };
21}
22 *
23 *
24 *
25template <typename Collection,typename unop>
26void for_each(Collection col, unop op){
27  std::for_each(col.begin(),col.end(),op);
28}
29
30Usage:
31
32auto lambda_echo = [](int i ) { std::cout << i << std::endl; };
33 std::vector<int> col{20,24,37,42,23,45,37};
34 for_each(col,lambda_echo);
35
36*/
37template <typename Collection,typename unop>
38void for_each(Collection col, unop op){
39  std::for_each(col.begin(),col.end(),op);
40}
41
42/**
43 * map
44 *
45 * Usage example:
46 auto addOne = [](int i) { return i+1;};
47 auto returnCol = map(col,addOne);
48 for_each(returnCol,lambda_echo);
49 *
50 *
51 *
52 */
53template <typename Collection,typename unop>
54Collection map(Collection col,unop op) {
55  std::transform(col.begin(),col.end(),col.begin(),op);
56  return col;
57}
58
59
60
61/*
62Filter usage:
63
64auto filteredCol = filter(col,[](int value){ return value > 30;});
65 for_each(filteredCol,lambda_echo);
66*/
67
68template <typename Collection,typename Predicate>
69Collection filterNot(Collection col,Predicate predicate ) {
70  auto returnIterator = std::remove_if(col.begin(),col.end(),predicate);
71  col.erase(returnIterator,std::end(col));
72  return col;
73}
74
75template <typename Collection,typename Predicate>
76Collection filter(Collection col,Predicate predicate) {
77 //capture the predicate in order to be used inside function
78 auto fnCol = filterNot(col,[predicate](typename Collection::value_type i) { return !predicate(i);});
79 return fnCol;
80}
81
82/**
83  *
84  * Alternative map implementations
85  *
86  **/
87template<class F, class T, class U=decltype(std::declval<F>()(std::declval<T>()))>
88std::vector<U> fmap(F f, const std::vector<T>& vec)
89{
90    std::vector<U> result;
91    std::transform(vec.begin(), vec.end(), std::back_inserter(result), f);
92    return result;
93}
94
95template<class F, class T, class U=decltype(std::declval<F>()(std::declval<T>()))>
96std::shared_ptr<U> fmap(F f, const std::shared_ptr<T>& p)
97{
98    if (p == nullptr) return nullptr;
99    else return std::shared_ptr<U>(new U(f(*p)));
100}
101
102
103/**
104 * Experimental code - should not be in production
105 */
106
107namespace Experimental {
108    template <typename T>
109    T min3(const T& a, const T& b, const T& c)
110    {
111       return std::min(std::min(a, b), c);
112    }
113
114    class LevenshteinDistance
115    {
116        mutable std::vector<std::vector<unsigned int> > matrix_;
117
118    public:
119        explicit LevenshteinDistance(size_t initial_size = 8)
120            : matrix_(initial_size, std::vector<unsigned int>(initial_size))
121        {
122        }
123
124        unsigned int operator()(const std::string& s, const std::string& t) const
125        {
126            const size_t m = s.size();
127            const size_t n = t.size();
128            // The distance between a string and the empty string is the string's length
129            if (m == 0) {
130                return (unsigned int)n;
131            }
132            if (n == 0) {
133                return (unsigned int)m;
134            }
135            // Size the matrix as necessary
136            if (matrix_.size() < m + 1) {
137                matrix_.resize(m + 1, matrix_[0]);
138            }
139            if (matrix_[0].size() < n + 1) {
140                for (auto& mat : matrix_) {
141                    mat.resize(n + 1);
142                }
143            }
144            // The top row and left column are prefixes that can be reached by
145            // insertions and deletions alone
146            unsigned int i, j;
147            for (i = 1;  i <= m; ++i) {
148                matrix_[i][0] = i;
149            }
150            for (j = 1; j <= n; ++j) {
151                matrix_[0][j] = j;
152            }
153            // Fill in the rest of the matrix
154            for (j = 1; j <= n; ++j) {
155                for (i = 1; i <= m; ++i) {
156                    unsigned int substitution_cost = s[i - 1] == t[j - 1] ? 0 : 1;
157                    matrix_[i][j] =
158                        min3(matrix_[i - 1][j] + 1,                 // Deletion
159                        matrix_[i][j - 1] + 1,                      // Insertion
160                        matrix_[i - 1][j - 1] + substitution_cost); // Substitution
161                }
162            }
163            return matrix_[m][n];
164        }
165    };
166}
167
168#endif // FN_H
Note: See TracBrowser for help on using the repository browser.