IC Python API:RLPy RMath
Contents
- 1 Description
- 2 Member Functions
- 2.1 Abs (a)
- 2.2 ACos (fValue)
- 2.3 AlmostZero ( tValue )
- 2.4 ASin ( fValue )
- 2.5 ATan ( fValue )
- 2.6 ATan2 ( fY, fX )
- 2.7 Bezier3 ( a, b, c, d, t )
- 2.8 Ceil ( fValue )
- 2.9 Clamp ( tMax, tMin, tValue )
- 2.10 CopySign ( fValue )
- 2.11 Cos ( fValue )
- 2.12 Equal ( tValue1, tValue2 )
- 2.13 Erf ( fX )
- 2.14 Erfc ( fX )
- 2.15 Exp ( fValue )
- 2.16 FAbs ( fValue )
- 2.17 FastCos0 ( fAngle )
- 2.18 FastCos1 ( fAngle )
- 2.19 FastInvCos ( fValue )
- 2.20 FastInvSin ( fValue )
- 2.21 FastInvSqrt_Walsh ( tValue )
- 2.22 FastInvTan0 ( fValue )
- 2.23 FastInvTan1 ( fValue )
- 2.24 FastSin0 ( fAngle )
- 2.25 FastSin1 ( fAngle )
- 2.26 FastSqrt_LogBase2 ( tValue )
- 2.27 FastSqrt_Walsh ( tValue )
- 2.28 FastTan0 ( fAngle )
- 2.29 FastTan1 ( fAngle )
- 2.30 Floor ( fValue )
- 2.31 FMod ( fX, fY )
- 2.32 Gamma ( fX )
- 2.33 IncompleteGamma ( fA, fX )
- 2.34 IntervalRandom ( args )
- 2.35 InvSqrt ( fValue )
- 2.36 Log ( fValue )
- 2.37 LogGamma ( fX )
- 2.38 Max ( a, b )
- 2.39 Min ( a, b )
- 2.40 ModBessel0 ( fX )
- 2.41 ModBessel1 ( fX )
- 2.42 Pow ( fBase, fExponent )
- 2.43 Round ( tValue )
- 2.44 RoundAlmostZero ( tValue )
- 2.45 RoundEpsilonZero ( tValue )
- 2.46 Sign ( fValue )
- 2.47 Sin ( fValue )
- 2.48 Sqr ( fValue )
- 2.49 Sqrt ( fValue )
- 2.50 SymmetricRandom ( args )
- 2.51 Tan ( fValue )
- 2.52 UnitRandom ( args )
- Main article: Modules.
- Last modified: 04/13/2020
Description
This class provides functions related to mathematics, including functions of trigonometric functions, exponents, logarithms, numerical ccomparisons, creation of random values, etc. It also provides some constant variables that can be referenced directly:
Constant | Description |
---|---|
RMath.CONST_ALMOST_ZERO | Same as AlmostZero, used to determine whether the value is close to 0. |
RMath.CONST_EPSILON | Used to determine if a value is close to epsilon 0. |
RMath.CONST_MAX_T | Maximum allowable floating-point value. |
RMath.CONST_MIN_T | Minimum allowable floating-point value. |
RMath.CONST_PI | Value of pi: π. |
RMath.CONST_TWO_PI | Value of pi times two: 2π. |
RMath.CONST_HALF_PI | Value of pi divided by 2: π/2. |
RMath.CONST_INV_PI | 1 divided by the value of pi: 1/π. |
RMath.CONST_INV_TWO_PI | Inverse of 2 times the value of pi: 1/2π. |
RMath.CONST_DEG_TO_RAD | Conversion of 1 degree to radians. |
RMath.CONST_RAD_TO_DEG | Conversion of 1 radian to degrees |
RMath.CONST_SQRT_HALF | 1 divided by the square root of 2: 1/sqrt(2). |
RMath.CONST_MM_TO_INCH | Conversion of 1 millimeter to inches. |
RMath.CONST_INCH_TO_MM | Conversion of 1 inch to millimeters. |
Member Functions
Abs (a)
Computes the absolute number of a value.
Parameters
- a [IN] Floating-point value - float
Returns
- Absolute value of a - float
1 print( RLPy.RMath.Abs( -10 ) ) # 10
ACos (fValue)
Computes the arc-cosine of a value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- Arc-cosine of fValue in radians - float [0,π]
1 print( RLPy.RMath.ACos( 0.9 ) ) # 0.4510268568992615
AlmostZero ( tValue )
Checks if a value is almost zero.
Parameters
- tValue [IN] Floating-point value - float
Returns
- True if the value is almost zero, else False - bool
1 print( RLPy.RMath.AlmostZero( 0.1 ) ) # False
2 print( RLPy.RMath.AlmostZero( 0.000000000000001 ) ) # True
ASin ( fValue )
Computes the arc-sine of a value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- Arc-sine of fValue in radians - float [-π/2,π/2]
1 print( RLPy.RMath.ASin( 0.9 ) ) # 1.1197694540023804
ATan ( fValue )
Computes the arc-tangent of a value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- Arc-cosine of fValue in radians - float [-π/2,π/2]
1 print( RLPy.RMath.ATan( 0.9 ) ) # 0.7328150868415833
ATan2 ( fY, fX )
Computes the arc-tangent of y/x using the signs of arguments to determine the correct quadrant.
Parameters
- fY [IN] Floating-point value - float
- fX [IN] Floating-point value - float
Returns
- The arc-tangent of fY and fX in radians - float [-π,π]
1 print( RLPy.RMath.ATan2( -7.0, 7.0 ) ) # -0.7853981852531433
Bezier3 ( a, b, c, d, t )
Computes an interpolated value on a cubic bezier curve with 4 control points.
Parameters
- a [IN] 1st control point value - float
- b [IN] 2nd control point value - float
- c [IN] 3rd control point value - float
- d [IN] 4th control point value - float
- t [IN] Point along the curve - float [0,1]
Returns
- An interpolated value from the bezier curve - float
1 print( RLPy.RMath.Bezier3( 0.0,0.5,3.0,4.0,0.0 ) ) # 0.0
2 print( RLPy.RMath.Bezier3( 0.0,0.5,3.0,4.0,0.5 ) ) # 1.8125
3 print( RLPy.RMath.Bezier3( 0.0,0.5,3.0,4.0,1.0 ) ) # 4.0
Ceil ( fValue )
Nearest integer not less than the given value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- The smallest integer not less than fValue - float
1 print( RLPy.RMath.Ceil( 7.01 ) ) # 8.0
Clamp ( tMax, tMin, tValue )
Float result between a min and max values.
Parameters
- tMax [IN] Maximum possible value - float
- tMin [IN] Minimum possible value - float
- tValue [IN] Floating-point value to restrict inside the min-to-max range - float
Returns
- Float result between tMax and tMin - float [min,max]
1 print( RLPy.RMath.Clamp( 0.0, 255.0, 300.0 ) ) # 255.0
CopySign ( fValue )
Copies the sign of a floating-point value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- Return -1 if the input is negative, else 1 - float {-1,1}
1 print( RLPy.RMath.CopySign( 9.0 ) ) # 1.0
2 print( RLPy.RMath.CopySign( 0.0 ) ) # 1.0
3 print( RLPy.RMath.CopySign( -9.0 ) ) # -1.0
Cos ( fValue )
Computes the cosine of a value.
Parameters
- fValue [IN] Angle in radians - float
Returns
- Cosine of fValue - float [-1,1]
1 print( RLPy.RMath.Cos( RLPy.RMath.CONST_PI ) ) # -1.0
Equal ( tValue1, tValue2 )
Check if 2 values are equal or not.
Parameters
- tValue1 [IN] Floating-point value - float
- tValue2 [IN] Floating-point value - float
Returns
- Return True if TValue1 and TValue2 are almost Equal, else False - bool
1 print( RLPy.RMath.Equal( 0.0000001, 0.0000002 ) ) # True
Erf ( fX )
Computes the polynomial approximation of a value.
Parameters
- fX [IN] Floating-point value - float
Returns
- Polynomial approximation of fX - float
1 print( RLPy.RMath.Erf( 0.9 ) ) # 0.7960618138313293
Erfc ( fX )
Computes 1-erf(x)
Parameters
- fX [IN] Floating-point value - float
Returns
- Erfc(x) = 1-erf(x) - float
1 print( RLPy.RMath.Erf( 0.9 ) ) # 0.20393820106983185
Exp ( fValue )
Returns e raised to a given power (ex)
Parameters
- fValue [IN] Floating-point value - float
Returns
- The base-e exponential of arg is returned - float
1 print( RLPy.RMath.Exp( 2.0 ) ) # 7.389056205749512
FAbs ( fValue )
Absolute value of a floating-point value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- The absolute value of arg - float
1 print( RLPy.RMath.FAbs( -2.0 ) ) # 2.0
FastCos0 ( fAngle )
Fast evaluation of cos(angle) by polynomial approximations.
Parameters
- fAngle [IN] Angle in radians - float [0,π/2]
Returns
- The sine of arg in the range of -1 and 1, is returned. The maximum absolute error is about 1.2e-03. This operation is about 2x faster than Cos - float
1 print( RLPy.RMath.Cos( 1.0 ) ) # 0.5403022766113281
2 print( RLPy.RMath.FastCos0( 1.0 ) ) # 0.5403500199317932
FastCos1 ( fAngle )
Fast evaluation of cos(angle) by polynomial approximations.
Parameters
- fAngle [IN] Angle in radians - float [0,π/2]
Returns
- The sine of arg in the range of 1 and -1, is returned. The maximum absolute error is about 2.3e-09. This operation is about 1.5x faster than Cos - float
1 print( RLPy.RMath.Cos( 1.0 ) ) # 0.5403022766113281
2 print( RLPy.RMath.FastCos1( 1.0 ) ) # 0.5403022766113281
FastInvCos ( fValue )
Fast evaluation of acos(value) by a sqrt times a polynomial.
Parameters
- fValue [IN] Floating-point value - float [0,1]
Returns
- The sine of arg is returned. The maximum absolute error is about 6.8e-05. The speed up is about 2.5 - float
1 print( RLPy.RMath.ACos( 0.9 ) ) # 0.4510268568992615
2 print( RLPy.RMath.FastInvCos( 0.9 ) ) # 0.45104315876960754
FastInvSin ( fValue )
Fast evaluation of asin(value) by a sqrt times a polynomial.
Parameters
- fValue [IN] Floating-point value - float [0,1]
Returns
- The sine of arg is returned. The maximum absolute error is about 6.8e-05. The speed up is about 2.5 - float
1 print( RLPy.RMath.ASin( 0.9 ) ) # 1.1197694540023804
2 print( RLPy.RMath.FastInvSin( 0.9 ) ) # 1.1197532415390015
FastInvSqrt_Walsh ( tValue )
A fast approximation to 1/sqrt using The Quake 3 Walsh Method.
Parameters
- tValue [IN] Floating-point value - float
Returns
- The inverse of square root - float
1 print( RLPy.RMath.InvSqrt( 0.9 ) ) # 1.054092526435852
2 print( RLPy.RMath.FastInvSqrt_Walsh( 0.9 ) ) # 1.053429365158081
FastInvTan0 ( fValue )
Fast evaluation of atan(value) by polynomial approximations.
Parameters
- fValue [IN] Floating-point value - float [-1,1]
Returns
- The atan of arg is returned. The maximum absolute error is about 1.2e-05. The speed up is about 2.2 - float
1 print( RLPy.RMath.ATan( 0.9 ) ) # 0.7328150868415833
2 print( RLPy.RMath.FastInvTan0( 0.9 ) ) # 0.7328156232833862
FastInvTan1 ( fValue )
Fast evaluation of atan(value) by polynomial approximations.
Parameters
- fValue [IN] Floating-point value - float [-1,1]
Returns
- The atan of arg is returned. The maximum absolute error is about 1.43-08. The speed up is about 1.5 - float
1 print( RLPy.RMath.ATan( 0.9 ) ) # 0.7328150868415833
2 print( RLPy.RMath.FastInvTan1( 0.9 ) ) # 0.7328150868415833
FastSin0 ( fAngle )
Fast evaluation of sin(angle) by polynomial approximations.
Parameters
- fAngle [IN] Angle in radians - float [0,π/2]
Returns
- The sine of fAngle. The maximum absolute error is about 1.7e-04. This operation is about 2x faster than Sin - float [-1,1]
1 print( RLPy.RMath.Sin( 0.9 ) ) # 0.7833269238471985
2 print( RLPy.RMath.FastSin0( 0.9 ) ) # 0.7834432125091553
FastSin1 ( fAngle )
Fast evaluation of sin(angle) by polynomial approximations.
Parameters
- fAngle [IN] Angle in radians - float [0,π/2]
Returns
- The sine of arg in the range of -1 and 1, is returned. The maximum absolute error is about 2.3e-09. This operation is about 1.5x faster than Sin - float
1 print( RLPy.RMath.Sin( 0.9 ) ) # 0.7833269238471985
2 print( RLPy.RMath.FastSin1( 0.9 ) ) # 0.7833268642425537
FastSqrt_LogBase2 ( tValue )
A fast approximation of Sqrt that is about 5x faster with slight errors.
Parameters
- tValue [IN] Floating-point value - float
Returns
- The value of square root - float
1 print( RLPy.RMath.Sqrt( 0.9 ) ) # 0.9486832618713379
2 print( RLPy.RMath.FastSqrt_LogBase2( 0.9 ) ) # 0.949999988079071
FastSqrt_Walsh ( tValue )
A fast approximation to Sqrt using The Quake 3 Walsh method that is about 2x faster.
Parameters
- tValue [IN] Floating-point value - float
Returns
- The value of square root - float
1 print( RLPy.RMath.Sqrt( 0.9 ) ) # 0.9486832618713379
2 print( RLPy.RMath.FastSqrt_Walsh( 0.9 ) ) # 0.9480863809585571
FastTan0 ( fAngle )
Fast evaluation of tan(angle) by polynomial approximations.
Parameters
- fAngle [IN] Angle in radians - float [0,π/4]
Returns
- Tangent of fAngle. The maximum absolute error is about 8.1e-04. It is about 2.5x faster than Tan - float
1 print( RLPy.RMath.Tan( 0.9 ) ) # 1.2601581811904907
2 print( RLPy.RMath.FastTan0( 0.9 ) ) # 1.2515404224395752
FastTan1 ( fAngle )
Fast evaluation of tan(angle) by polynomial approximations.
Parameters
- fAngle [IN] Angle in radians - float [0,π/4]
Returns
- The tangent of arg is returned. The maximum absolute error is about 1.9e-08. It is about 1.75x faster than Tan - float
1 print( RLPy.RMath.Tan( 0.9 ) ) # 1.2601581811904907
2 print( RLPy.RMath.FastTan1( 0.9 ) ) # 1.2601404190063477
Floor ( fValue )
Nearest integer not greater than the given value.
Parameters
- fValue [IN] Floating-point value - float
Returns
- The largest integer value not greater than arg - float
1 print( RLPy.RMath.Floor( 1.9 ) ) # 1.0
FMod ( fX, fY )
Remainder of the floating-point division operation.
Parameters
- fX [IN] Floating-point value - float
- fY [IN] Floating-point value - float
Returns
- The floating-point remainder of the division x/y as defined above - float
1 print( RLPy.RMath.FMod( 5, 3 ) ) # 2.0
Gamma ( fX )
Computes the gamma of a value.
Parameters
- fX [IN] Floating-point value - float
Returns
- The value of gamma - float
1 print( RLPy.RMath.Gamma( 0.9 ) ) # 1.0686286687850952
IncompleteGamma ( fA, fX )
Computes incomplete gamma.
Parameters
- fA [IN] Floating-point value - float
- fX [IN] Floating-point value - float
Returns
- The value of gamma - float
1 print( RLPy.RMath.IncompleteGamma( 0.1, 0.9 ) ) # 0.9716073274612427
IntervalRandom ( args )
Generate a random number between a min and max value.
Parameters
- fMin [IN] Minimum value - float
- fSeed [IN] maximum value - float
- fSeed [IN] Seeded value - float
Returns
- The random number generator may be seeded by a first call to IntervalRandom with a positive seed - float
1 print( RLPy.RMath.IntervalRandom(0.0,255.0,5.0) ) # 0.4202398657798767
2 print( RLPy.RMath.IntervalRandom(0.0,255.0) ) # 223.2952423095703
InvSqrt ( fValue )
Computes inverse of square root (1/sqrt)
Parameters
- fValue [IN] Floating-point value - float
Returns
- The inverse of square root - float
1 print( RLPy.RMath.InvSqrt( 0.9 ) ) # 1.054092526435852
Log ( fValue )
Computes natural (base e) logarithm.
Parameters
- fValue [IN] Floating-point value - float
Returns
- The natural (base-e) logarithm of arg is returned - float
1 print( RLPy.RMath.Log( 5.5 ) ) # 1.7047480344772339
LogGamma ( fX )
Computes log gamma.
Parameters
- fX [IN] Floating-point value - float
Returns
- The value of log gamma - float
1 print( RLPy.RMath.LogGamma( 5.5 ) ) # 3.9578146934509277
Max ( a, b )
Larger of two floating-point values.
Parameters
- a [IN] Floating-point value - float
- b [IN] Floating-point value - float
Returns
- The larger of two floating-point values - float
1 print( RLPy.RMath.Max( 8.0, 9.0 ) ) # 9.0
Min ( a, b )
Smaller of two floating-point values.
Parameters
- a [IN] Floating-point value - float
- b [IN] Floating-point value - float
Returns
- The smaller of two floating-point values - float
1 print( RLPy.RMath.Min( 8.0, 9.0 ) ) # 8.0
ModBessel0 ( fX )
Modified Bessel functions of order 0.
Parameters
- fX [IN] Floating-point value - float
Returns
- The value of modified bessel - float
1 print( RLPy.RMath.ModBessel0( 5.5 ) ) # 42.694644927978516
ModBessel1 ( fX )
Modified Bessel functions of order 1.
Parameters
- fX [IN] Floating-point value - float
Returns
- The value of modified bessel - float
1 print( RLPy.RMath.ModBessel1( 5.5 ) ) # 38.588165283203125
Pow ( fBase, fExponent )
Raises a number to the given power.
Parameters
- fBase [IN] Base as a value of floating-point - float
- fExponent [IN] Exponent as a value of floating-point - float
Returns
- Base raised to the power of exp - float
1 print( RLPy.RMath.Pow( 2.0, 5.0 ) ) # 32.0
Round ( tValue )
Nearest floating-point.
Parameters
- tValue [IN] Floating-point value - float
Returns
- The nearest flaoting value to arg - float
1 print( RLPy.RMath.Round( 8.49 ) ) # 8.989999771118164
2 print( RLPy.RMath.Round( 8.5 ) ) # 9.0
3 print( RLPy.RMath.Round( 8.52 ) ) # 9.020000457763672
RoundAlmostZero ( tValue )
Round Almost Zero.
Parameters
- tValue1 [IN] Floating-point value.
Returns
- Return RoundAlmostZero - float
1 print( RLPy.RMath.RoundAlmostZero( 0.0000001 ) ) # 0.0
RoundEpsilonZero ( tValue )
Round Epsilon Zero.
Parameters
- tValue1 [IN] Floating-point value.
Returns
- Return RoundEpsilonZero - float
1 print( RLPy.RMath.RoundEpsilonZero( 0.0000001 ) ) # 0.0
Sign ( fValue )
Sign of a value. If the value is greater than 0, return 1; If the value is equal to 0, return 0; If the value is less than 0, return -1;
Parameters
- fValue [IN] Floating-point value - float
Returns
- Return -1 if the input is negative, 0 if the input is zero, and 1 if the input is positive - float {-1,0,1}
1 print( RLPy.RMath.Sign( 9.0 ) ) # 1.0
2 print( RLPy.RMath.Sign( 0.0 ) ) # 0.0
3 print( RLPy.RMath.Sign( -9.0 ) ) # -1.0
Sin ( fValue )
Computes the sine of a value.
Parameters
- fValue [IN] Angle in radians - float
Returns
- The sine of arg - float [-1,1]
1 print( RLPy.RMath.Sin( 0.9 ) ) # 0.7833269238471985
Sqr ( fValue )
Computes square.
Parameters
- fValue [IN] Floating-point value - float
Returns
- Square of arg, fValue * fValue - float
1 print( RLPy.RMath.Sqr( 0.9 ) ) # 0.809999942779541
Sqrt ( fValue )
Computes square root.
Parameters
- fValue [IN] Floating-point value - float
Returns
- Square root of arg - float
1 print( RLPy.RMath.Sqrt( 0.9 ) ) # 0.9486832618713379
SymmetricRandom ( args )
Generate a random number between -1 and 1. The random number generator may be seeded by a first call to SymmetricRandom with a positive seed.
Parameters
- fSeed [IN] Seeded value - float
Returns
- Random value - float [-1,1]
1 print( RLPy.RMath.SymmetricRandom( 5.0 ) ) # -0.9967039823532104
2 print( RLPy.RMath.SymmetricRandom() ) # 0.7513352036476135
Tan ( fValue )
Computes the tangent of a value.
Parameters
- fValue [IN] Angle in radians - float
Returns
- Tangent of fValue - float
1 print( RLPy.RMath.Tan( 0.9 ) ) # 1.2601581811904907
UnitRandom ( args )
Generate a random value between 0 and 1. The random number generator may be seeded by a first call to UnitRandom with a positive seed.
Parameters
- fSeed [IN] Seeded value - float
Returns
- Random value - float [0,1]
1 print( RLPy.RMath.UnitRandom( 5.0 ) ) # 0.0016479995101690292
2 print( RLPy.RMath.UnitRandom() ) # 0.8756675720214844