Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Adding single-precision math functions. #5492

Merged
merged 7 commits into from Oct 18, 2016
@@ -11,6 +11,11 @@

#define IS_FLT_INFINITY(x) (((*((INT32*)((void*)&x))) & 0x7FFFFFFF) == 0x7F800000)

// Windows x86 and Windows ARM don't define _isnanf() but they do define a generic macro isnan()
#if (defined(_TARGET_X86_) || defined(_TARGET_ARM_)) && !defined(FEATURE_PAL) && !defined(_isnanf)
#define _isnanf isnan
#endif

// The default compilation mode is /fp:precise, which disables floating-point intrinsics. This
// default compilation mode has previously caused performance regressions in floating-point code.
// We enable /fp:fast semantics for the majority of the math functions, as it will speed up performance
@@ -39,6 +44,218 @@ FCIMPL1(float, COMSingle::Abs, float x)
return (float)fabsf(x);
FCIMPLEND

/*=====================================Acos=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Acos, float x)
FCALL_CONTRACT;

return (float)acosf(x);
FCIMPLEND

/*=====================================Asin=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Asin, float x)
FCALL_CONTRACT;

return (float)asinf(x);
FCIMPLEND

/*=====================================Atan=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Atan, float x)
FCALL_CONTRACT;

return (float)atanf(x);
FCIMPLEND

/*=====================================Atan2====================================
**
==============================================================================*/
FCIMPL2(float, COMSingle::Atan2, float y, float x)
FCALL_CONTRACT;

// atan2f(+/-INFINITY, +/-INFINITY) produces +/-0.785398163f (x is +INFINITY) and
// +/-2.35619449f (x is -INFINITY) instead of the expected value of NaN. We handle
// that case here ourselves.
if (IS_FLT_INFINITY(y) && IS_FLT_INFINITY(x)) {
return (float)(y / x);
}

return (float)atan2f(y, x);
FCIMPLEND

/*====================================Ceil======================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Ceil, float x)
FCALL_CONTRACT;

return (float)ceilf(x);
FCIMPLEND

/*=====================================Cos======================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Cos, float x)
FCALL_CONTRACT;

return (float)cosf(x);
FCIMPLEND

/*=====================================Cosh=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Cosh, float x)
FCALL_CONTRACT;

return (float)coshf(x);
FCIMPLEND

/*=====================================Exp======================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Exp, float x)
FCALL_CONTRACT;

return (float)expf(x);
FCIMPLEND

/*====================================Floor=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Floor, float x)
FCALL_CONTRACT;

return (float)floorf(x);
FCIMPLEND

/*=====================================Log======================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Log, float x)
FCALL_CONTRACT;

return (float)logf(x);
FCIMPLEND

/*====================================Log10=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Log10, float x)
FCALL_CONTRACT;

return (float)log10f(x);
FCIMPLEND

/*=====================================ModF=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::ModF, float* iptr)
FCALL_CONTRACT;

return (float)modff(*iptr, iptr);
FCIMPLEND

/*=====================================Pow======================================
**
==============================================================================*/
FCIMPL2(float, COMSingle::Pow, float x, float y)
FCALL_CONTRACT;

// The CRT version of pow preserves the NaN payload of x over the NaN payload of y.

if(_isnanf(y)) {
return y; // IEEE 754-2008: NaN payload must be preserved
}

if(_isnanf(x)) {
return x; // IEEE 754-2008: NaN payload must be preserved
}

// The CRT version of powf does not return NaN for powf(-1.0f, +/-INFINITY) and
// instead returns +1.0f.

if(IS_FLT_INFINITY(y) && (x == -1.0f)) {
INT32 result = CLR_NAN_32;
return (*((float*)((INT32*)&result)));
}

return (float)powf(x, y);
FCIMPLEND

