Generative Fast Fourier Transforms (GFFT)  0.3
numtypelist.h
1 /***************************************************************************
2  * Copyright (C) 2009-2014 by Vladimir Mirnyy *
3  * *
4  * This program is free software; you can redistribute it and/or modify *
5  * it under the terms of the GNU General Public License as published by *
6  * the Free Software Foundation; either version 2 of the License, or *
7  * (at your option) any later version. *
8  * *
9  * This program is distributed in the hope that it will be useful, *
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12  * GNU General Public License for more details. *
13  ***************************************************************************/
14 
15 #ifndef __numtypelist_h
16 #define __numtypelist_h
17 
18 #include "Typelist.h"
19 
20 #include "sint.h"
21 
22 namespace NL {
23 
24 using namespace Loki;
25 
26 template<class TList> struct Print;
27 
28 template<> struct Print<NullType> { };
29 
30 template<class Head, class Tail>
31 struct Print<Typelist<Head,Tail> > {
32  typedef typename Print<Tail>::Result Result;
33 };
34 
41 
42  template <class NList> struct Max;
43  template <class Num>
44  struct Max< Typelist<Num,NullType> >
45  {
46  typedef Num Result;
47  };
48 
49  template <class Num, class Tail>
50  struct Max< Typelist<Num, Tail> >
51  {
52  private:
53  enum { temp = Max<Tail>::value };
54  public:
55  typedef SInt<(temp > Num::value) ? temp : Num::value> Result;
56  };
57 
64 
65  template <class NList> struct Min;
66  template <class Num>
67  struct Min< Typelist<Num,NullType> >
68  {
69  typedef Num Result;
70  };
71 
72  template <class Num, class Tail>
73  struct Min< Typelist<Num, Tail> >
74  {
75  private:
76  enum { temp = Min<Tail>::value };
77  public:
78  typedef SInt<(temp < Num::value) ? temp : Num::value> Result;
79  };
80 
88 
89  template <class NList, class Num> struct AddConst;
90  template <class Num>
91  struct AddConst<NullType,Num>
92  {
93  typedef NullType Result;
94  };
95 
96  template <class Head, class Tail, class Num>
97  struct AddConst<Typelist<Head,Tail>,Num>
98  {
99  typedef Typelist<SInt<Head::value + Num::value>,
100  typename AddConst<Tail,Num>::Result> Result;
101  };
102 
112 
113  template <class NList, unsigned int index, class Num> struct AddAt;
114 
115  template <class Head, class Tail, class Num>
116  struct AddAt<Typelist<Head, Tail>, 0, Num>
117  {
118  typedef Typelist<SInt<Head::value + Num::value>, Tail> Result;
119  };
120 
121  template <class Head, class Tail, unsigned int i, class Num>
122  struct AddAt<Typelist<Head, Tail>, i, Num>
123  {
124  typedef Typelist<Head,
125  typename AddAt<Tail, i-1, Num>::Result>
126  Result;
127  };
128 
137 
138  template <class NList1, class NList2> struct Add;
139 
140  template <>
141  struct Add<NullType,NullType>
142  {
143  typedef NullType Result;
144  };
145 
146  template <class Head, class Tail>
147  struct Add<NullType,Typelist<Head,Tail> >
148  {
149  typedef Typelist<Head,Tail> Result;
150  };
151 
152  template <class Head, class Tail>
153  struct Add<Typelist<Head,Tail>,NullType>
154  {
155  typedef Typelist<Head,Tail> Result;
156  };
157 
158  template <class Head1, class Tail1, class Head2, class Tail2>
159  struct Add<Typelist<Head1,Tail1>,Typelist<Head2,Tail2> >
160  {
161  typedef Typelist<SInt<Head1::value + Head2::value>,
162  typename Add<Tail1,Tail2>::Result> Result;
163  };
164 
165 
173 
174  template <class NList, class Num> struct SubConst;
175 
176  template <class Num>
177  struct SubConst<NullType,Num>
178  {
179  typedef NullType Result;
180  };
181 
182  template <class Head, class Tail, class Num>
183  struct SubConst<Typelist<Head,Tail>,Num>
184  {
185  typedef Typelist<SInt<Head::value - Num::value>,
186  typename SubConst<Tail,Num>::Result> Result;
187  };
188 
198 
199  template <class NList, unsigned int index, class Num> struct SubAt;
200 
201  template <class Head, class Tail, class Num>
202  struct SubAt<Typelist<Head, Tail>, 0, Num>
203  {
204  typedef Typelist<SInt<Head::value - Num::value>, Tail> Result;
205  };
206 
207  template <class Head, class Tail, unsigned int i, class Num>
208  struct SubAt<Typelist<Head, Tail>, i, Num>
209  {
210  typedef Typelist<Head,
211  typename SubAt<Tail, i-1, Num>::Result> Result;
212  };
213 
222 
223  template <class NList1, class NList2> struct Sub;
224 
225  template <>
226  struct Sub<NullType,NullType>
227  {
228  typedef NullType Result;
229  };
230 
231  template <class Head, class Tail>
232  struct Sub<NullType,Typelist<Head,Tail> >
233  {
234  typedef Typelist<Head,Tail> Result;
235  };
236 
237  template <class Head, class Tail>
238  struct Sub<Typelist<Head,Tail>,NullType>
239  {
240  typedef Typelist<Head,Tail> Result;
241  };
242 
243  template <class Head1, class Tail1, class Head2, class Tail2>
244  struct Sub<Typelist<Head1,Tail1>,Typelist<Head2,Tail2> >
245  {
246  typedef Typelist<SInt<Head1::value-Head2::value>,
247  typename Sub<Tail1,Tail2>::Result> Result;
248  };
249 
257 
258  template <class NList, class Num> struct MultConst;
259 
260  template <class Num>
261  struct MultConst<NullType,Num>
262  {
263  typedef NullType Result;
264  };
265 
266  template <class Head, class Tail, class Num>
267  struct MultConst<Typelist<Head,Tail>,Num>
268  {
269  typedef Typelist<SInt<Head::value * Num::value>,
270  typename MultConst<Tail,Num>::Result> Result;
271  };
272 
282 
283  template <class NList, unsigned int index, class Num> struct MultAt;
284 
285  template <class Head, class Tail, class Num>
286  struct MultAt<Typelist<Head, Tail>, 0, Num>
287  {
288  typedef Typelist<SInt<Head::value * Num::value>, Tail> Result;
289  };
290 
291  template <class Head, class Tail, unsigned int i, class Num>
292  struct MultAt<Typelist<Head, Tail>, i, Num>
293  {
294  typedef Typelist<Head,
295  typename MultAt<Tail, i-1, Num>::Result>
296  Result;
297  };
298 
307 
308  template <class NList1, class NList2> struct Mult;
309  template <>
310  struct Mult<NullType,NullType>
311  {
312  typedef NullType Result;
313  };
314 
315  template <class Head, class Tail>
316  struct Mult<NullType,Typelist<Head,Tail> >
317  {
318  typedef NullType Result;
319  };
320 
321  template <class Head, class Tail>
322  struct Mult<Typelist<Head,Tail>,NullType>
323  {
324  typedef Typelist<Head,Tail> Result;
325  };
326 
327  template <class Head1, class Tail1, class Head2, class Tail2>
328  struct Mult<Typelist<Head1,Tail1>,Typelist<Head2,Tail2> >
329  {
330  typedef Typelist<SInt<Head1::value*Head2::value>,
331  typename Add<Tail1,Tail2>::Result> Result;
332  };
333 
340 
341  template <class NList> struct Sum;
342  template <> struct Sum<NullType>
343  {
344  typedef SInt<0> Result;
345  };
346 
347  template <class Num, class Tail>
348  struct Sum< Typelist<Num, Tail> >
349  {
350  typedef SInt<Num::value + Sum<Tail>::Result::value> Result;
351  };
352 
362 
363  template <class NList1, class NList2> struct Compare;
364 
365  template <class H1, class T1, class H2, class T2>
366  struct Compare<Typelist<H1,T1>,Typelist<H2,T2> >
367  {
368  static const int v = Compare<T1,T2>::value;
369  static const int value = (v==0) ?
370  ((H1::value-H2::value)>0 ? 1 :
371  (H1::value==H2::value) ? 0 : -1) : v;
372  };
373 
374  template <class H, class T>
375  struct Compare<Typelist<H,T>,NullType>
376  {
377  static const int value = 1;
378  };
379 
380  template <class H, class T>
381  struct Compare<NullType,Typelist<H,T> >
382  {
383  static const int value = -1;
384  };
385 
386  template <class H1, class H2>
387  struct Compare<Typelist<H1,NullType>,Typelist<H2,NullType> >
388  {
389  static const int value = (H1::value-H2::value)>0 ? 1 :
390  (H1::value==H2::value) ? 0 : -1;
391  };
392 
399 
400  template <class NList> struct Sort;
401  template <> struct Sort<NullType>
402  {
403  typedef NullType Result;
404  };
405 
406  template <class Head, class Tail>
407  struct Sort<Typelist<Head,Tail> >
408  {
409  private:
410  typedef typename Min<Typelist<Head,Tail> >::Result _Min;
411  typedef typename TL::Replace<Tail,_Min,Head>::Result temp;
412 
413  public:
414  typedef Typelist<_Min,typename Sort<temp>::Result> Result;
415  };
416 
417 
418 template<typename NList>
419 struct NZeros;
420 
421 template<int_t N, typename Tail>
422 struct NZeros<Loki::Typelist<SInt<N>,Tail> > {
423  static const int_t value = NZeros<Tail>::value;
424 };
425 
426 template<typename Tail>
427 struct NZeros<Loki::Typelist<SInt<0>,Tail> > {
428  static const int_t value = NZeros<Tail>::value + 1;
429 };
430 
431 template<>
432 struct NZeros<Loki::NullType> {
433  static const int_t value = 0;
434 };
435 
436 
437 template<class NList>
438 struct CutTrailingZeros;
439 
440 template<class H, class Tail>
441 struct CutTrailingZeros<Loki::Typelist<H,Tail> > {
442  typedef Loki::Typelist<H, typename CutTrailingZeros<Tail>::Result> Result;
443 };
444 
445 template<class Tail>
446 struct CutTrailingZeros<Loki::Typelist<SInt<0>,Tail> > {
447  static const int Len = TL::Length<Tail>::value;
448  static const int NZ = NZeros<Tail>::value;
449  typedef typename Select<(Len == NZ), Loki::NullType,
450  Loki::Typelist<SInt<0>, typename CutTrailingZeros<Tail>::Result> >::Result Result;
451 };
452 
453 template<>
454 struct CutTrailingZeros<Loki::NullType> {
455  typedef Loki::NullType Result;
456 };
457 
458 } // namespace NL
459 
460 #endif
Generated on Mon Feb 10 2014 for Generative Fast Fourier Transforms (GFFT) by DoxyGen 1.8.3.1