Library of Assembled Shared Sources
basic_ops.h
Go to the documentation of this file.
1/** @file
2 * @author Bram de Greve (bram@cocamware.com)
3 * @author Tom De Muer (tom@cocamware.com)
4 *
5 * *** BEGIN LICENSE INFORMATION ***
6 *
7 * The contents of this file are subject to the Common Public Attribution License
8 * Version 1.0 (the "License"); you may not use this file except in compliance with
9 * the License. You may obtain a copy of the License at
10 * http://lass.sourceforge.net/cpal-license. The License is based on the
11 * Mozilla Public License Version 1.1 but Sections 14 and 15 have been added to cover
12 * use of software over a computer network and provide for limited attribution for
13 * the Original Developer. In addition, Exhibit A has been modified to be consistent
14 * with Exhibit B.
15 *
16 * Software distributed under the License is distributed on an "AS IS" basis, WITHOUT
17 * WARRANTY OF ANY KIND, either express or implied. See the License for the specific
18 * language governing rights and limitations under the License.
19 *
20 * The Original Code is LASS - Library of Assembled Shared Sources.
21 *
22 * The Initial Developer of the Original Code is Bram de Greve and Tom De Muer.
23 * The Original Developer is the Initial Developer.
24 *
25 * All portions of the code written by the Initial Developer are:
26 * Copyright (C) 2004-2011 the Initial Developer.
27 * All Rights Reserved.
28 *
29 * Contributor(s):
30 *
31 * Alternatively, the contents of this file may be used under the terms of the
32 * GNU General Public License Version 2 or later (the GPL), in which case the
33 * provisions of GPL are applicable instead of those above. If you wish to allow use
34 * of your version of this file only under the terms of the GPL and not to allow
35 * others to use your version of this file under the CPAL, indicate your decision by
36 * deleting the provisions above and replace them with the notice and other
37 * provisions required by the GPL License. If you do not delete the provisions above,
38 * a recipient may use your version of this file under either the CPAL or the GPL.
39 *
40 * *** END LICENSE INFORMATION ***
41 */
42
43
44
45/** @defgroup BasicOps
46 * Basic Operators
47 */
48
49
50#ifndef LASS_GUARDIAN_OF_INCLUSION_NUM_BASIC_OPS_H
51#define LASS_GUARDIAN_OF_INCLUSION_NUM_BASIC_OPS_H
52
53#include "num_common.h"
54#include <cmath>
55
56// The friendly folks of Cygwin have implemented log2 as a macro.
57// Well, actually, they forgot to undef it in cmath. Do it now!
58//
59#if LASS_PLATFORM_TYPE == LASS_PLATFORM_TYPE_CYGWIN && defined(log2)
60# undef log2
61namespace std
62{
63 template <typename T> inline T log2(T x) { return std::log(x) / T(M_LN2); }
64}
65#endif
66
67namespace lass
68{
69namespace num
70{
71
72// generic functions
73
74template <typename T> inline T abs(const T& x);
75template <typename T> inline T sign(const T& x);
76template <typename T> inline T sqr(const T& x);
77template <typename T> inline T inv(const T& x);
78template <typename T> inline T cubic(const T& x);
79template <typename T> inline T pow(const T& x, const T& p);
80template <typename T> inline T log2(const T& x);
81template <typename T> inline T log10(const T& x);
82template <typename T> inline T norm(const T& x);
83template <typename T> inline T conj(const T& x);
84template <typename T> inline const T& clamp(const T& x, const T& min, const T& max);
85template <typename T> inline T lerp(const T& a, const T& b, const T& f);
86
87template <typename T> inline void inpabs(T& x);
88template <typename T> inline void inpsign(T& x);
89template <typename T> inline void inpinv(T& x);
90template <typename T> inline void inpsqrt(T& x);
91template <typename T> inline void inpsqr(T& x);
92template <typename T> inline void inpcubic(T& x);
93template <typename T> inline void inppow(T& x, const T& p);
94template <typename T> inline void inpexp(T& x);
95template <typename T> inline void inplog(T& x);
96template <typename T> inline void inplog2(T& x);
97template <typename T> inline void inplog10(T& x);
98template <typename T> inline void inpcos(T& x);
99template <typename T> inline void inpsin(T& x);
100template <typename T> inline void inptan(T& x);
101template <typename T> inline void inpacos(T& x);
102template <typename T> inline void inpasin(T& x);
103template <typename T> inline void inpatan(T& x);
104template <typename T> inline void inpatan2(T& x, const T& y);
105template <typename T> inline void inpfloor(T& x);
106template <typename T> inline void inpceil(T& x);
107template <typename T> inline void inpround(T& x);
108template <typename T> inline void inpfractional(T& x);
109template <typename T> inline void inpdiv(T& x, const T& d);
110template <typename T> inline void inpmod(T& x, const T& d);
111template <typename T> inline void inpclamp(T& x, const T& min, const T& max);
112template <typename T> inline void compnorm(const T& x, T& y);
113template <typename T> inline void compinv(const T& x, T& y);
114
115template<typename T,typename f> inline T applyFunction(const T& x, f func );
116
117
118
119// float
120
121inline float abs(float x);
122inline float inv(float x);
123inline float sqrt(float x);
124inline float pow(float x, float p);
125inline float exp(float x);
126inline float expm1(float x);
127inline float log(float x);
128inline float log2(float x);
129inline float log10(float x);
130inline float log1p(float x);
131inline float cos(float x);
132inline float sin(float x);
133inline float tan(float x);
134inline float acos(float x);
135inline float asin(float x);
136inline float atan(float x);
137inline float atan2(float y, float x);
138inline float sinc(float x);
139inline float floor(float x);
140inline float ceil(float x);
141inline float round(float x);
142inline float fractional(float x);
143inline float div(float x, float d);
144inline float mod(float x, float d);
145
146inline float fastSin(float x);
147
148
149
150// double
151
152inline double abs(double x);
153inline double inv(double x);
154inline double sqrt(double x);
155inline double pow(double x, double p);
156inline double exp(double x);
157inline double expm1(double x);
158inline double log(double x);
159inline double log2(double x);
160inline double log10(double x);
161inline double log1p(double x);
162inline double cos(double x);
163inline double sin(double x);
164inline double tan(double x);
165inline double acos(double x);
166inline double asin(double x);
167inline double atan(double x);
168inline double atan2(double y, double x);
169inline double sinc(double x);
170inline double floor(double x);
171inline double ceil(double x);
172inline double round(double x);
173inline double fractional(double x);
174inline double div(double x, double d);
175inline double mod(double x, double d);
176
177inline double fastSin(double x);
178
179
180
181// long double
182
183#if defined(LASS_NUM_BASIC_OPS_USE_BUILTIN_LONG_DOUBLE) || defined(LASS_HAVE_LONG_DOUBLE_STD_FUNCTIONS)
184# define LASS_HAVE_LONG_DOUBLE 1
185#endif
186
187#if LASS_HAVE_LONG_DOUBLE
188
189inline long double abs(long double x);
190inline long double inv(long double x);
191inline long double sqrt(long double x);
192inline long double pow(long double x, long double p);
193inline long double exp(long double x);
194inline long double expm1(long double x);
195inline long double log(long double x);
196inline long double log2(long double x);
197inline long double log10(long double x);
198inline long double log1p(long double x);
199inline long double cos(long double x);
200inline long double sin(long double x);
201inline long double tan(long double x);
202inline long double acos(long double x);
203inline long double asin(long double x);
204inline long double atan(long double x);
205inline long double atan2(long double y, long double x);
206inline long double sinc(long double x);
207inline long double floor(long double x);
208inline long double ceil(long double x);
209inline long double round(long double x);
210inline long double fractional(long double x);
211inline long double div(long double x, long double d);
212inline long double mod(long double x, long double d);
213
214inline long double fastSin(long double x);
215
216#endif
217
218
219// --- char ----------------------------------------------------------------------------------------
220
221inline char pow(char x, char p);
222inline char floor(char x);
223inline char ceil(char x);
224inline char round(char x);
225inline char fractional(char x);
226inline char div(char x, char p);
227inline char mod(char x, char p);
228
229inline void inpabs(char& x);
230inline void inpfloor(char& x);
231inline void inpceil(char& x);
232inline void inpround(char& x);
233inline void inpfractional(char& x);
234
235#ifdef LASS_CHAR_IS_SIGNED
236
237inline char pow(char x, unsigned char p);
238inline char div(char x, unsigned char d);
239inline unsigned char mod(char x, unsigned char d);
240
241#else
242
243inline char abs(char x);
244inline char sign(char x);
245
246#endif
247
248
249
250// signed char
251
252inline signed char abs(signed char x);
253inline signed char pow(signed char x, signed char p);
254inline signed char pow(signed char x, unsigned char p);
255inline signed char floor(signed char x);
256inline signed char ceil(signed char x);
257inline signed char round(signed char x);
258inline signed char fractional(signed char x);
259inline signed char div(signed char x, signed char d);
260inline signed char div(signed char x, unsigned char d);
261inline signed char mod(signed char x, signed char d);
262inline unsigned char mod(signed char x, unsigned char d);
263
264inline void inpfloor(signed char& x);
265inline void inpceil(signed char& x);
266inline void inpround(signed char& x);
267inline void inpfractional(signed char& x);
268
269// unsigned char
270
271inline unsigned char abs(unsigned char x);
272inline unsigned char sign(unsigned char x);
273inline unsigned char pow(unsigned char x, unsigned char p);
274inline unsigned char floor(unsigned char x);
275inline unsigned char ceil(unsigned char x);
276inline unsigned char round(unsigned char x);
277inline unsigned char fractional(unsigned char x);
278inline unsigned char div(unsigned char x, unsigned char d);
279inline unsigned char mod(unsigned char x, unsigned char d);
280
281inline void inpabs(unsigned char& x);
282inline void inpfloor(unsigned char& x);
283inline void inpceil(unsigned char& x);
284inline void inpround(unsigned char& x);
285inline void inpfractional(unsigned char& x);
286
287
288
289// signed short
290
291inline signed short abs(signed short x);
292inline signed short pow(signed short x, signed short p);
293inline signed short pow(signed short x, unsigned short p);
294inline signed short floor(signed short x);
295inline signed short ceil(signed short x);
296inline signed short round(signed short x);
297inline signed short fractional(signed short x);
298inline signed short div(signed short x, signed short d);
299inline signed short div(signed short x, unsigned short d);
300inline signed short mod(signed short x, signed short d);
301inline unsigned short mod(signed short x, unsigned short d);
302
303inline void inpfloor(signed short& x);
304inline void inpceil(signed short& x);
305inline void inpround(signed short& x);
306inline void inpfractional(signed short& x);
307
308// unsigned short
309
310inline unsigned short abs(unsigned short x);
311inline unsigned short sign(unsigned short x);
312inline unsigned short pow(unsigned short x, unsigned short p);
313inline unsigned short floor(unsigned short x);
314inline unsigned short ceil(unsigned short x);
315inline unsigned short round(unsigned short x);
316inline unsigned short fractional(unsigned short x);
317inline unsigned short div(unsigned short x, unsigned short d);
318inline unsigned short mod(unsigned short x, unsigned short d);
319
320inline void inpabs(unsigned short& x);
321inline void inpfloor(unsigned short& x);
322inline void inpceil(unsigned short& x);
323inline void inpround(unsigned short& x);
324inline void inpfractional(unsigned short& x);
325
326
327
328// signed int
329
330inline signed int abs(signed int x);
331inline signed int pow(signed int x, signed int p);
332inline signed int pow(signed int x, unsigned int p);
333inline signed int floor(signed int x);
334inline signed int ceil(signed int x);
335inline signed int round(signed int x);
336inline signed int fractional(signed int x);
337inline signed int div(signed int x, signed int d);
338inline signed int div(signed int x, unsigned int d);
339inline signed int mod(signed int x, signed int d);
340inline unsigned int mod(signed int x, unsigned int d);
341
342inline void inpfloor(signed int& x);
343inline void inpceil(signed int& x);
344inline void inpround(signed int& x);
345inline void inpfractional(signed int& x);
346
347// unsigned int
348
349inline unsigned int abs(unsigned int x);
350inline unsigned int sign(unsigned int x);
351inline unsigned int pow(unsigned int x, unsigned int y);
352inline unsigned int floor(unsigned int x);
353inline unsigned int ceil(unsigned int x);
354inline unsigned int round(unsigned int x);
355inline unsigned int fractional(unsigned int x);
356inline unsigned int div(unsigned int x, unsigned int d);
357inline unsigned int mod(unsigned int x, unsigned int d);
358
359inline void inpabs(unsigned int& x);
360inline void inpfloor(unsigned int& x);
361inline void inpceil(unsigned int& x);
362inline void inpround(unsigned int& x);
363inline void inpfractional(unsigned int& x);
364
365
366
367// signed long
368
369inline signed long abs(signed long x);
370inline signed long pow(signed long x, signed long y);
371inline signed long pow(signed long x, unsigned long y);
372inline signed long floor(signed long x);
373inline signed long ceil(signed long x);
374inline signed long round(signed long x);
375inline signed long fractional(signed long x);
376inline signed long div(signed long x, signed long d);
377inline signed long div(signed long x, unsigned long d);
378inline signed long mod(signed long x, signed long d);
379inline unsigned long mod(signed long x, unsigned long d);
380
381inline void inpfloor(signed long& x);
382inline void inpceil(signed long& x);
383inline void inpround(signed long& x);
384inline void inpfractional(signed long& x);
385
386// unsigned long
387
388inline unsigned long abs(unsigned long x);
389inline unsigned long sign(unsigned long x);
390inline unsigned long pow(unsigned long x, unsigned long p);
391inline unsigned long floor(unsigned long x);
392inline unsigned long ceil(unsigned long x);
393inline unsigned long round(unsigned long x);
394inline unsigned long fractional(unsigned long x);
395inline unsigned long div(unsigned long x, unsigned long d);
396inline unsigned long mod(unsigned long x, unsigned long d);
397
398inline void inpabs(unsigned long& x);
399inline void inpfloor(unsigned long& x);
400inline void inpceil(unsigned long& x);
401inline void inpround(unsigned long& x);
402inline void inpfractional(unsigned long& x);
403
404
405
406#if LASS_HAVE_LONG_LONG
407
408// signed long long
409
410inline signed long long abs(signed long long x);
411inline signed long long pow(signed long long x, signed long long y);
412inline signed long long pow(signed long long x, unsigned long long y);
413inline signed long long floor(signed long long x);
414inline signed long long ceil(signed long long x);
415inline signed long long round(signed long long x);
416inline signed long long fractional(signed long long x);
417inline signed long long div(signed long long x, signed long long d);
418inline signed long long div(signed long long x, unsigned long long d);
419inline signed long long mod(signed long long x, signed long long d);
420inline unsigned long long mod(signed long long x, unsigned long long d);
421
422inline void inpfloor(signed long long& x);
423inline void inpceil(signed long long& x);
424inline void inpround(signed long long& x);
425inline void inpfractional(signed long long& x);
426
427
428// unsigned long long
429
430inline unsigned long long abs(unsigned long long x);
431inline unsigned long long sign(unsigned long long x);
432inline unsigned long long pow(unsigned long long x, unsigned long long p);
433inline unsigned long long floor(unsigned long long x);
434inline unsigned long long ceil(unsigned long long x);
435inline unsigned long long round(unsigned long long x);
436inline unsigned long long fractional(unsigned long long x);
437inline unsigned long long div(unsigned long long x, unsigned long long d);
438inline unsigned long long mod(unsigned long long x, unsigned long long d);
439
440inline void inpabs(unsigned long long& x);
441inline void inpfloor(unsigned long long& x);
442inline void inpceil(unsigned long long& x);
443inline void inpround(unsigned long long& x);
444inline void inpfractional(unsigned long long& x);
445
446#endif
447
448
449
450// complex numbers
451
452template <typename T> inline T abs(const std::complex<T>& x);
453template <typename T> inline std::complex<T> inv(const std::complex<T>& x);
454template <typename T> inline std::complex<T> sqrt(const std::complex<T>& x);
455template <typename T> inline std::complex<T> pow(const std::complex<T>& x, const std::complex<T>& p);
456template <typename T> inline std::complex<T> exp(const std::complex<T>& x);
457template <typename T> inline std::complex<T> log(const std::complex<T>& x);
458template <typename T> inline std::complex<T> log2(const std::complex<T>& x);
459template <typename T> inline std::complex<T> log10(const std::complex<T>& x);
460template <typename T> inline std::complex<T> cos(const std::complex<T>& x);
461template <typename T> inline std::complex<T> sin(const std::complex<T>& x);
462template <typename T> inline std::complex<T> tan(const std::complex<T>& x);
463template <typename T> inline std::complex<T> atan(const std::complex<T>& x);
464
465template <typename T> inline T norm(const std::complex<T>& x);
466template <typename T> inline std::complex<T> conj(const std::complex<T>& x);
467
468#include "basic_ops.inl"
469
470}
471
472}
473
474#endif
basic_ops.inl
lass::num::sqr
T sqr(const T &x)
return x * x
Definition basic_ops.h:162
log2
T log2(const T &x)
return log(x) / log(2)
Definition basic_ops.inl:195
lass::num::inv
T inv(const T &x)
return x ^ -1
Definition basic_ops.h:178
lass::num::sign
T sign(const T &x)
if x < 0 return -1, else if x > 0 return 1, else return 0.
Definition basic_ops.h:153
lass::num::norm
T norm(const T &x)
return norm of x as if x is real part of complex number: sqr(x)
Definition basic_ops.h:211
lass::num::clamp
const T & clamp(const T &x, const T &min, const T &max)
if x < min return min, else if x > max return max, else return x.
Definition basic_ops.h:226
lass::num::log10
T log10(const T &x)
return log(x) / log(10)
Definition basic_ops.h:203
lass::num::pow
T pow(const T &x, const T &p)
return exp(p * log(x));
Definition basic_ops.h:187
lass::num::abs
T abs(const T &x)
if x < 0 return -x, else return x.
Definition basic_ops.h:145
lass::num::log2
T log2(const T &x)
return log(x) / log(2)
Definition basic_ops.h:195
lass::num::cubic
T cubic(const T &x)
return x * x * x
Definition basic_ops.h:170
lass::num::lerp
T lerp(const T &a, const T &b, const T &f)
linear interpolation between a and b
Definition basic_ops.h:234
lass::num::conj
T conj(const T &x)
return conjugate as if x is a complex number: x
Definition basic_ops.h:218
lass
Library for Assembled Shared Sources.
Definition config.h:53
num_common.h