File: 06_math.ispc

package info (click to toggle)
ispc 1.26.0-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 95,356 kB
  • sloc: cpp: 55,778; python: 6,681; yacc: 3,074; lex: 1,095; ansic: 714; sh: 283; makefile: 16
file content (169 lines) | stat: -rw-r--r-- 11,733 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// Copyright (c) 2021-2024, Intel Corporation
// SPDX-License-Identifier: BSD-3-Clause

// math:
// sqrt, rsqrt / rsqrt_fast, rcp / rcp_fast, ldexp, frexp,
// sin, asin, cos, acos, sincos, tan, atan, atan2, exp, log, pow

#define SQRT(T)                                                                                                        \
    export void sqrt_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                          \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = sqrt(src[i]);                                                                                     \
        }                                                                                                              \
    }

#define RSQRT(T)                                                                                                       \
    export void rsqrt_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                         \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = rsqrt(src[i]);                                                                                    \
        }                                                                                                              \
    }

#define RSQRT_FAST(T)                                                                                                  \
    export void rsqrt_fast_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                    \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = rsqrt_fast(src[i]);                                                                               \
        }                                                                                                              \
    }

#define RCP(T)                                                                                                         \
    export void rcp_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                           \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = rcp(src[i]);                                                                                      \
        }                                                                                                              \
    }

#define RCP_FAST(T)                                                                                                    \
    export void rcp_fast_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                      \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = rcp_fast(src[i]);                                                                                 \
        }                                                                                                              \
    }

#define LDEXP(T)                                                                                                       \
    export void ldexp_##T(uniform T *uniform src1, uniform int *uniform src2, uniform T *uniform dst,                  \
                          uniform int count) {                                                                         \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = ldexp(src1[i], src2[i]);                                                                          \
        }                                                                                                              \
    }

#define FREXP(T)                                                                                                       \
    export void frexp_##T(uniform T *uniform src, uniform T *uniform dst1, uniform int *uniform dst2,                  \
                          uniform int count) {                                                                         \
        foreach (i = 0 ... count) {                                                                                    \
            varying int pow = 0;                                                                                       \
            dst1[i] = frexp(src[i], &pow);                                                                             \
            dst2[i] = pow;                                                                                             \
        }                                                                                                              \
    }

#define SIN(T)                                                                                                         \
    export void sin_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                           \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = sin(src[i]);                                                                                      \
        }                                                                                                              \
    }

#define ASIN(T)                                                                                                        \
    export void asin_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                          \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = asin(src[i]);                                                                                     \
        }                                                                                                              \
    }

#define COS(T)                                                                                                         \
    export void cos_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                           \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = cos(src[i]);                                                                                      \
        }                                                                                                              \
    }

#define ACOS(T)                                                                                                        \
    export void acos_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                          \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = acos(src[i]);                                                                                     \
        }                                                                                                              \
    }

// Missing sincos() here as it's not universallu available.

#define TAN(T)                                                                                                         \
    export void tan_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                           \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = tan(src[i]);                                                                                      \
        }                                                                                                              \
    }

#define ATAN(T)                                                                                                        \
    export void atan_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                          \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = atan(src[i]);                                                                                     \
        }                                                                                                              \
    }

#define ATAN2(T)                                                                                                       \
    export void atan2_##T(uniform T *uniform src1, uniform T *uniform src2, uniform T *uniform dst,                    \
                          uniform int count) {                                                                         \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = atan2(src1[i], src2[i]);                                                                          \
        }                                                                                                              \
    }

#define EXP(T)                                                                                                         \
    export void exp_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                           \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = exp(src[i]);                                                                                      \
        }                                                                                                              \
    }

#define LOG(T)                                                                                                         \
    export void log_##T(uniform T *uniform src, uniform T *uniform dst, uniform int count) {                           \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = log(src[i]);                                                                                      \
        }                                                                                                              \
    }

#define POW(T)                                                                                                         \
    export void pow_##T(uniform T *uniform src1, uniform T *uniform src2, uniform T *uniform dst, uniform int count) { \
        foreach (i = 0 ... count) {                                                                                    \
            dst[i] = pow(src1[i], src2[i]);                                                                            \
        }                                                                                                              \
    }

SQRT(float)
SQRT(double)
RSQRT(float)
RSQRT(double)
RSQRT_FAST(float)
RSQRT_FAST(double)
RCP(float)
RCP(double)
RCP_FAST(float)
RCP_FAST(double)
LDEXP(float)
LDEXP(double)
FREXP(float)
FREXP(double)

SIN(float)
SIN(double)
ASIN(float)
ASIN(double)
COS(float)
COS(double)
ACOS(float)
ACOS(double)
TAN(float)
TAN(double)
ATAN(float)
ATAN(double)
ATAN2(float)
ATAN2(double)

EXP(float)
EXP(double)
LOG(float)
LOG(double)
POW(float)
POW(double)