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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/**
* MathF library
* Contains tangent function, wrappers for a number of the handwritten functions in fp, and a suite of arctangents
*/
#include "libc64/math64.h"
#include "libc64/fixed_point.h"
#include "stdbool.h"
#include "math.h"
s32 gUseAtanContFrac;
/**
* Tangent function computed using libultra sinf and cosf
*/
f32 Math_FTanF(f32 x) {
return sinf(x) / cosf(x);
}
// Unused
f32 Math_FFloorF(f32 x) {
return floorf(x);
}
// Unused
f32 Math_FCeilF(f32 x) {
return ceilf(x);
}
// Unused
f32 Math_FRoundF(f32 x) {
return roundf(x);
}
// Unused
f32 Math_FTruncF(f32 x) {
return truncf(x);
}
f32 Math_FNearbyIntF(f32 x) {
return nearbyintf(x);
}
/**
* Arctangent approximation using a Maclaurin series [https://mathworld.wolfram.com/MaclaurinSeries.html]
* (one quadrant, i.e. |x| < 1)
*/
f32 Math_FAtanTaylorQF(f32 x) {
// Coefficients of Maclaurin series of arctangent
static const f32 coeffs[] = {
-1.0f / 3, +1.0f / 5, -1.0f / 7, +1.0f / 9, -1.0f / 11, +1.0f / 13, -1.0f / 15, +1.0f / 17, 0.0f,
};
f32 poly = x;
f32 sq = x * x;
f32 exp = x * sq;
const f32* c = coeffs;
f32 term;
// Calculate the series until adding more terms does not change the float
while (true) {
term = *c++ * exp;
if (poly + term == poly) {
break;
}
poly += term;
exp *= sq;
}
return poly;
}
/**
* Extends previous arctangent function to the rest of the real numbers.
* Uses the formulae arctan(x) = pi/2 - arctan(1/x)
* and arctan(x) = pi/4 - arctan( (1-x)/(1+x) )
* to extend the range in which the series computed by Math_FAtanTaylorQF is a good approximation
*/
f32 Math_FAtanTaylorF(f32 x) {
f32 t;
f32 q;
if (x > 0.0f) {
t = x;
} else if (x < 0.0f) {
t = -x;
} else if (x == 0.0f) {
return 0.0f;
} else {
return qNaN0x10000;
}
if (t <= M_SQRT2f - 1.0f) {
return Math_FAtanTaylorQF(x);
}
if (t >= M_SQRT2f + 1.0f) {
q = M_PIf / 2 - Math_FAtanTaylorQF(1.0f / t);
} else { // in the interval (\sqrt{2} - 1, \sqrt{2} + 1)
q = M_PIf / 4 - Math_FAtanTaylorQF((1.0f - t) / (1.0f + t));
}
if (x > 0.0f) {
return q;
} else {
return -q;
}
}
/**
* Arctangent approximation using a continued fraction
* Cf. https://en.wikipedia.org/wiki/Gauss%27s_continued_fraction#The_series_2F1_2 ,
* https://dlmf.nist.gov/4.25#E4
*/
f32 Math_FAtanContFracF(f32 x) {
s32 sector;
f32 z;
f32 conv;
f32 sq;
s32 i;
if (x >= -1.0f && x <= 1.0f) {
sector = 0;
} else if (x > 1.0f) {
sector = 1;
x = 1.0f / x;
} else if (x < -1.0f) {
sector = -1;
x = 1.0f / x;
} else {
return qNaN0x10000;
}
// Builds the continued fraction from the innermost fraction out
sq = x * x;
conv = 0.0f;
z = 8.0f;
for (i = 8; i > 0; i--) {
conv = (z * z) * sq / (2.0f * z + 1.0f + conv);
z -= 1.0f;
}
conv = x / (1.0f + conv);
if (sector == 0) {
return conv;
} else if (sector > 0) {
return M_PIf / 2 - conv;
} else {
return -M_PIf / 2 - conv;
}
}
/**
* Single-argument arctangent, only used by the two-argument function.
* Nothing else sets the bss variable gUseAtanContFrac, so the Maclaurin series is always used
*/
f32 Math_FAtanF(f32 x) {
if (!gUseAtanContFrac) {
return Math_FAtanTaylorF(x);
} else {
return Math_FAtanContFracF(x);
}
}
/**
* Main two-argument arctangent function
*/
f32 Math_FAtan2F(f32 y, f32 x) {
if (x == 0.0f) {
if (y == 0.0f) {
return 0.0f;
} else if (y > 0.0f) {
return M_PIf / 2;
} else if (y < 0.0f) {
return -M_PIf / 2;
} else {
return qNaN0x10000;
}
} else if (x >= 0.0f) {
return Math_FAtanF(y / x);
} else if (y < 0.0f) {
return Math_FAtanF(y / x) - M_PIf;
} else {
return M_PIf - Math_FAtanF(-(y / x));
}
}
f32 Math_FAsinF(f32 x) {
return Math_FAtan2F(x, sqrtf(1.0f - (x * x)));
}
f32 Math_FAcosF(f32 x) {
return M_PIf / 2 - Math_FAsinF(x);
}
|
