OpenLB 1.7
Loading...
Searching...
No Matches
omath.h
Go to the documentation of this file.
1/* This file is part of the OpenLB library
2 *
3 * Copyright (C) 2020 Jan E. Marquardt
4 * E-mail contact: info@openlb.net
5 * The most recent release of OpenLB can be downloaded at
6 * <http://www.openlb.net/>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public
19 * License along with this program; if not, write to the Free
20 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22*/
23
24#ifndef OLB_OMATH_H
25#define OLB_OMATH_H
26
27#include <iostream>
28#include <cmath>
29#include <cstdlib>
30#include <type_traits>
31
32namespace olb {
33
34namespace util {
35
36// Pow
37template <typename T, typename S>
38any_platform inline auto pow(T base, S exp) -> std::enable_if_t<std::is_arithmetic_v<T>,decltype(std::pow(base,exp))>
39{
40#ifdef __CUDA_ARCH__
41 return ::pow(base, exp);
42#else
43 return std::pow(base, exp);
44#endif
45}
46
47any_platform inline float powf(float base, float exp)
48{
49#ifdef __CUDA_ARCH__
50 return ::powf(base, exp);
51#else
52 return pow(base, exp);
53#endif
54}
55
56inline long double powl(long double base, long double exp)
57{
58 return pow(base, exp);
59}
60
61//fmod
62inline float fmod(float x, float y)
63{
64 return std::fmod(x, y);
65}
66
67inline float fmodf(float x, float y)
68{
69 return fmod(x, y);
70}
71
72inline double fmod(double x, double y)
73{
74 return std::fmod(x, y);
75}
76
77inline long double fmod(long double x, long double y)
78{
79 return std::fmod(x, y);
80}
81
82inline long double fmodl(long double x, long double y)
83{
84 return fmod(x, y);
85}
86
87inline float fmod(float x, int y)
88{
89 return std::fmod(x, y);
90}
91
92inline double fmod(double x, int y)
93{
94 return std::fmod(x, y);
95}
96
97inline long double fmod(long double x, int y)
98{
99 return std::fmod(x, y);
100}
101
102template <typename T, typename S>
103inline auto fmod(T x, S y)
104{
105 return std::fmod(x, y);
106}
107
108
109// Exp
110template <typename T>
111inline std::enable_if_t<std::is_floating_point_v<T>, T> exp(T arg) any_platform
112{
113 return std::exp(arg);
114}
115
116template <typename T>
117inline std::enable_if_t<std::is_integral_v<T>, double> exp(T arg) any_platform
118{
119 return std::exp(arg);
120}
121
122inline float expf(float arg)
123{
124 return exp(arg);
125}
126
127inline long double expl(long double arg)
128{
129 return exp(arg);
130}
131
132// Log
133inline float log(float arg)
134{
135 return std::log(arg);
136}
137
138inline float logf(float arg)
139{
140 return log(arg);
141}
142
143inline double log(double arg)
144{
145 return std::log(arg);
146}
147
148inline long double log(long double arg)
149{
150 return std::log(arg);
151}
152
153inline long double logl(long double arg)
154{
155 return log(arg);
156}
157
158template <typename T>
159inline std::enable_if_t<std::is_integral_v<T>, double> log(T arg)
160{
161 return std::log(arg);
162}
163
164// Log10
165inline float log10(float arg)
166{
167 return std::log10(arg);
168}
169
170inline float log10f(float arg)
171{
172 return log10(arg);
173}
174
175inline double log10(double arg)
176{
177 return std::log10(arg);
178}
179
180inline long double log10(long double arg)
181{
182 return std::log10(arg);
183}
184
185inline long double log10l(long double arg)
186{
187 return log10(arg);
188}
189
190template <typename T>
191inline std::enable_if_t<std::is_integral_v<T>, double> log10(T arg)
192{
193 return std::log10(arg);
194}
195
196// Log2
197inline float log2(float arg)
198{
199 return std::log2(arg);
200}
201
202inline float log2f(float arg)
203{
204 return log2(arg);
205}
206
207inline double log2(double arg)
208{
209 return std::log2(arg);
210}
211
212inline long double log2(long double arg)
213{
214 return std::log2(arg);
215}
216
217inline long double log2l(long double arg)
218{
219 return log2(arg);
220}
221
222template <typename T>
223inline std::enable_if_t<std::is_integral_v<T>, double> log2(T arg)
224{
225 return std::log2(arg);
226}
227
228// Log1p
229inline float log1p(float arg)
230{
231 return std::log1p(arg);
232}
233
234inline float log1pf(float arg)
235{
236 return log1p(arg);
237}
238
239inline double log1p(double arg)
240{
241 return std::log1p(arg);
242}
243
244inline long double log1p(long double arg)
245{
246 return std::log1p(arg);
247}
248
249inline long double log1pl(long double arg)
250{
251 return log1p(arg);
252}
253
254template <typename T>
255inline std::enable_if_t<std::is_integral_v<T>, double> log1p(T arg)
256{
257 return std::log1p(arg);
258}
259
260// Sqrt
261any_platform inline float sqrtf(float arg)
262{
263#ifdef __CUDA_ARCH__
264 return ::sqrtf(arg);
265#else
266 return sqrt(arg);
267#endif
268}
269
270inline long double sqrtl(long double arg)
271{
272 return sqrt(arg);
273}
274
275template <typename T>
276inline std::enable_if_t<std::is_floating_point_v<T>, T> sqrt(T arg) any_platform
277{
278#ifdef __CUDA_ARCH__
279 return ::sqrt(arg);
280#else
281 return std::sqrt(arg);
282#endif
283}
284
285template <typename T>
286inline std::enable_if_t<std::is_integral_v<T>, double> sqrt(T arg) any_platform
287{
288#ifdef __CUDA_ARCH__
289 return ::sqrt(arg);
290#else
291 return std::sqrt(arg);
292#endif
293}
294
295// Sin
296inline float sin(float arg)
297{
298 return std::sin(arg);
299}
300
301inline float sinf(float arg)
302{
303 return sin(arg);
304}
305
306inline double sin(double arg)
307{
308 return std::sin(arg);
309}
310
311inline long double sin(long double arg)
312{
313 return std::sin(arg);
314}
315
316inline long double sinl(long double arg)
317{
318 return sin(arg);
319}
320
321template <typename T>
322inline std::enable_if_t<std::is_integral_v<T>, double> sin(T arg)
323{
324 return std::sin(arg);
325}
326
327// Sinh
328inline float sinh(float arg)
329{
330 return std::sinh(arg);
331}
332
333inline float sinhf(float arg)
334{
335 return sinh(arg);
336}
337
338inline double sinh(double arg)
339{
340 return std::sinh(arg);
341}
342
343inline long double sinh(long double arg)
344{
345 return std::sinh(arg);
346}
347
348inline long double sinhl(long double arg)
349{
350 return sinh(arg);
351}
352
353template <typename T>
354inline std::enable_if_t<std::is_integral_v<T>, double> sinh(T arg)
355{
356 return std::sinh(arg);
357}
358
359// Cos
360inline float cos(float arg)
361{
362 return std::cos(arg);
363}
364
365inline float cosf(float arg)
366{
367 return cos(arg);
368}
369
370inline double cos(double arg)
371{
372 return std::cos(arg);
373}
374
375inline long double cos(long double arg)
376{
377 return std::cos(arg);
378}
379
380inline long double cosl(long double arg)
381{
382 return cos(arg);
383}
384
385template <typename T>
386inline std::enable_if_t<std::is_integral_v<T>, double> cos(T arg)
387{
388 return std::cos(arg);
389}
390
391// Cosh
392inline float cosh(float arg)
393{
394 return std::cosh(arg);
395}
396
397inline float coshf(float arg)
398{
399 return cosh(arg);
400}
401
402inline double cosh(double arg)
403{
404 return std::cosh(arg);
405}
406
407inline long double cosh(long double arg)
408{
409 return std::cosh(arg);
410}
411
412inline long double coshl(long double arg)
413{
414 return cosh(arg);
415}
416
417template <typename T>
418inline std::enable_if_t<std::is_integral_v<T>, double> cosh(T arg)
419{
420 return std::cosh(arg);
421}
422
423// Tan
424inline float tan(float arg)
425{
426 return std::tan(arg);
427}
428
429inline float tanf(float arg)
430{
431 return tan(arg);
432}
433
434inline double tan(double arg)
435{
436 return std::tan(arg);
437}
438
439inline long double tan(long double arg)
440{
441 return std::tan(arg);
442}
443
444inline long double tanl(long double arg)
445{
446 return tan(arg);
447}
448
449template <typename T>
450inline std::enable_if_t<std::is_integral_v<T>, double> tan(T arg)
451{
452 return std::tan(arg);
453}
454
455// Tanh
456inline float tanh(float arg)
457{
458 return std::tanh(arg);
459}
460
461inline float tanhf(float arg)
462{
463 return tanh(arg);
464}
465
466inline double tanh(double arg)
467{
468 return std::tanh(arg);
469}
470
471inline long double tanh(long double arg)
472{
473 return std::tanh(arg);
474}
475
476inline long double tanhl(long double arg)
477{
478 return tanh(arg);
479}
480
481template <typename T>
482inline std::enable_if_t<std::is_integral_v<T>, double> tanh(T arg)
483{
484 return std::tanh(arg);
485}
486
487// Asin
488inline float asin(float arg)
489{
490 return std::asin(arg);
491}
492
493inline float asinf(float arg)
494{
495 return asin(arg);
496}
497
498inline double asin(double arg)
499{
500 return std::asin(arg);
501}
502
503inline long double asin(long double arg)
504{
505 return std::asin(arg);
506}
507
508inline long double asinl(long double arg)
509{
510 return asin(arg);
511}
512
513template <typename T>
514inline std::enable_if_t<std::is_integral_v<T>, double> asin(T arg)
515{
516 return std::asin(arg);
517}
518
519// Asinh
520inline float asinh(float arg)
521{
522 return std::asinh(arg);
523}
524
525inline float asinhf(float arg)
526{
527 return asinh(arg);
528}
529
530inline double asinh(double arg)
531{
532 return std::asinh(arg);
533}
534
535inline long double asinh(long double arg)
536{
537 return std::asinh(arg);
538}
539
540inline long double asinhl(long double arg)
541{
542 return asinh(arg);
543}
544
545template <typename T>
546inline std::enable_if_t<std::is_integral_v<T>, double> asinh(T arg)
547{
548 return std::asinh(arg);
549}
550
551// Acos
552inline float acos(float arg)
553{
554 return std::acos(arg);
555}
556
557inline float acosf(float arg)
558{
559 return acos(arg);
560}
561
562inline double acos(double arg)
563{
564 return std::acos(arg);
565}
566
567inline long double acos(long double arg)
568{
569 return std::acos(arg);
570}
571
572inline long double acosl(long double arg)
573{
574 return acos(arg);
575}
576
577template <typename T>
578inline std::enable_if_t<std::is_integral_v<T>, double> acos(T arg)
579{
580 return std::acos(arg);
581}
582
583// Acosh
584inline float acosh(float arg)
585{
586 return std::acosh(arg);
587}
588
589inline float acoshf(float arg)
590{
591 return acosh(arg);
592}
593
594inline double acosh(double arg)
595{
596 return std::acosh(arg);
597}
598
599inline long double acosh(long double arg)
600{
601 return std::acosh(arg);
602}
603
604inline long double acoshl(long double arg)
605{
606 return acosh(arg);
607}
608
609template <typename T>
610inline std::enable_if_t<std::is_integral_v<T>, double> acosh(T arg)
611{
612 return std::acosh(arg);
613}
614
615// Atan
616inline float atan(float arg)
617{
618 return std::atan(arg);
619}
620
621inline float atanf(float arg)
622{
623 return atan(arg);
624}
625
626inline double atan(double arg)
627{
628 return std::atan(arg);
629}
630
631inline long double atan(long double arg)
632{
633 return std::atan(arg);
634}
635
636inline long double atanl(long double arg)
637{
638 return atan(arg);
639}
640
641template <typename T>
642inline std::enable_if_t<std::is_integral_v<T>, double> atan(T arg)
643{
644 return std::atan(arg);
645}
646
647// Atan2
648inline float atan2(float y, float x)
649{
650 return std::atan2(y, x);
651}
652
653inline float atan2f(float y, float x)
654{
655 return atan2(y, x);
656}
657
658inline double atan2(double y, double x)
659{
660 return std::atan2(y, x);
661}
662
663inline long double atan2(long double y, long double x)
664{
665 return std::atan2(y, x);
666}
667
668inline long double atan2l(long double y, long double x)
669{
670 return atan2(y, x);
671}
672
673template <typename T>
674inline std::enable_if_t<std::is_integral_v<T>, double> atan2(T y, T x)
675{
676 return std::atan2(y, x);
677}
678
679// Atanh
680inline float atanh(float arg)
681{
682 return std::atanh(arg);
683}
684
685inline float atanhf(float arg)
686{
687 return atanh(arg);
688}
689
690inline double atanh(double arg)
691{
692 return std::atanh(arg);
693}
694
695inline long double atanh(long double arg)
696{
697 return std::atanh(arg);
698}
699
700inline long double atanhl(long double arg)
701{
702 return atanh(arg);
703}
704
705template <typename T>
706inline std::enable_if_t<std::is_integral_v<T>, double> atanh(T arg)
707{
708 return std::atanh(arg);
709}
710
711
712// Rounding
713// floor
714inline float floor(float arg)
715{
716 return std::floor(arg);
717}
718
719inline double floor(double arg)
720{
721 return std::floor(arg);
722}
723
724inline long double floor(long double arg)
725{
726 return std::floor(arg);
727}
728
729inline float floorf(float arg)
730{
731 return floor(arg);
732}
733
734inline long double floorl(long double arg)
735{
736 return floor(arg);
737}
738
739template <typename T>
740inline std::enable_if_t<std::is_integral_v<T>, double> floor(T arg)
741{
742 return std::floor(arg);
743}
744
745// ceil
746inline float ceil(float arg)
747{
748 return std::ceil(arg);
749}
750
751inline double ceil(double arg)
752{
753 return std::ceil(arg);
754}
755
756inline long double ceil(long double arg)
757{
758 return std::ceil(arg);
759}
760
761inline float ceilf(float arg)
762{
763 return ceil(arg);
764}
765
766inline long double ceill(long double arg)
767{
768 return ceil(arg);
769}
770
771template <typename T>
772inline std::enable_if_t<std::is_integral_v<T>, double> ceil(T arg)
773{
774 return std::ceil(arg);
775}
776
777// trunc
778inline float trunc(float arg)
779{
780 return std::trunc(arg);
781}
782
783inline float truncf(float arg)
784{
785 return trunc(arg);
786}
787
788inline double trunc(double arg)
789{
790 return std::trunc(arg);
791}
792
793inline long double trunc(long double arg)
794{
795 return std::trunc(arg);
796}
797
798inline long double truncl(long double arg)
799{
800 return trunc(arg);
801}
802
803template <typename T>
804inline std::enable_if_t<std::is_integral_v<T>, double> trunc(T arg)
805{
806 return std::trunc(arg);
807}
808
809// round
810template <typename T>
811inline std::enable_if_t<std::is_integral_v<T>, double> round(T arg)
812{
813 return std::round(arg);
814}
815
816inline float round(float arg)
817{
818 return std::round(arg);
819}
820
821inline double round(double arg)
822{
823 return std::round(arg);
824}
825
826inline long double round(long double arg)
827{
828 return std::round(arg);
829}
830
831inline float roundf(float arg)
832{
833 return round(arg);
834}
835
836inline double roundf(double arg)
837{
838 return round(arg);
839}
840
841inline long double roundl(long double arg)
842{
843 return round(arg);
844}
845
846template <typename T>
847inline std::enable_if_t<std::is_arithmetic_v<T>, long> lround(T arg)
848{
849 return std::lround(arg);
850}
851
852inline long lroundf(float arg)
853{
854 return lround(arg);
855}
856
857inline long lroundl(long double arg)
858{
859 return lround(arg);
860}
861
862template <typename T>
863inline std::enable_if_t<std::is_arithmetic_v<T>, long long> llround(T arg)
864{
865 return std::llround(arg);
866}
867
868inline long long llroundf(float arg)
869{
870 return llround(arg);
871}
872
873inline long long llroundl(long double arg)
874{
875 return llround(arg);
876}
877
878
879// Absolute
880template <typename T>
881inline std::enable_if_t<std::is_arithmetic_v<T>, T> abs(T arg) any_platform
882{
883#ifdef __CUDA_ARCH__
884 return ::fabs(arg);
885#else
886 return std::abs(arg);
887#endif
888}
889
890template <typename T>
891inline std::enable_if_t<std::is_floating_point_v<T>, T> fabs(T arg) any_platform
892{
893#ifdef __CUDA_ARCH__
894 return ::fabs(arg);
895#else
896 return std::fabs(arg);
897#endif
898}
899
900template <typename T>
901inline std::enable_if_t<std::is_integral_v<T>, double> fabs(T arg) any_platform
902{
903#ifdef __CUDA_ARCH__
904 return ::fabs(arg);
905#else
906 return std::fabs(arg);
907#endif
908}
909
910inline long labs(long arg)
911{
912 return abs(arg);
913}
914
915inline long long llabs(long long arg)
916{
917 return abs(arg);
918}
919
920inline float fabsf(float arg)
921{
922 return fabs(arg);
923}
924
925inline long double fabs(long double arg)
926{
927 return std::fabs(arg);
928}
929
930inline long double fabsl(long double arg)
931{
932 return fabs(arg);
933}
934
935} // namespace util
936
937} // namespace olb
938
939#endif
ADf< T, DIM > labs(const ADf< T, DIM > &a)
Definition aDiff.h:1025
cpu::simd::Pack< T > sqrt(cpu::simd::Pack< T > value)
Definition pack.h:100
ADf< long double, DIM > fabsl(const ADf< long double, DIM > &a)
Definition aDiff.h:1013
long double atanl(long double arg)
Definition omath.h:636
ADf< T, DIM > abs(const ADf< T, DIM > &a)
Definition aDiff.h:1019
ADf< T, DIM > ceil(const ADf< T, DIM > &a)
Definition aDiff.h:900
ADf< T, DIM > floor(const ADf< T, DIM > &a)
Definition aDiff.h:869
float trunc(float arg)
Definition omath.h:778
long double fmodl(long double x, long double y)
Definition omath.h:82
ADf< T, DIM > tan(const ADf< T, DIM > &a)
Definition aDiff.h:587
float acoshf(float arg)
Definition omath.h:589
ADf< T, DIM > fmod(const ADf< T, DIM > &a, const ADf< T, DIM > &b)
Definition aDiff.h:703
long double asinl(long double arg)
Definition omath.h:508
long double sinl(long double arg)
Definition omath.h:316
ADf< T, DIM > atan2(const T &y, const ADf< T, DIM > &x)
Definition aDiff.h:623
long double tanhl(long double arg)
Definition omath.h:476
ADf< float, DIM > llroundf(const ADf< float, DIM > &a)
Definition aDiff.h:984
float atan2f(float y, float x)
Definition omath.h:653
ADf< T, DIM > asinh(const ADf< T, DIM > &a)
Definition aDiff.h:669
float cosf(float arg)
Definition omath.h:365
float truncf(float arg)
Definition omath.h:783
ADf< long double, DIM > log1pl(const ADf< long double, DIM > &a)
Definition aDiff.h:550
ADf< T, DIM > lround(const ADf< T, DIM > &a)
Definition aDiff.h:957
long double truncl(long double arg)
Definition omath.h:798
any_platform float sqrtf(float arg)
Definition omath.h:261
ADf< float, DIM > log10f(const ADf< float, DIM > &a)
Definition aDiff.h:505
ADf< T, DIM > log(const ADf< T, DIM > &a)
Definition aDiff.h:475
ADf< long double, DIM > expl(const ADf< long double, DIM > &a)
Definition aDiff.h:469
ADf< float, DIM > logf(const ADf< float, DIM > &a)
Definition aDiff.h:484
ADf< long double, DIM > log2l(const ADf< long double, DIM > &a)
Definition aDiff.h:532
long double asinhl(long double arg)
Definition omath.h:540
float asinhf(float arg)
Definition omath.h:525
long double atan2l(long double y, long double x)
Definition omath.h:668
long double tanl(long double arg)
Definition omath.h:444
long double sqrtl(long double arg)
Definition omath.h:270
ADf< float, DIM > roundf(const ADf< float, DIM > &a)
Definition aDiff.h:944
ADf< T, DIM > round(const ADf< T, DIM > &a)
Definition aDiff.h:928
float fmodf(float x, float y)
Definition omath.h:67
ADf< float, DIM > log2f(const ADf< float, DIM > &a)
Definition aDiff.h:526
ADf< long double, DIM > log10l(const ADf< long double, DIM > &a)
Definition aDiff.h:511
ADf< T, DIM > llround(const ADf< T, DIM > &a)
Definition aDiff.h:978
ADf< float, DIM > floorf(const ADf< float, DIM > &a)
Definition aDiff.h:888
ADf< T, DIM > sin(const ADf< T, DIM > &a)
Definition aDiff.h:569
ADf< float, DIM > expf(const ADf< float, DIM > &a)
Definition aDiff.h:463
ADf< T, DIM > acosh(const ADf< T, DIM > &a)
Definition aDiff.h:675
long double acosl(long double arg)
Definition omath.h:572
ADf< long double, DIM > floorl(const ADf< long double, DIM > &a)
Definition aDiff.h:894
ADf< float, DIM > fabsf(const ADf< float, DIM > &a)
Definition aDiff.h:1007
float coshf(float arg)
Definition omath.h:397
long double powl(long double base, long double exp)
Definition omath.h:56
long double acoshl(long double arg)
Definition omath.h:604
ADf< T, DIM > asin(const ADf< T, DIM > &a)
Definition aDiff.h:596
ADf< T, DIM > log1p(const ADf< T, DIM > &a)
Definition aDiff.h:538
cpu::simd::Pack< T > pow(cpu::simd::Pack< T > base, cpu::simd::Pack< T > exp)
Definition pack.h:112
float sinf(float arg)
Definition omath.h:301
long double sinhl(long double arg)
Definition omath.h:348
float acosf(float arg)
Definition omath.h:557
ADf< float, DIM > lroundf(const ADf< float, DIM > &a)
Definition aDiff.h:966
float tanhf(float arg)
Definition omath.h:461
ADf< T, DIM > cosh(const ADf< T, DIM > &a)
Definition aDiff.h:657
ADf< T, DIM > llabs(const ADf< T, DIM > &a)
Definition aDiff.h:1034
ADf< T, DIM > sinh(const ADf< T, DIM > &a)
Definition aDiff.h:651
cpu::simd::Pack< T > fabs(cpu::simd::Pack< T > value)
Definition pack.h:106
float atanhf(float arg)
Definition omath.h:685
long double atanhl(long double arg)
Definition omath.h:700
ADf< long double, DIM > lroundl(const ADf< long double, DIM > &a)
Definition aDiff.h:972
ADf< long double, DIM > roundl(const ADf< long double, DIM > &a)
Definition aDiff.h:950
ADf< T, DIM > acos(const ADf< T, DIM > &a)
Definition aDiff.h:605
ADf< long double, DIM > llroundl(const ADf< long double, DIM > &a)
Definition aDiff.h:990
any_platform float powf(float base, float exp)
Definition omath.h:47
float asinf(float arg)
Definition omath.h:493
long double cosl(long double arg)
Definition omath.h:380
float atanf(float arg)
Definition omath.h:621
ADf< long double, DIM > ceill(const ADf< long double, DIM > &a)
Definition aDiff.h:922
ADf< T, DIM > tanh(const ADf< T, DIM > &a)
Definition aDiff.h:663
float sinhf(float arg)
Definition omath.h:333
long double coshl(long double arg)
Definition omath.h:412
ADf< float, DIM > log1pf(const ADf< float, DIM > &a)
Definition aDiff.h:544
ADf< T, DIM > log10(const ADf< T, DIM > &a)
Definition aDiff.h:496
float tanf(float arg)
Definition omath.h:429
ADf< T, DIM > atan(const ADf< T, DIM > &a)
Definition aDiff.h:614
ADf< long double, DIM > logl(const ADf< long double, DIM > &a)
Definition aDiff.h:490
ADf< T, DIM > exp(const ADf< T, DIM > &a)
Definition aDiff.h:455
ADf< float, DIM > ceilf(const ADf< float, DIM > &a)
Definition aDiff.h:916
ADf< T, DIM > atanh(const ADf< T, DIM > &a)
Definition aDiff.h:689
ADf< T, DIM > log2(const ADf< T, DIM > &a)
Definition aDiff.h:517
ADf< T, DIM > cos(const ADf< T, DIM > &a)
Definition aDiff.h:578
Top level namespace for all of OpenLB.
#define any_platform
Define preprocessor macros for device-side functions, constant storage.
Definition platform.h:78