Build: hide most symbols on macOS on Linux to avoid conflicts
[blender.git] / source / blender / blenlib / BLI_math_base.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  *
19  * The Original Code is: some of this file.
20  *
21  * */
22
23 #ifndef __BLI_MATH_BASE_H__
24 #define __BLI_MATH_BASE_H__
25
26 /** \file
27  * \ingroup bli
28  */
29
30 #if defined(_MSC_VER) && !defined(_USE_MATH_DEFINES)
31 #  define _USE_MATH_DEFINES
32 #endif
33
34 #include "BLI_assert.h"
35 #include "BLI_math_inline.h"
36 #include <math.h>
37
38 #ifndef M_PI
39 #  define M_PI 3.14159265358979323846 /* pi */
40 #endif
41 #ifndef M_PI_2
42 #  define M_PI_2 1.57079632679489661923 /* pi/2 */
43 #endif
44 #ifndef M_PI_4
45 #  define M_PI_4 0.78539816339744830962 /* pi/4 */
46 #endif
47 #ifndef M_SQRT2
48 #  define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
49 #endif
50 #ifndef M_SQRT1_2
51 #  define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
52 #endif
53 #ifndef M_SQRT3
54 #  define M_SQRT3 1.73205080756887729352 /* sqrt(3) */
55 #endif
56 #ifndef M_SQRT1_3
57 #  define M_SQRT1_3 0.57735026918962576450 /* 1/sqrt(3) */
58 #endif
59 #ifndef M_1_PI
60 #  define M_1_PI 0.318309886183790671538 /* 1/pi */
61 #endif
62 #ifndef M_E
63 #  define M_E 2.7182818284590452354 /* e */
64 #endif
65 #ifndef M_LOG2E
66 #  define M_LOG2E 1.4426950408889634074 /* log_2 e */
67 #endif
68 #ifndef M_LOG10E
69 #  define M_LOG10E 0.43429448190325182765 /* log_10 e */
70 #endif
71 #ifndef M_LN2
72 #  define M_LN2 0.69314718055994530942 /* log_e 2 */
73 #endif
74 #ifndef M_LN10
75 #  define M_LN10 2.30258509299404568402 /* log_e 10 */
76 #endif
77
78 #if defined(__GNUC__)
79 #  define NAN_FLT __builtin_nanf("")
80 #else
81 /* evil quiet NaN definition */
82 static const int NAN_INT = 0x7FC00000;
83 #  define NAN_FLT (*((float *)(&NAN_INT)))
84 #endif
85
86 #if BLI_MATH_DO_INLINE
87 #  include "intern/math_base_inline.c"
88 #endif
89
90 #ifdef BLI_MATH_GCC_WARN_PRAGMA
91 #  pragma GCC diagnostic push
92 #  pragma GCC diagnostic ignored "-Wredundant-decls"
93 #endif
94
95 /******************************* Float ******************************/
96
97 MINLINE float pow2f(float x);
98 MINLINE float pow3f(float x);
99 MINLINE float pow4f(float x);
100 MINLINE float pow7f(float x);
101
102 MINLINE float sqrt3f(float f);
103 MINLINE double sqrt3d(double d);
104
105 MINLINE float sqrtf_signed(float f);
106
107 MINLINE float saacosf(float f);
108 MINLINE float saasinf(float f);
109 MINLINE float sasqrtf(float f);
110 MINLINE float saacos(float fac);
111 MINLINE float saasin(float fac);
112 MINLINE float sasqrt(float fac);
113
114 MINLINE float interpf(float a, float b, float t);
115 MINLINE double interpd(double a, double b, double t);
116
117 /* NOTE: Compilers will upcast all types smaller than int to int when performing arithmetic
118  * operation. */
119 MINLINE int square_s(short a);
120 MINLINE int square_uchar(unsigned char a);
121 MINLINE int cube_s(short a);
122 MINLINE int cube_uchar(unsigned char a);
123
124 MINLINE int square_i(int a);
125 MINLINE unsigned int square_uint(unsigned int a);
126 MINLINE float square_f(float a);
127 MINLINE double square_d(double a);
128
129 MINLINE int cube_i(int a);
130 MINLINE unsigned int cube_uint(unsigned int a);
131 MINLINE float cube_f(float a);
132 MINLINE double cube_d(double a);
133
134 MINLINE float min_ff(float a, float b);
135 MINLINE float max_ff(float a, float b);
136 MINLINE float min_fff(float a, float b, float c);
137 MINLINE float max_fff(float a, float b, float c);
138 MINLINE float min_ffff(float a, float b, float c, float d);
139 MINLINE float max_ffff(float a, float b, float c, float d);
140
141 MINLINE double min_dd(double a, double b);
142 MINLINE double max_dd(double a, double b);
143
144 MINLINE int min_ii(int a, int b);
145 MINLINE int max_ii(int a, int b);
146 MINLINE int min_iii(int a, int b, int c);
147 MINLINE int max_iii(int a, int b, int c);
148 MINLINE int min_iiii(int a, int b, int c, int d);
149 MINLINE int max_iiii(int a, int b, int c, int d);
150
151 MINLINE size_t min_zz(size_t a, size_t b);
152 MINLINE size_t max_zz(size_t a, size_t b);
153
154 MINLINE int clamp_i(int value, int min, int max);
155 MINLINE float clamp_f(float value, float min, float max);
156 MINLINE size_t clamp_z(size_t value, size_t min, size_t max);
157
158 MINLINE int compare_ff(float a, float b, const float max_diff);
159 MINLINE int compare_ff_relative(float a, float b, const float max_diff, const int max_ulps);
160
161 MINLINE float signf(float f);
162 MINLINE int signum_i_ex(float a, float eps);
163 MINLINE int signum_i(float a);
164
165 MINLINE float power_of_2(float f);
166
167 MINLINE int integer_digits_f(const float f);
168 MINLINE int integer_digits_d(const double d);
169 MINLINE int integer_digits_i(const int i);
170
171 /* these don't really fit anywhere but were being copied about a lot */
172 MINLINE int is_power_of_2_i(int n);
173 MINLINE int power_of_2_max_i(int n);
174 MINLINE int power_of_2_min_i(int n);
175
176 MINLINE unsigned int power_of_2_max_u(unsigned int x);
177 MINLINE unsigned int power_of_2_min_u(unsigned int x);
178 MINLINE unsigned int log2_floor_u(unsigned int x);
179 MINLINE unsigned int log2_ceil_u(unsigned int x);
180
181 MINLINE int divide_round_i(int a, int b);
182 MINLINE int mod_i(int i, int n);
183
184 MINLINE signed char round_fl_to_char(float a);
185 MINLINE unsigned char round_fl_to_uchar(float a);
186 MINLINE short round_fl_to_short(float a);
187 MINLINE unsigned short round_fl_to_ushort(float a);
188 MINLINE int round_fl_to_int(float a);
189 MINLINE unsigned int round_fl_to_uint(float a);
190
191 MINLINE signed char round_db_to_char(double a);
192 MINLINE unsigned char round_db_to_uchar(double a);
193 MINLINE short round_db_to_short(double a);
194 MINLINE unsigned short round_db_to_ushort(double a);
195 MINLINE int round_db_to_int(double a);
196 MINLINE unsigned int round_db_to_uint(double a);
197
198 MINLINE signed char round_fl_to_char_clamp(float a);
199 MINLINE unsigned char round_fl_to_uchar_clamp(float a);
200 MINLINE short round_fl_to_short_clamp(float a);
201 MINLINE unsigned short round_fl_to_ushort_clamp(float a);
202 MINLINE int round_fl_to_int_clamp(float a);
203 MINLINE unsigned int round_fl_to_uint_clamp(float a);
204
205 MINLINE signed char round_db_to_char_clamp(double a);
206 MINLINE unsigned char round_db_to_uchar_clamp(double a);
207 MINLINE short round_db_to_short_clamp(double a);
208 MINLINE unsigned short round_db_to_ushort_clamp(double a);
209 MINLINE int round_db_to_int_clamp(double a);
210 MINLINE unsigned int round_db_to_uint_clamp(double a);
211
212 int pow_i(int base, int exp);
213 double double_round(double x, int ndigits);
214
215 #ifdef BLI_MATH_GCC_WARN_PRAGMA
216 #  pragma GCC diagnostic pop
217 #endif
218
219 /* asserts, some math functions expect normalized inputs
220  * check the vector is unit length, or zero length (which can't be helped in some cases).
221  */
222 #ifndef NDEBUG
223 /** \note 0.0001 is too small because normals may be converted from short's: see T34322. */
224 #  define BLI_ASSERT_UNIT_EPSILON 0.0002f
225 /**
226  * \note Checks are flipped so NAN doesn't assert.
227  * This is done because we're making sure the value was normalized and in the case we
228  * don't want NAN to be raising asserts since there is nothing to be done in that case.
229  */
230 #  define BLI_ASSERT_UNIT_V3(v) \
231     { \
232       const float _test_unit = len_squared_v3(v); \
233       BLI_assert(!(fabsf(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON) || \
234                  !(fabsf(_test_unit) >= BLI_ASSERT_UNIT_EPSILON)); \
235     } \
236     (void)0
237
238 #  define BLI_ASSERT_UNIT_V2(v) \
239     { \
240       const float _test_unit = len_squared_v2(v); \
241       BLI_assert(!(fabsf(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON) || \
242                  !(fabsf(_test_unit) >= BLI_ASSERT_UNIT_EPSILON)); \
243     } \
244     (void)0
245
246 #  define BLI_ASSERT_UNIT_QUAT(q) \
247     { \
248       const float _test_unit = dot_qtqt(q, q); \
249       BLI_assert(!(fabsf(_test_unit - 1.0f) >= BLI_ASSERT_UNIT_EPSILON * 10) || \
250                  !(fabsf(_test_unit) >= BLI_ASSERT_UNIT_EPSILON * 10)); \
251     } \
252     (void)0
253
254 #  define BLI_ASSERT_ZERO_M3(m) \
255     { \
256       BLI_assert(dot_vn_vn((const float *)m, (const float *)m, 9) != 0.0); \
257     } \
258     (void)0
259
260 #  define BLI_ASSERT_ZERO_M4(m) \
261     { \
262       BLI_assert(dot_vn_vn((const float *)m, (const float *)m, 16) != 0.0); \
263     } \
264     (void)0
265 #  define BLI_ASSERT_UNIT_M3(m) \
266     { \
267       BLI_ASSERT_UNIT_V3((m)[0]); \
268       BLI_ASSERT_UNIT_V3((m)[1]); \
269       BLI_ASSERT_UNIT_V3((m)[2]); \
270     } \
271     (void)0
272 #else
273 #  define BLI_ASSERT_UNIT_V2(v) (void)(v)
274 #  define BLI_ASSERT_UNIT_V3(v) (void)(v)
275 #  define BLI_ASSERT_UNIT_QUAT(v) (void)(v)
276 #  define BLI_ASSERT_ZERO_M3(m) (void)(m)
277 #  define BLI_ASSERT_ZERO_M4(m) (void)(m)
278 #  define BLI_ASSERT_UNIT_M3(m) (void)(m)
279 #endif
280
281 #endif /* __BLI_MATH_BASE_H__ */