public bool PosTest1() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest1: Verify the monotonicity of cosh function..."); try { float variable = TestLibrary.Generator.GetSingle(-55); float value1 = MathF.Cosh(variable); float positiveoffset = MathF.Exp(-15); float value2 = MathF.Cosh(variable + positiveoffset); if (value2 <= value1) { TestLibrary.TestFramework.LogError("001", "the monotonicity of cosh function [x>=y -> cosh(x)>=cosh(y)]"); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("002", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
public bool PosTest2() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest2: Verify the evenness of cosh function [cosh(x)=cosh(-x)]"); try { float variable = TestLibrary.Generator.GetSingle(-55); float value1 = MathF.Cosh(variable); float value2 = MathF.Cosh(-variable); if (!MathFTestLib.SingleIsWithinEpsilon(value1, value2)) { TestLibrary.TestFramework.LogError("003", "The parity of cosh should be even function!"); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
public bool PosTest5() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest5: Verify the value of cosh(float.MinValue)=+inf"); try { float variable = float.MinValue; float value = MathF.Cosh(variable); if (value != float.PositiveInfinity) { TestLibrary.TestFramework.LogError("009", "The value should be float.PositiveInfinity, actual: " + value.ToString()); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("010", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
/// <summary> /// Interpolates between two bookmarks. The t argument must be between 0 and 1 (inclusive), and /// the two endpoints must have the same mode (ORBIT or MAP). /// </summary> public static Bookmark Interpolate(Bookmark a, Bookmark b, float time) { Bookmark result = new Bookmark(); if (a.Mode == Mode.Map) { Debug.Assert(b.Mode == Mode.Map); float rho = MathF.Sqrt(2.0f); float rho2 = 2, rho4 = 4; float ux0 = a.Map.Center.X, uy0 = a.Map.Center.Y, w0 = a.Map.Extent; float ux1 = b.Map.Center.X, uy1 = b.Map.Center.Y, w1 = b.Map.Extent; float dx = ux1 - ux0; float dy = uy1 - uy0; float d2 = dx * dx + dy * dy; float d1 = MathF.Sqrt(d2); float b0 = (w1 * w1 - w0 * w0 + rho4 * d2) / (2.0f * w0 * rho2 * d1); float b1 = (w1 * w1 - w0 * w0 - rho4 * d2) / (2.0f * w1 * rho2 * d1); float r0 = MathF.Log(MathF.Sqrt(b0 * b0 + 1.0f) - b0); float r1 = MathF.Log(MathF.Sqrt(b1 * b1 + 1f) - b1); float dr = r1 - r0; bool valid = dr != 0; float s = ((valid ? dr : MathF.Log(w1 / w0)) / rho); s = time * s; // this performs Van Wijk interpolation to animate between two waypoints on a map. if (valid) { var coshr0 = MathF.Cosh(r0); var u = w0 / (rho2 * d1) * (coshr0 * MathF.Tanh(rho * s + r0) - MathF.Sinh(r0)); result.Map.Center.X = (ux0 + u * dx); result.Map.Center.Y = (uy0 + u * dy); result.Map.Extent = (w0 * coshr0 / MathF.Cosh(rho * s + r0)); return(result); } // for degenerate cases, fall back to a simplified interpolation method. result.Map.Center.X = ux0 + time * dx; result.Map.Center.Y = uy0 + time * dy; result.Map.Extent = (w0 * MathF.Exp(rho * s)); return(result); } Debug.Assert(b.Mode == Mode.Orbit); result.Orbit.Phi = MathUtils.Lerp(a.Orbit.Phi, b.Orbit.Phi, time); result.Orbit.Theta = MathUtils.Lerp(a.Orbit.Theta, b.Orbit.Theta, time); result.Orbit.Distance = MathUtils.Lerp(a.Orbit.Distance, b.Orbit.Distance, time); result.Orbit.Pivot = Vector3.Lerp(a.Orbit.Pivot, b.Orbit.Pivot, time); return(result); }
public bool PosTest3() { bool retVal = true; TestLibrary.TestFramework.BeginScenario("PosTest3: Verify the value of cosh(0) = 1..."); try { float zero = 0; float value = MathF.Cosh(zero); if (!MathFTestLib.SingleIsWithinEpsilon(value, 1)) { TestLibrary.TestFramework.LogError("005", "The value of cosh(0) should be 1, actual: " + value.ToString()); retVal = false; } } catch (Exception e) { TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e); retVal = false; } return(retVal); }
public static float Cosh(float value) => MathF.Cosh(value);
public static float cosh(float x) => MathF.Cosh(x);
public Test(Mode modeParam, TextWriter errorOutParam, TextWriter infoOutParam, Table table) { _table = table; _mode = modeParam; _errorOut = errorOutParam; _infoOut = infoOutParam; _failedOperations = new HashSet <string>(); // Validate parsing, this whole program expects little endian { uint val = 1234567891; if (Convert.ToUInt32(ToBinary(Convert.ToUInt32(ToBinary(val), 2)), 2) != val) { ReportError($"{nameof(ToBinary)} and back failed"); } } for (int testIndex = 0; testIndex < _table.Data.Length; testIndex++) { for (int testResult = 0; testResult < (_table.Data[testIndex].results?.Length ?? 0); testResult++) { var result = _table.Data[testIndex].results[testResult]; var asFloat = To <uint, float>(result.i); if (asFloat != result.f && !NaNAndBitsMatch(asFloat, result.f)) { ReportError($"FAILED PARSING {ToBinary(result.i)} to value {result.f.ToString("G9", CultureInfo.InvariantCulture)}, expected {ToBinary(result.f)}"); } } } for (int testIndex = 0; testIndex < _table.Data.Length; testIndex++) { float value = To <uint, float>(_table.Data[testIndex].initialValue); // Certain operations are funneling tests into specific ranges of values // so we aren't just using them as is, that is dVal's purpose in this code StartValidation(value); Validate(testIndex, "BIN", value); Validate(testIndex, "+", value + 0.1735f); Validate(testIndex, "-", value - 17f); Validate(testIndex, "*", value * 7.7757f); Validate(testIndex, "/", value / 0.3353f); Validate(testIndex, "%", value % 7.0f); // MATHF Validate(testIndex, nameof(MathF.Abs), MathF.Abs(value)); Validate(testIndex, nameof(MathF.Acos), MathF.Acos(value % 1f)); Validate(testIndex, nameof(MathF.Acosh), MathF.Acosh(1f + MathF.Abs(value))); Validate(testIndex, nameof(MathF.Asin), MathF.Asin(value % 1f)); Validate(testIndex, nameof(MathF.Asinh), MathF.Asinh(value)); Validate(testIndex, nameof(MathF.Atan), MathF.Atan(value)); Validate(testIndex, nameof(MathF.Atan2), MathF.Atan2(value, 0.17f)); Validate(testIndex, nameof(MathF.Atanh), MathF.Atanh(value % 1f)); Validate(testIndex, nameof(MathF.Cbrt), MathF.Cbrt(value)); Validate(testIndex, nameof(MathF.Ceiling), MathF.Ceiling(value)); Validate(testIndex, nameof(MathF.Cos), MathF.Cos(value)); Validate(testIndex, nameof(MathF.Cosh), MathF.Cosh(value % 2f)); Validate(testIndex, nameof(MathF.Exp), MathF.Exp(1f / value)); Validate(testIndex, nameof(MathF.Floor), MathF.Floor(value)); Validate(testIndex, nameof(MathF.FusedMultiplyAdd), MathF.FusedMultiplyAdd(value, 1.33f, -1.5f)); Validate(testIndex, nameof(MathF.IEEERemainder), MathF.IEEERemainder(value, 25.78f)); Validate(testIndex, nameof(MathF.Log), MathF.Log(MathF.Abs(value))); Validate(testIndex, nameof(MathF.Log) + "(x,y)", MathF.Log(MathF.Abs(value), 4f)); Validate(testIndex, nameof(MathF.Log2), MathF.Log2(MathF.Abs(value))); Validate(testIndex, nameof(MathF.Log10), MathF.Log10(MathF.Abs(value))); Validate(testIndex, nameof(MathF.Pow), MathF.Pow(MathF.Abs(value) % 1E+23f, 1.7f)); Validate(testIndex, nameof(MathF.ScaleB), MathF.ScaleB(value % 1E+23f, 2)); Validate(testIndex, nameof(MathF.Sin), MathF.Sin(value)); Validate(testIndex, nameof(MathF.Sinh), MathF.Sinh(value % 2f)); Validate(testIndex, nameof(MathF.Sqrt), MathF.Sqrt(MathF.Abs(value))); Validate(testIndex, nameof(MathF.Tan), MathF.Tan(value)); Validate(testIndex, nameof(MathF.Tanh), MathF.Tanh(value)); Validate(testIndex, nameof(MathF.Max), MathF.Max(value, 0.9f)); Validate(testIndex, nameof(MathF.MaxMagnitude), MathF.MaxMagnitude(value, -0.7f)); Validate(testIndex, nameof(MathF.Min), MathF.Min(value, 307f)); Validate(testIndex, nameof(MathF.MinMagnitude), MathF.MinMagnitude(value, -8.89f)); Validate(testIndex, nameof(MathF.Round), MathF.Round(value)); if (float.IsNaN(value) == false) { Validate(testIndex, nameof(MathF.Sign), MathF.Sign(value)); } Validate(testIndex, nameof(MathF.Truncate), MathF.Truncate(value)); // MATH double valueAsDouble = value; Validate(testIndex, $"D.{nameof(Math.Abs)}", Math.Abs(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Acos)}", Math.Acos(valueAsDouble % 1d)); Validate(testIndex, $"D.{nameof(Math.Acosh)}", Math.Acosh(1d + Math.Abs(valueAsDouble))); Validate(testIndex, $"D.{nameof(Math.Asin)}", Math.Asin(valueAsDouble % 1d)); Validate(testIndex, $"D.{nameof(Math.Asinh)}", Math.Asinh(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Atan)}", Math.Atan(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Atan2)}", Math.Atan2(valueAsDouble, 0.17d)); Validate(testIndex, $"D.{nameof(Math.Atanh)}", Math.Atanh(valueAsDouble % 1d)); Validate(testIndex, $"D.{nameof(Math.Cbrt)}", Math.Cbrt(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Ceiling)}", Math.Ceiling(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Cos)}", Math.Cos(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Cosh)}", Math.Cosh(valueAsDouble % 2d)); Validate(testIndex, $"D.{nameof(Math.Exp)}", Math.Exp(1d / valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Floor)}", Math.Floor(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.FusedMultiplyAdd)}", Math.FusedMultiplyAdd(valueAsDouble, 1.33d, -1.5d)); Validate(testIndex, $"D.{nameof(Math.IEEERemainder)}", Math.IEEERemainder(valueAsDouble, 25.78d)); Validate(testIndex, $"D.{nameof(Math.Log)}", Math.Log(Math.Abs(valueAsDouble))); Validate(testIndex, $"D.{nameof(Math.Log)}" + "(x,y)", Math.Log(Math.Abs(valueAsDouble), 4d)); Validate(testIndex, $"D.{nameof(Math.Log2)}", Math.Log2(Math.Abs(valueAsDouble))); Validate(testIndex, $"D.{nameof(Math.Log10)}", Math.Log10(Math.Abs(valueAsDouble))); Validate(testIndex, $"D.{nameof(Math.Pow)}", Math.Pow(Math.Abs(valueAsDouble) % 1E+23d, 1.7d)); Validate(testIndex, $"D.{nameof(Math.ScaleB)}", Math.ScaleB(valueAsDouble % 1E+23d, 2)); Validate(testIndex, $"D.{nameof(Math.Sin)}", Math.Sin(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Sinh)}", Math.Sinh(valueAsDouble % 2d)); Validate(testIndex, $"D.{nameof(Math.Sqrt)}", Math.Sqrt(Math.Abs(valueAsDouble))); Validate(testIndex, $"D.{nameof(Math.Tan)}", Math.Tan(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Tanh)}", Math.Tanh(valueAsDouble)); Validate(testIndex, $"D.{nameof(Math.Max)}", Math.Max(valueAsDouble, 0.9d)); Validate(testIndex, $"D.{nameof(Math.MaxMagnitude)}", Math.MaxMagnitude(valueAsDouble, -0.7d)); Validate(testIndex, $"D.{nameof(Math.Min)}", Math.Min(valueAsDouble, 307d)); Validate(testIndex, $"D.{nameof(Math.MinMagnitude)}", Math.MinMagnitude(valueAsDouble, -8.89d)); Validate(testIndex, $"D.{nameof(Math.Round)}", Math.Round(valueAsDouble)); if (float.IsNaN(value) == false) { Validate(testIndex, $"D.{nameof(Math.Sign)}", Math.Sign(valueAsDouble)); } Validate(testIndex, $"D.{nameof(Math.Truncate)}", Math.Truncate(valueAsDouble)); } }