/*====================================Round=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Round, float x)
FCALL_CONTRACT;

// If the number has no fractional part do nothing
// This shortcut is necessary to workaround precision loss in borderline cases on some platforms
if (x == (float)((INT32)x)) {
return x;
}

// We had a number that was equally close to 2 integers.
// We need to return the even one.

float tempVal = (x + 0.5f);
float flrTempVal = floorf(tempVal);

if ((flrTempVal == tempVal) && (fmodf(tempVal, 2.0f) != 0)) {
flrTempVal -= 1.0f;
}

return _copysignf(flrTempVal, x);
FCIMPLEND

/*=====================================Sin======================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Sin, float x)
FCALL_CONTRACT;

return (float)sinf(x);
FCIMPLEND

/*=====================================Sinh=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Sinh, float x)
FCALL_CONTRACT;

return (float)sinhf(x);
FCIMPLEND

/*=====================================Sqrt=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Sqrt, float x)
FCALL_CONTRACT;

return (float)sqrtf(x);
FCIMPLEND

/*=====================================Tan======================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Tan, float x)
FCALL_CONTRACT;

return (float)tanf(x);
FCIMPLEND

/*=====================================Tanh=====================================
**
==============================================================================*/
FCIMPL1(float, COMSingle::Tanh, float x)
FCALL_CONTRACT;

return (float)tanhf(x);
FCIMPLEND

#ifdef _MSC_VER
#pragma float_control(precise, on )
#endif
@@ -11,6 +11,25 @@
class COMSingle {
public:
FCDECL1(static float, Abs, float x);
FCDECL1(static float, Acos, float x);
FCDECL1(static float, Asin, float x);
FCDECL1(static float, Atan, float x);
FCDECL2(static float, Atan2, float y, float x);
FCDECL1(static float, Ceil, float x);
FCDECL1(static float, Cos, float x);
FCDECL1(static float, Cosh, float x);
FCDECL1(static float, Exp, float x);
FCDECL1(static float, Floor, float x);
FCDECL1(static float, Log, float x);
FCDECL1(static float, Log10, float x);
FCDECL1(static float, ModF, float* iptr);
FCDECL2(static float, Pow, float x, float y);
FCDECL1(static float, Round, float x);
FCDECL1(static float, Sin, float x);
FCDECL1(static float, Sinh, float x);
FCDECL1(static float, Sqrt, float x);
FCDECL1(static float, Tan, float x);
FCDECL1(static float, Tanh, float x);
};

