00001 // This code contains NVIDIA Confidential Information and is disclosed to you
00002 // under a form of NVIDIA software license agreement provided separately to you.
00003 //
00004 // Notice
00005 // NVIDIA Corporation and its licensors retain all intellectual property and
00006 // proprietary rights in and to this software and related documentation and
00007 // any modifications thereto. Any use, reproduction, disclosure, or
00008 // distribution of this software and related documentation without an express
00009 // license agreement from NVIDIA Corporation is strictly prohibited.
00010 //
00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
00015 //
00016 // Information and code furnished is believed to be accurate and reliable.
00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
00018 // information or for any infringement of patents or other rights of third parties that may
00019 // result from its use. No license is granted by implication or otherwise under any patent
00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
00021 // This code supersedes and replaces all information previously supplied.
00022 // NVIDIA Corporation products are not authorized for use as critical
00023 // components in life support devices or systems without express written approval of
00024 // NVIDIA Corporation.
00025 //
00026 // Copyright (c) 2008-2017 NVIDIA Corporation. All rights reserved.
00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
00029 
00030 #ifndef PXFOUNDATION_PXMATH_H
00031 #define PXFOUNDATION_PXMATH_H
00032 
00037 #include "foundation/PxPreprocessor.h"
00038 
00039 #if PX_VC
00040 #pragma warning(push)
00041 #pragma warning(disable : 4985) // 'symbol name': attributes not present on previous declaration
00042 #endif
00043 #include <math.h>
00044 #if PX_VC
00045 #pragma warning(pop)
00046 #endif
00047 
00048 #include <float.h>
00049 #include "foundation/PxIntrinsics.h"
00050 #include "foundation/PxAssert.h"
00051 
00052 #if !PX_DOXYGEN
00053 namespace physx
00054 {
00055 #endif
00056 
00057 // constants
00058 static const float PxPi = float(3.141592653589793);
00059 static const float PxHalfPi = float(1.57079632679489661923);
00060 static const float PxTwoPi = float(6.28318530717958647692);
00061 static const float PxInvPi = float(0.31830988618379067154);
00062 static const float PxInvTwoPi = float(0.15915494309189533577);
00063 static const float PxPiDivTwo = float(1.57079632679489661923);
00064 static const float PxPiDivFour = float(0.78539816339744830962);
00065 
00069 template <class T>
00070 PX_CUDA_CALLABLE PX_FORCE_INLINE T PxMax(T a, T b)
00071 {
00072     return a < b ? b : a;
00073 }
00074 
00076 template <>
00077 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxMax(float a, float b)
00078 {
00079     return intrinsics::selectMax(a, b);
00080 }
00081 
00085 template <class T>
00086 PX_CUDA_CALLABLE PX_FORCE_INLINE T PxMin(T a, T b)
00087 {
00088     return a < b ? a : b;
00089 }
00090 
00091 template <>
00093 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxMin(float a, float b)
00094 {
00095     return intrinsics::selectMin(a, b);
00096 }
00097 
00098 /*
00099 Many of these are just implemented as PX_CUDA_CALLABLE PX_FORCE_INLINE calls to the C lib right now,
00100 but later we could replace some of them with some approximations or more
00101 clever stuff.
00102 */
00103 
00107 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAbs(float a)
00108 {
00109     return intrinsics::abs(a);
00110 }
00111 
00112 PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxEquals(float a, float b, float eps)
00113 {
00114     return (PxAbs(a - b) < eps);
00115 }
00116 
00120 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAbs(double a)
00121 {
00122     return ::fabs(a);
00123 }
00124 
00128 PX_CUDA_CALLABLE PX_FORCE_INLINE int32_t PxAbs(int32_t a)
00129 {
00130     return ::abs(a);
00131 }
00132 
00136 template <class T>
00137 PX_CUDA_CALLABLE PX_FORCE_INLINE T PxClamp(T v, T lo, T hi)
00138 {
00139     PX_ASSERT(lo <= hi);
00140     return PxMin(hi, PxMax(lo, v));
00141 }
00142 
00144 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxSqrt(float a)
00145 {
00146     return intrinsics::sqrt(a);
00147 }
00148 
00150 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxSqrt(double a)
00151 {
00152     return ::sqrt(a);
00153 }
00154 
00156 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxRecipSqrt(float a)
00157 {
00158     return intrinsics::recipSqrt(a);
00159 }
00160 
00162 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxRecipSqrt(double a)
00163 {
00164     return 1 / ::sqrt(a);
00165 }
00166 
00168 
00170 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxSin(float a)
00171 {
00172     return intrinsics::sin(a);
00173 }
00174 
00176 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxSin(double a)
00177 {
00178     return ::sin(a);
00179 }
00180 
00182 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxCos(float a)
00183 {
00184     return intrinsics::cos(a);
00185 }
00186 
00188 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxCos(double a)
00189 {
00190     return ::cos(a);
00191 }
00192 
00197 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxTan(float a)
00198 {
00199     return ::tanf(a);
00200 }
00201 
00206 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxTan(double a)
00207 {
00208     return ::tan(a);
00209 }
00210 
00216 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAsin(float f)
00217 {
00218     return ::asinf(PxClamp(f, -1.0f, 1.0f));
00219 }
00220 
00226 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAsin(double f)
00227 {
00228     return ::asin(PxClamp(f, -1.0, 1.0));
00229 }
00230 
00236 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAcos(float f)
00237 {
00238     return ::acosf(PxClamp(f, -1.0f, 1.0f));
00239 }
00240 
00246 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAcos(double f)
00247 {
00248     return ::acos(PxClamp(f, -1.0, 1.0));
00249 }
00250 
00256 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAtan(float a)
00257 {
00258     return ::atanf(a);
00259 }
00260 
00266 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAtan(double a)
00267 {
00268     return ::atan(a);
00269 }
00270 
00276 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAtan2(float x, float y)
00277 {
00278     return ::atan2f(x, y);
00279 }
00280 
00286 PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAtan2(double x, double y)
00287 {
00288     return ::atan2(x, y);
00289 }
00290 
00292 PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxIsFinite(float f)
00293 {
00294     return intrinsics::isFinite(f);
00295 }
00296 
00298 PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxIsFinite(double f)
00299 {
00300     return intrinsics::isFinite(f);
00301 }
00302 
00303 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxFloor(float a)
00304 {
00305     return ::floorf(a);
00306 }
00307 
00308 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxExp(float a)
00309 {
00310     return ::expf(a);
00311 }
00312 
00313 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxCeil(float a)
00314 {
00315     return ::ceilf(a);
00316 }
00317 
00318 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxSign(float a)
00319 {
00320     return physx::intrinsics::sign(a);
00321 }
00322 
00323 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxPow(float x, float y)
00324 {
00325     return ::powf(x, y);
00326 }
00327 
00328 PX_CUDA_CALLABLE PX_FORCE_INLINE float PxLog(float x)
00329 {
00330     return ::logf(x);
00331 }
00332 
00333 #if !PX_DOXYGEN
00334 } // namespace physx
00335 #endif
00336 
00338 #endif // #ifndef PXFOUNDATION_PXMATH_H