Loading...
Searching...
No Matches
math.h
Go to the documentation of this file.
1//
2// Copyright 2016 Pixar
3//
4// Licensed under the Apache License, Version 2.0 (the "Apache License")
5// with the following modification; you may not use this file except in
6// compliance with the Apache License and the following modification to it:
7// Section 6. Trademarks. is deleted and replaced with:
8//
9// 6. Trademarks. This License does not grant permission to use the trade
10// names, trademarks, service marks, or product names of the Licensor
11// and its affiliates, except as required to comply with Section 4(c) of
12// the License and to reproduce the content of the NOTICE file.
13//
14// You may obtain a copy of the Apache License at
15//
16// http://www.apache.org/licenses/LICENSE-2.0
17//
18// Unless required by applicable law or agreed to in writing, software
19// distributed under the Apache License with the above modification is
20// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21// KIND, either express or implied. See the Apache License for the specific
22// language governing permissions and limitations under the Apache License.
23//
24#ifndef PXR_BASE_GF_MATH_H
25#define PXR_BASE_GF_MATH_H
26
30
31#include "pxr/pxr.h"
32#include "pxr/base/arch/math.h"
33#include "pxr/base/gf/api.h"
34#include "pxr/base/gf/traits.h"
35
36#include <type_traits>
37
38PXR_NAMESPACE_OPEN_SCOPE
39
42inline bool GfIsClose(double a, double b, double epsilon) {
43 return fabs(a-b) < epsilon;
44}
45
48inline double GfRadiansToDegrees(double radians) {
49 return radians * (180.0 / M_PI);
50}
51
54inline double GfDegreesToRadians(double degrees) {
55 return degrees * (M_PI / 180.0);
56}
57
61template <class T>
62inline double GfSqr(const T& x) {
63 return x * x;
64}
65
72template <typename T>
73inline T
74GfSgn(T v) {
75 return (v < 0) ? -1 : ((v > 0) ? 1 : 0);
76}
77
80inline double GfSqrt(double f) { return std::sqrt(f); }
83inline float GfSqrt(float f) { return std::sqrt(f); }
84
87inline double GfExp(double f) { return std::exp(f); }
90inline float GfExp(float f) { return std::exp(f); }
91
94inline double GfLog(double f) { return std::log(f); }
97inline float GfLog(float f) { return std::log(f); }
98
101inline double GfFloor(double f) { return std::floor(f); }
104inline float GfFloor(float f) { return std::floor(f); }
105
108inline double GfCeil(double f) { return std::ceil(f); }
111inline float GfCeil(float f) { return std::ceil(f); }
112
115inline double GfAbs(double f) { return std::fabs(f); }
118inline float GfAbs(float f) { return std::fabs(f); }
119
122inline double GfRound(double f) { return std::rint(f); }
125inline float GfRound(float f) { return std::rint(f); }
126
129inline double GfPow(double f, double p) { return std::pow(f, p); }
132inline float GfPow(float f, float p) { return std::pow(f, p); }
133
136inline double GfSin(double v) { return std::sin(v); }
139inline float GfSin(float v) { return std::sin(v); }
142inline double GfCos(double v) { return std::cos(v); }
145inline float GfCos(float v) { return std::cos(v); }
148inline void GfSinCos(double v, double *s, double *c) { ArchSinCos(v, s, c); }
151inline void GfSinCos(float v, float *s, float *c) { ArchSinCosf(v, s, c); }
152
156inline double GfClamp(double value, double min, double max) {
157 if (value < min) return min;
158 if (value > max) return max;
159 return value;
160}
161
164inline float GfClamp(float value, float min, float max) {
165 if (value < min) return min;
166 if (value > max) return max;
167 return value;
168}
169
177GF_API
178double GfMod(double a, double b);
180// \ingroup group_gf_BasicMath
181GF_API
182float GfMod(float a, float b);
183
192template <class T>
193inline T GfLerp( double alpha, const T& a, const T& b) {
194 return (1-alpha)* a + alpha * b;
195}
196
199template <class T>
200inline T GfMin(T a1, T a2) {
201 return (a1 < a2 ? a1 : a2);
202}
203template <class T>
204inline T GfMin(T a1, T a2, T a3) {
205 return GfMin(GfMin(a1, a2), a3);
206}
207template <class T>
208inline T GfMin(T a1, T a2, T a3, T a4) {
209 return GfMin(GfMin(a1, a2, a3), a4);
210}
211template <class T>
212inline T GfMin(T a1, T a2, T a3, T a4, T a5) {
213 return GfMin(GfMin(a1, a2, a3, a4), a5);
214}
215
218template <class T>
219inline T GfMax(T a1, T a2) {
220 return (a1 < a2 ? a2 : a1);
221}
222template <class T>
223inline T GfMax(T a1, T a2, T a3) {
224 return GfMax(GfMax(a1, a2), a3);
225}
226template <class T>
227inline T GfMax(T a1, T a2, T a3, T a4) {
228 return GfMax(GfMax(a1, a2, a3), a4);
229}
230template <class T>
231inline T GfMax(T a1, T a2, T a3, T a4, T a5) {
232 return GfMax(GfMax(a1, a2, a3, a4), a5);
233}
234
238template <typename Left, typename Right,
239 std::enable_if_t<GfIsArithmetic<Left>::value &&
241inline decltype(std::declval<Left>() * std::declval<Right>())
242GfDot(Left left, Right right) {
243 return left * right;
244}
245
249template <typename Left, typename Right,
250 std::enable_if_t<GfIsArithmetic<Left>::value &&
252inline decltype(std::declval<Left>() * std::declval<Right>())
253GfCompMult(Left left, Right right) {
254 return left * right;
255}
256
260template <typename Left, typename Right,
261 std::enable_if_t<GfIsArithmetic<Left>::value &&
263inline decltype(std::declval<Left>() / std::declval<Right>())
264GfCompDiv(Left left, Right right) {
265 return left / right;
266}
267
268
269PXR_NAMESPACE_CLOSE_SCOPE
270
271#endif // PXR_BASE_GF_MATH_H
Architecture-specific math function calls.
void ArchSinCos(double v, double *s, double *c)
Computes the sine and cosine of the specified value as a double.
Definition: math.h:114
void ArchSinCosf(float v, float *s, float *c)
Computes the sine and cosine of the specified value as a float.
Definition: math.h:111
decltype(std::declval< Left >()/std::declval< Right >()) GfCompDiv(Left left, Right right)
Returns component-wise quotient of vectors.
Definition: math.h:264
double GfDegreesToRadians(double degrees)
Converts an angle in degrees to radians.
Definition: math.h:54
double GfPow(double f, double p)
Return pow(f, p).
Definition: math.h:129
double GfSqr(const T &x)
Returns the inner product of x with itself: specifically, x*x.
Definition: math.h:62
GF_API double GfMod(double a, double b)
The mod function with "correct" behaviour for negative numbers.
double GfCos(double v)
Return cos(v).
Definition: math.h:142
double GfRadiansToDegrees(double radians)
Converts an angle in radians to degrees.
Definition: math.h:48
double GfRound(double f)
Return round(f).
Definition: math.h:122
double GfFloor(double f)
Return floor(f).
Definition: math.h:101
double GfClamp(double value, double min, double max)
Return the resulting of clamping value to lie between min and max.
Definition: math.h:156
bool GfIsClose(double a, double b, double epsilon)
Returns true if a and b are with epsilon of each other.
Definition: math.h:42
double GfCeil(double f)
Return ceil(f).
Definition: math.h:108
T GfMin(T a1, T a2)
Returns the smallest of the given values.
Definition: math.h:200
void GfSinCos(double v, double *s, double *c)
Return sin(v) in s and cos(v) in c.
Definition: math.h:148
double GfSqrt(double f)
Return sqrt(f).
Definition: math.h:80
double GfLog(double f)
Return log(f).
Definition: math.h:94
T GfMax(T a1, T a2)
Returns the largest of the given values.
Definition: math.h:219
decltype(std::declval< Left >() *std::declval< Right >()) GfDot(Left left, Right right)
Returns the dot (inner) product of two vectors.
Definition: math.h:242
T GfLerp(double alpha, const T &a, const T &b)
Linear interpolation function.
Definition: math.h:193
double GfAbs(double f)
Return abs(f).
Definition: math.h:115
T GfSgn(T v)
Return the signum of v (i.e.
Definition: math.h:74
double GfSin(double v)
Return sin(v).
Definition: math.h:136
double GfExp(double f)
Return exp(f).
Definition: math.h:87
decltype(std::declval< Left >() *std::declval< Right >()) GfCompMult(Left left, Right right)
Returns component-wise multiplication of vectors.
Definition: math.h:253
A metafunction which is equivalent to std::arithmetic but also includes any specializations from GfIs...
Definition: traits.h:68