#endif // _FLOATSINGLE_H_
Copy path View file
@@ -447,6 +447,7 @@
</Type>
<Type Name="System.BitConverter">
<Member Name="DoubleToInt64Bits(System.Double)" />
<Member Name="Int32BitsToSingle(System.Int32)" />
<Member Name="Int64BitsToDouble(System.Int64)" />
<Member MemberType="Field" Name="IsLittleEndian" />
<Member Name="GetBytes(System.Boolean)" />
@@ -459,6 +460,7 @@
<Member Name="GetBytes(System.UInt32)" />
<Member Name="GetBytes(System.UInt64)" />
<Member Name="GetBytes(System.UInt16)" />
<Member Name="SingleToInt32Bits(System.Single)" />
<Member Name="ToBoolean(System.Byte[],System.Int32)" />
<Member Name="ToChar(System.Byte[],System.Int32)" />
<Member Name="ToDouble(System.Byte[],System.Int32)" />
@@ -3660,6 +3662,38 @@
<Member Name="Truncate(System.Decimal)" />
<Member Name="Truncate(System.Double)" />
</Type>
<Type Name="System.MathF">
<Member MemberType="Field" Name="E" />
<Member MemberType="Field" Name="PI" />
<Member Name="Abs(System.Single)" />
<Member Name="Acos(System.Single)" />
<Member Name="Asin(System.Single)" />
<Member Name="Atan(System.Single)" />
<Member Name="Atan2(System.Single,System.Single)" />
<Member Name="Ceiling(System.Single)"/>
<Member Name="Cos(System.Single)" />
<Member Name="Cosh(System.Single)" />
<Member Name="Exp(System.Single)" />
<Member Name="Floor(System.Single)" />
<Member Name="IEEERemainder(System.Single,System.Single)" />
<Member Name="Log(System.Single)" />
<Member Name="Log(System.Single,System.Single)" />
<Member Name="Log10(System.Single)" />
<Member Name="Max(System.Single,System.Single)" />
<Member Name="Min(System.Single,System.Single)" />
<Member Name="Pow(System.Single,System.Single)" />
<Member Name="Round(System.Single)" />
<Member Name="Round(System.Single,System.Int32)" />
<Member Name="Round(System.Single,System.Int32,System.MidpointRounding)" />
<Member Name="Round(System.Single,System.MidpointRounding)" />
<Member Name="Sign(System.Single)" />
<Member Name="Sin(System.Single)" />
<Member Name="Sinh(System.Single)" />
<Member Name="Sqrt(System.Single)" />
<Member Name="Tan(System.Single)" />
<Member Name="Tanh(System.Single)" />
<Member Name="Truncate(System.Single)" />
</Type>
<Type Name="System.MemberAccessException">
<Member Name="#ctor" />
<Member Name="#ctor(System.String)" />
@@ -369,6 +369,7 @@
<SystemSources Include="$(BclSourcesRoot)\System\_LocalDataStoreMgr.cs" />
<SystemSources Include="$(BclSourcesRoot)\System\MarshalByRefObject.cs" />
<SystemSources Include="$(BclSourcesRoot)\System\Math.cs" />
<SystemSources Include="$(BclSourcesRoot)\System\MathF.cs" />
<SystemSources Include="$(BclSourcesRoot)\System\mda.cs" />
<SystemSources Include="$(BclSourcesRoot)\System\MethodAccessException.cs" />
<SystemSources Include="$(BclSourcesRoot)\System\MidpointRounding.cs" />
Copy path View file
@@ -603,7 +603,11 @@ public static partial class BitConverter
[System.CLSCompliantAttribute(false)]
public static byte[] GetBytes(ulong value) { throw null; }
[System.Security.SecuritySafeCriticalAttribute]
public static float Int32BitsToSingle(int value) { throw null; }
[System.Security.SecuritySafeCriticalAttribute]
public static double Int64BitsToDouble(long value) { throw null; }
[System.Security.SecuritySafeCriticalAttribute]
public static int SingleToInt32Bits(float value) { throw null; }
public static bool ToBoolean(byte[] value, int startIndex) { throw null; }
public static char ToChar(byte[] value, int startIndex) { throw null; }
[System.Security.SecuritySafeCriticalAttribute]
@@ -2622,6 +2626,59 @@ public static partial class Math
public static decimal Truncate(decimal d) { throw null; }
public static double Truncate(double d) { throw null; }
}
public static partial class MathF
{
public const float E = 2.71828183f;
public const float PI = 3.14159265f;
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Abs(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Acos(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Asin(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Atan(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Atan2(float y, float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Ceiling(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Cos(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Cosh(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Exp(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Floor(float x) { return default(float); }
public static float IEEERemainder(float x, float y) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Log(float x) { return default(float); }
public static float Log(float x, float y) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Log10(float x) { return default(float); }
public static float Max(float x, float y) { return default(float); }
public static float Min(float x, float y) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Pow(float x, float y) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Round(float x) { return default(float); }
public static float Round(float x, int digits) { return default(float); }
public static float Round(float x, int digits, System.MidpointRounding mode) { return default(float); }
public static float Round(float x, System.MidpointRounding mode) { return default(float); }
public static int Sign(float x) { return default(int); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Sin(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Sinh(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)]
[System.Security.SecuritySafeCriticalAttribute]
public static float Sqrt(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Tan(float x) { return default(float); }
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.InternalCall)][System.Security.SecuritySafeCriticalAttribute]
public static float Tanh(float x) { return default(float); }
public static float Truncate(float x) { return default(float); }
}
[System.Runtime.InteropServices.ComVisibleAttribute(true)]
public partial class MemberAccessException : System.SystemException
{
Oops, something went wrong.
ProTip! Use n and p to navigate between commits in a pull request.
You can’t perform that action at this time.