libfaster API Documentation  Development Version
Super fast distributted computing
workerIFddDependent.cpp
1 #include <list>
2 #include <iostream>
3 #include <chrono>
4 
5 
6 #include "_workerIFdd.h"
7 #include "indexedFddStorageExtern.cpp"
8 
9  using std::chrono::system_clock;
10  using std::chrono::duration_cast;
11  using std::chrono::milliseconds;
12 
13 // --------- MAP
14 template <typename K, typename T>
15 template <typename L, typename U>
16 void faster::_workerIFdd<K,T>::map (workerFddBase * dest, ImapIFunctionP<K,T,L,U> mapFunc){
17  T * d = this->localData->getData();
18  size_t s = this->localData->getSize();
19  K * ik = (K*) this->localData->getKeys();
20  L * ok = (L*) dest->getKeys();
21  U * od = (U*) dest->getData();
22 
23  //std::cerr << "START\n" ;
24 
25  //#pragma omp target map(to:ik,d) map(from:ok,od)
26  #pragma omp parallel for
27  for (size_t i = 0; i < s; ++i){
28  std::pair<L,U> r = mapFunc(ik[i], d[i]);
29  ok[i] = r.first;
30  od[i] = r.second;
31  }
32  //std::cerr << "END\n";
33 }
34 
35 /*template <typename K, typename T>
36 template <typename L, typename U>
37 void faster::_workerIFdd<K,T>::map (workerFddBase * dest, IPmapIFunctionP<K,T,L,U> mapFunc){
38  T * d = this->localData->getData();
39  size_t s = this->localData->getSize();
40  K * ik = (K*) this->localData->getKeys();
41  size_t * ols = dest->getLineSizes() ;
42  L * ok = (L*) dest->getKeys();
43  U * od = (U*) dest->getData();
44 
45  //std::cerr << "START " << id << " " << s << " ";
46 
47  #pragma omp parallel for
48  for (size_t i = 0; i < s; ++i){
49  //mapFunc(ok[i], od[i], ols[i], d[i]);
50  std::tuple <L,U,size_t> r = mapFunc(ik[i], d[i]);
51  ok[i] = std::get<0>(r);
52  od[i] = std::get<1>(r);
53  ols[i] = std::get<2>(r);
54  }
55  //std::cerr << "END ";
56 }*/
57 
58 template <typename K, typename T>
59 template < typename U>
60 void faster::_workerIFdd<K,T>::map (workerFddBase * dest, mapIFunctionP<K,T,U> mapFunc){
61  T * d = this->localData->getData();
62  size_t s = this->localData->getSize();
63  K * ik = (K*) this->localData->getKeys();
64  U * od = (U*) dest->getData();
65 
66  //std::cerr << "START " << id << " " << s << " ";
67 
68  #pragma omp parallel for
69  for (size_t i = 0; i < s; ++i){
70  od[i] = mapFunc(ik[i], d[i]);
71  }
72  //std::cerr << "END ";
73 }
74 
75 /*template <typename K, typename T>
76 template <typename U>
77 void faster::_workerIFdd<K,T>::map (workerFddBase * dest, PmapIFunctionP<K,T,U> mapFunc){
78  T * d = this->localData->getData();
79  size_t s = this->localData->getSize();
80  K * ik = (K*) this->localData->getKeys();
81  size_t * ols = dest->getLineSizes() ;
82  U * od = (U*) dest->getData();
83 
84  //std::cerr << "START " << id << " " << s << " ";
85 
86  #pragma omp parallel for
87  for (size_t i = 0; i < s; ++i){
88  //mapFunc(od[i], ols[i], d[i]);
89  std::pair<U, size_t> r = mapFunc(ik[i], d[i]);
90  od[i] = r.first;
91  ols[i] = r.second;
92  }
93  //std::cerr << "END ";
94 }*/
95 
96 
97 template <typename K, typename T>
98 template <typename L, typename U>
99 void faster::_workerIFdd<K,T>::mapByKey (workerFddBase * dest, ImapByKeyIFunctionP<K,T,L,U> mapByKeyFunc){
100 
101  //auto start = system_clock::now();
102  K * ik = (K*) this->localData->getKeys();
103  T * id = this->localData->getData();
104  size_t s = this->localData->getSize();
105 
106  //std::cerr << " MaprByKey\n";
107  //std::cerr << " MaprByKey T0:" << duration_cast<milliseconds>(system_clock::now() - start).count() << " ";
108  //start = system_clock::now();
109 
110  auto kL = this->findKeyInterval(ik, id, s);
111  //std::cerr << "T1:" << duration_cast<milliseconds>(system_clock::now() - start).count() << " ";
112  //start = system_clock::now();
113 
114  //dest->setSize(this->uKeys->size());
115  //std::cerr << "\n";
116  //std::cerr << " SetSize: " << this->uKeys->size() << "\n";
117  dest->setSize(this->uKeys->size());
118  L * ok = (L*) dest->getKeys();
119  U * od = (U*) dest->getData();
120  //std::cerr << "T2:" << duration_cast<milliseconds>(system_clock::now() - start).count() << " ";
121  //start = system_clock::now();
122 
123 
124  //std::cerr << "T3:" << duration_cast<milliseconds>(system_clock::now() - start).count() << " ";
125  //start = system_clock::now();
126 
127  #pragma omp parallel for
128  for (size_t i = 0; i < this->uKeys->size(); i++){
129  std::pair<L,U> r = mapByKeyFunc((*this->uKeys)[i], kL[i]);
130 
131  ok[i] = r.first;
132  od[i] = r.second;
133  }
134  //std::cerr << "T4:" << duration_cast<milliseconds>(system_clock::now() - start).count() << "\n";
135  //start = system_clock::now();
136  //std::cerr << " DONE\n";
137 
138 
139 }
140 
141 /*template <typename K, typename T>
142 template <typename L, typename U>
143 void faster::_workerIFdd<K,T>::mapByKey (workerFddBase * dest, IPmapByKeyIFunctionP<K,T,L,U> mapByKeyFunc){
144 
145  T * d = this->localData->getData();
146  size_t s = this->localData->getSize();
147  K * ik = (K*) this->localData->getKeys();
148  size_t * ols = dest->getLineSizes() ;
149 
150  auto keyLocations = this->findKeyInterval(ik, d, s);
151  //dest->setSize(this->uKeys->size());
152  dest->setSize(keyLocations.size());
153  L * ok = (L*) dest->getKeys();
154  U * od = (U*) dest->getData();
155 
156 
157  #pragma omp parallel for
158  for (size_t i = 0; i < this->uKeys->size(); ++i){
159  //K & key = (*this->uKeys)[i];
160  //auto loc = keyLocations.find(key);
161  K & key = (*this->uKeys)[i];
162  auto loc = keyLocations[i];
163 
164  std::tuple <L,U,size_t> r = mapByKeyFunc(key, loc);
165 
166  ok[i] = std::get<0>(r);
167  od[i] = std::get<1>(r);
168  ols[i] = std::get<2>(r);
169 
170  delete loc;
171  }
172 }*/
173 
174 template <typename K, typename T>
175 template < typename U>
176 void faster::_workerIFdd<K,T>::mapByKey (workerFddBase * dest, mapByKeyIFunctionP<K,T,U> mapByKeyFunc){
177 
178  T * d = this->localData->getData();
179  size_t s = this->localData->getSize();
180  K * ik = (K*) this->localData->getKeys();
181 
182  auto keyLocations = this->findKeyInterval(ik, d, s);
183  //dest->setSize(this->uKeys->size());
184  dest->setSize(keyLocations.size());
185  U * od = (U*) dest->getData();
186 
187 
188  #pragma omp parallel for
189  for (size_t i = 0; i < this->uKeys->size(); ++i){
190  //K & key = (*this->uKeys)[i];
191  //auto loc = keyLocations.find(key);
192  K & key = (*this->uKeys)[i];
193  auto loc = keyLocations[i];
194 
195  od[i] = mapByKeyFunc(key, loc);
196 
197  }
198 }
199 
200 /*template <typename K, typename T>
201 template <typename U>
202 void faster::_workerIFdd<K,T>::mapByKey (workerFddBase * dest, PmapByKeyIFunctionP<K,T,U> mapByKeyFunc){
203 
204  T * d = this->localData->getData();
205  size_t s = this->localData->getSize();
206  K * ik = (K*) this->localData->getKeys();
207 
208  auto keyLocations = this->findKeyInterval(k, d, s);
209  //dest->setSize(this->uKeys->size());
210  dest->setSize(keyLocations.size());
211  size_t * ols = dest->getLineSizes() ;
212  U * od = (U*) dest->getData();
213 
214  //std::cerr << "START " << id << " " << s << " ";
215 
216 
217  #pragma omp parallel for
218  for (size_t i = 0; i < this->uKeys->size(); ++i){
219  //K & key = (*this->uKeys)[i];
220  //auto loc = keyLocations.find(key);
221  K & key = (*this->uKeys)[i];
222  auto loc = keyLocations[i];
223 
224  std::pair<U, size_t> r = mapByKeyFunc(key, loc);
225 
226  od[i] = r.first;
227  ols[i] = r.second;
228 
229  delete loc;
230  }
231  //std::cerr << "END ";
232 }*/
233 
234 
235 
236 // --------- BulkMAP
237 template <typename K, typename T>
238 template <typename L, typename U>
239 void faster::_workerIFdd<K,T>::bulkMap (workerFddBase * dest, IbulkMapIFunctionP<K,T,L,U> bulkMapFunc){
240  bulkMapFunc((L*) (dest->getKeys()), (U *) dest->getData(), (K*) this->localData->getKeys(), (T *)this->localData->getData(), this->localData->getSize());
241 }
242 /*template <typename K, typename T>
243 template <typename L, typename U>
244 void faster::_workerIFdd<K,T>::bulkMap (workerFddBase * dest, IPbulkMapIFunctionP<K,T,L,U> bulkMapFunc){
245  bulkMapFunc((L*) (dest->getKeys()), (U*) dest->getData(), dest->getLineSizes(), (K*) this->localData->getKeys(), (T *) this->localData->getData(), this->localData->getSize());
246 }*/
247 template <typename K, typename T>
248 template <typename U>
249 void faster::_workerIFdd<K,T>::bulkMap (workerFddBase * dest, bulkMapIFunctionP<K,T,U> bulkMapFunc){
250  bulkMapFunc((U*) dest->getData(), (K*) this->localData->getKeys(), (T *)this->localData->getData(), this->localData->getSize());
251 }
252 /*template <typename K, typename T>
253 template <typename U>
254 void faster::_workerIFdd<K,T>::bulkMap (workerFddBase * dest, PbulkMapIFunctionP<K,T,U> bulkMapFunc){
255  bulkMapFunc((U*) dest->getData(), dest->getLineSizes(), (K*) this->localData->getKeys(), (T *) this->localData->getData(), this->localData->getSize());
256 }*/
257 
258 
259 // --------- FlatMAP
260 
261 template <typename K, typename T>
262 template <typename L, typename U>
263 void faster::_workerIFdd<K,T>::flatMap(workerFddBase * dest, IflatMapIFunctionP<K,T,L,U> flatMapFunc ){
264  T * d = this->localData->getData();
265  size_t s = this->localData->getSize();
266  K * ik = (K*) this->localData->getKeys();
267  std::deque<std::pair<L,U>> resultList;
268 
269  #pragma omp parallel
270  {
271  std::deque<std::pair<L,U>> partResultList;
272 
273  #pragma omp for
274  for (size_t i = 0; i < s; ++i){
275  std::deque<std::pair<L,U>> r = flatMapFunc(ik[i], d[i]);
276 
277  partResultList.insert(partResultList.end(), r.begin(), r.end());
278  }
279 
280  #pragma omp critical
281  resultList.insert(resultList.end(), partResultList.begin(), partResultList.end() );
282 
283  }
284  dest->insertl(&resultList);
285 }
286 /*template <typename K, typename T>
287 template <typename L, typename U>
288 void faster::_workerIFdd<K,T>::flatMap(workerFddBase * dest, IPflatMapIFunctionP<K,T,L,U> flatMapFunc ){
289  T * d = this->localData->getData();
290  size_t s = this->localData->getSize();
291  K * ik = (K*) this->localData->getKeys();
292  std::deque< std::tuple<L, U, size_t> > resultList;
293 
294  #pragma omp parallel
295  {
296  std::deque<std::tuple<L, U, size_t>> partResultList;
297 
298  #pragma omp for
299  for (size_t i = 0; i < s; ++i){
300  std::deque<std::tuple<L, U, size_t>> r = flatMapFunc(ik[i], d[i]);
301 
302  partResultList.insert(partResultList.end(), r.begin(), r.end());
303  }
304 
305  #pragma omp critical
306  resultList.insert(resultList.end(), partResultList.begin(), partResultList.end() );
307 
308  }
309  dest->insertl(&resultList);
310 }*/
311 template <typename K, typename T>
312 template <typename U>
313 void faster::_workerIFdd<K,T>::flatMap(workerFddBase * dest, flatMapIFunctionP<K,T,U> flatMapFunc ){
314  T * d = this->localData->getData();
315  size_t s = this->localData->getSize();
316  K * ik = (K*) this->localData->getKeys();
317  std::deque<U> resultList;
318 
319  #pragma omp parallel
320  {
321  std::deque<U> partResultList;
322 
323  #pragma omp for
324  for (size_t i = 0; i < s; ++i){
325  std::deque<U> r = flatMapFunc(ik[i], d[i]);
326 
327  partResultList.insert(partResultList.end(), r.begin(), r.end());
328  }
329 
330  #pragma omp critical
331  resultList.insert(resultList.end(), partResultList.begin(), partResultList.end() );
332 
333  }
334  dest->insertl(&resultList);
335 }
336 /*template <typename K, typename T>
337 template <typename U>
338 void faster::_workerIFdd<K,T>::flatMap(workerFddBase * dest, PflatMapIFunctionP<K,T,U> flatMapFunc ){
339  T * d = this->localData->getData();
340  size_t s = this->localData->getSize();
341  K * ik = (K*) this->localData->getKeys();
342  std::deque< std::pair<U, size_t> > resultList;
343 
344  #pragma omp parallel
345  {
346  std::deque<std::pair<U, size_t>> partResultList;
347 
348  #pragma omp for
349  for (size_t i = 0; i < s; ++i){
350  std::deque<std::pair<U, size_t>> r = flatMapFunc(ik[i], d[i]);
351 
352  partResultList.insert(partResultList.end(), r.begin(), r.end());
353  }
354 
355  #pragma omp critical
356  resultList.insert(resultList.end(), partResultList.begin(), partResultList.end() );
357 
358  }
359  dest->insertl(&resultList);
360 }*/
361 template <typename K, typename T>
362 template <typename L, typename U>
363 void faster::_workerIFdd<K,T>::bulkFlatMap(workerFddBase * dest, IbulkFlatMapIFunctionP<K,T,L,U> bulkFlatMapFunc ){
364  L * ok;
365  U * result;
366  size_t rSize;
367 
368  bulkFlatMapFunc(ok, result, rSize, this->localData->getKeys(), this->localData->getData(), this->localData->getSize());
369  dest->setData(ok, result, rSize);
370  delete [] ok;
371  delete [] result;
372 }
373 /*template <typename K, typename T>
374 template <typename L, typename U>
375 void faster::_workerIFdd<K,T>::bulkFlatMap(workerFddBase * dest, IPbulkFlatMapIFunctionP<K,T,L,U> bulkFlatMapFunc ){
376  L * ok;
377  U * result;
378  size_t * rDataSizes = NULL;
379  size_t rSize;
380 
381  bulkFlatMapFunc(ok, result, rDataSizes, rSize, this->localData->getKeys(), (T*) this->localData->getData(), this->localData->getSize());
382  dest->setData( ok, result, rDataSizes, rSize);
383 }*/
384 template <typename K, typename T>
385 template <typename U>
386 void faster::_workerIFdd<K,T>::bulkFlatMap(workerFddBase * dest, bulkFlatMapIFunctionP<K,T,U> bulkFlatMapFunc ){
387  U * result;
388  size_t rSize;
389 
390  bulkFlatMapFunc(result, rSize, this->localData->getKeys(), this->localData->getData(), this->localData->getSize());
391  dest->setData(result, rSize);
392  delete [] result;
393 }
394 /*template <typename K, typename T>
395 template <typename U>
396 void faster::_workerIFdd<K,T>::bulkFlatMap(workerFddBase * dest, PbulkFlatMapIFunctionP<K,T,U> bulkFlatMapFunc ){
397  U * result;
398  size_t * rDataSizes = NULL;
399  size_t rSize;
400 
401  bulkFlatMapFunc( result, rDataSizes, rSize, this->localData->getKeys(), (T*) this->localData->getData(), this->localData->getSize());
402  dest->setData( result, rDataSizes, rSize);
403 }*/
404 
405 
406 
407 // Not Pointer -> Not Pointer
408 template <class K, class T>
409 template <typename L, typename U>
410 void faster::_workerIFdd<K,T>::_applyI(void * func, fddOpType op, workerFddBase * dest){
411  switch (op){
412  case OP_Map:
413  map<L,U>(dest, (ImapIFunctionP<K,T,L,U>) func);
414  //std::cerr << " Map \n";
415  break;
416  case OP_MapByKey:
417  mapByKey<L,U>(dest, (ImapByKeyIFunctionP<K,T,L,U>) func);
418  //std::cerr << " MapByKey \n";
419  break;
420  case OP_BulkMap:
421  bulkMap<L,U>(dest, ( IbulkMapIFunctionP<K,T,L,U> ) func);
422  //std::cerr << " BulkMap \n";
423  break;
424  case OP_FlatMap:
425  flatMap<L,U>(dest, ( IflatMapIFunctionP<K,T,L,U> ) func);
426  //std::cerr << " FlatMap \n";
427  break;
428  case OP_BulkFlatMap:
429  bulkFlatMap<L,U>(dest, ( IbulkFlatMapIFunctionP<K,T,L,U> ) func);
430  //std::cerr << " BulkFlatMap \n";
431  break;
432  }
433 }
434 
435 // Not Pointer -> Pointer
436 /*template <class K, class T>
437 template <typename L, typename U>
438 void faster::_workerIFdd<K,T>::_applyIP(void * func, fddOpType op, workerFddBase * dest){
439  switch (op){
440  case OP_Map:
441  map<L,U>(dest, (IPmapIFunctionP<K,T,L,U>) func);
442  std::cerr << " Map \n";
443  break;
444  case OP_MapByKey:
445  mapByKey<L,U>(dest, (IPmapByKeyIFunctionP<K,T,L,U>) func);
446  std::cerr << " MapByKey \n";
447  break;
448  case OP_BulkMap:
449  bulkMap<L,U>(dest, ( IPbulkMapIFunctionP<K,T,L,U> ) func);
450  std::cerr << " BulkMap \n";
451  break;
452  case OP_FlatMap:
453  flatMap<L,U>(dest, ( IPflatMapIFunctionP<K,T,L,U> ) func);
454  std::cerr << " FlatMap \n";
455  break;
456  case OP_BulkFlatMap:
457  bulkFlatMap<L,U>(dest, ( IPbulkFlatMapIFunctionP<K,T,L,U> ) func);
458  std::cerr << " BulkFlatMap \n";
459  break;
460  }
461 }// */
462 
463 // Not Pointer -> Not Pointer
464 template <class K, class T>
465 template <typename U>
466 void faster::_workerIFdd<K,T>::_apply(void * func, fddOpType op, workerFddBase * dest){
467  switch (op){
468  case OP_Map:
469  map<U>(dest, (mapIFunctionP<K,T,U>) func);
470  //std::cerr << " Map \n";
471  break;
472  case OP_MapByKey:
473  mapByKey<U>(dest, (mapByKeyIFunctionP<K,T,U>) func);
474  //std::cerr << " MapByKey \n";
475  break;
476  case OP_BulkMap:
477  bulkMap<U>(dest, ( bulkMapIFunctionP<K,T,U> ) func);
478  //std::cerr << " BulkMap \n";
479  break;
480  case OP_FlatMap:
481  flatMap<U>(dest, ( flatMapIFunctionP<K,T,U> ) func);
482  //std::cerr << " FlatMap \n";
483  break;
484  case OP_BulkFlatMap:
485  bulkFlatMap<U>(dest, ( bulkFlatMapIFunctionP<K,T,U> ) func);
486  //std::cerr << " BulkFlatMap \n";
487  break;
488  }
489 }
490 
491 // Not Pointer -> Pointer
492 /*template <class K, class T>
493 template <typename U>
494 void faster::_workerIFdd<K,T>::_applyP(void * func, fddOpType op, workerFddBase * dest){
495  switch (op){
496  case OP_Map:
497  map<U>(dest, (PmapIFunctionP<K,T,U>) func);
498  std::cerr << " Map \n";
499  break;
500  case OP_MapByKey:
501  mapByKey<U>(dest, (PmapByKeyIFunctionP<K,T,U>) func);
502  std::cerr << " MapByKey \n";
503  break;
504  case OP_BulkMap:
505  bulkMap<U>(dest, ( PbulkMapIFunctionP<K,T,U> ) func);
506  std::cerr << " BulkMap \n";
507  break;
508  case OP_FlatMap:
509  flatMap<U>(dest, ( PflatMapIFunctionP<K,T,U> ) func);
510  std::cerr << " FlatMap \n";
511  break;
512  case OP_BulkFlatMap:
513  bulkFlatMap<U>(dest, ( PbulkFlatMapIFunctionP<K,T,U> ) func);
514  std::cerr << " BulkFlatMap \n";
515  break;
516  }
517 }// */
518 
519 
520 template <class K, class T>
521 template <typename L>
522 void faster::_workerIFdd<K,T>::_preApplyI(void * func, fddOpType op, workerFddBase * dest){
523  switch (dest->getType()){
524  case Null: break;
525  case Char: _applyI<L,char> (func, op, dest); break;
526  case Int: _applyI<L,int> (func, op, dest); break;
527  case LongInt: _applyI<L,long int>(func, op, dest); break;
528  case Float: _applyI<L,float> (func, op, dest); break;
529  case Double: _applyI<L,double> (func, op, dest); break;
530  //case CharP: _applyIP<L,char *> (func, op, dest); break;
531  //case IntP: _applyIP<L,int *> (func, op, dest); break;
532  //case LongIntP: _applyIP<L,long int *> (func, op, dest); break;
533  //case FloatP: _applyIP<L,float *> (func, op, dest); break;
534  //case DoubleP: _applyIP<L,double *> (func, op, dest); break;
535  case String: _applyI<L,std::string>(func, op, dest); break;
536  //case Custom: _applyI(func, op, dest); break;
537  case CharV: _applyI<L,std::vector<char>> (func, op, dest); break;
538  case IntV: _applyI<L,std::vector<int>> (func, op, dest); break;
539  case LongIntV: _applyI<L,std::vector<long int>>(func, op, dest); break;
540  case FloatV: _applyI<L,std::vector<float>> (func, op, dest); break;
541  case DoubleV: _applyI<L,std::vector<double>> (func, op, dest); break;
542  }
543 
544 }
545 
546 template <class K, class T>
547 void faster::_workerIFdd<K,T>::_preApply(void * func, fddOpType op, workerFddBase * dest){
548  switch (dest->getType()){
549  case Null: break;
550  case Char: _apply<char> (func, op, dest); break;
551  case Int: _apply<int> (func, op, dest); break;
552  case LongInt: _apply<long int> (func, op, dest); break;
553  case Float: _apply<float> (func, op, dest); break;
554  case Double: _apply<double> (func, op, dest); break;
555  //case CharP: _applyP<char *> (func, op, dest); break;
556  //case IntP: _applyP<int *> (func, op, dest); break;
557  //case LongIntP: _applyP<long int *> (func, op, dest); break;
558  //case FloatP: _applyP<float *> (func, op, dest); break;
559  //case DoubleP: _applyP<double *> (func, op, dest); break;
560  case String: _apply<std::string>(func, op, dest); break;
561  //case Custom: _apply<void *>(func, op, dest); break;
562  case CharV: _apply<std::vector<char>> (func, op, dest); break;
563  case IntV: _apply<std::vector<int>> (func, op, dest); break;
564  case LongIntV:_apply<std::vector<long int>>(func, op, dest); break;
565  case FloatV: _apply<std::vector<float>> (func, op, dest); break;
566  case DoubleV: _apply<std::vector<double>> (func, op, dest); break;
567  }
568 
569 }
570 template <typename K, typename T>
571 void faster::_workerIFdd<K,T>::applyDependent(void * func, fddOpType op, workerFddBase * dest){
572  switch (dest->getKeyType()){
573  case Null: _preApply(func, op, dest);break;
574  case Char: _preApplyI<char>(func, op, dest); break;
575  case Int: _preApplyI<int>(func, op, dest); break;
576  case LongInt: _preApplyI<long int>(func, op, dest); break;
577  case Float: _preApplyI<float>(func, op, dest); break;
578  case Double: _preApplyI<double>(func, op, dest); break;
579  case String: _preApplyI<std::string>(func, op, dest); break;
580  }
581 }
582 
583 
584 
faster::_workerIFdd
Definition: _workerIFdd.h:139
faster
libfaster main namespace
Definition: _workerFdd.h:11