From 10fd13196456de9e03949cec35c58e3c3d2a24d0 Mon Sep 17 00:00:00 2001 From: "Steve (Numerics) Canon" Date: Tue, 2 Apr 2019 17:46:34 -0400 Subject: [PATCH] Test fixes. --- test/stdlib/MathFunctions.swift.gyb | 168 ++++++++++++++++++++++++++++ test/stdlib/tgmath.swift.gyb | 1 - 2 files changed, 168 insertions(+), 1 deletion(-) create mode 100644 test/stdlib/MathFunctions.swift.gyb diff --git a/test/stdlib/MathFunctions.swift.gyb b/test/stdlib/MathFunctions.swift.gyb new file mode 100644 index 0000000000000..03d6b8eff91bf --- /dev/null +++ b/test/stdlib/MathFunctions.swift.gyb @@ -0,0 +1,168 @@ +//===--- Math.swift.gyb ---------------------------------------*- swift -*-===// +// +// This source file is part of the Swift.org open source project +// +// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors +// Licensed under Apache License v2.0 with Runtime Library Exception +// +// See https://swift.org/LICENSE.txt for license information +// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors +// +//===----------------------------------------------------------------------===// +// -*- swift -*- +// RUN: %empty-directory(%t) +// RUN: %gyb %s -o %t/tgmath.swift +// RUN: %line-directive %t/tgmath.swift -- %target-build-swift %t/tgmath.swift -o %t/a.out +// RUN: %target-codesign %t/a.out +// RUN: %line-directive %t/tgmath.swift -- %target-run %t/a.out +// REQUIRES: executable_test + +#if (arch(i386) || arch(x86_64)) && !os(Windows) + typealias TestLiteralType = Float80 +#else + typealias TestLiteralType = Double +#endif + +import StdlibUnittest + +let MathTests = TestSuite("Math") + +func expectEqualWithTolerance(_ expected: TestLiteralType, _ actual: T, + ulps allowed: T = 3, + file: String = #file, line: UInt = #line) + where T: BinaryFloatingPoint { + if actual == T(expected) || actual.isNaN && expected.isNaN { + return + } + // Compute error in ulp, compare to tolerance. + let absoluteError = T(abs(TestLiteralType(actual) - expected)) + let ulpError = absoluteError / T(expected).ulp + expectTrue(ulpError <= allowed, + "\(actual) != \(expected) as \(T.self)" + + "\n \(ulpError)-ulp error exceeds \(allowed)-ulp tolerance.", + file: file, line: line) +} + +%from SwiftMathFunctions import * + +internal extension ElementaryFunctions where Self: BinaryFloatingPoint { + static func elementaryFunctionTests() { + /* Default tolerance is 3 ulps unless specified otherwise. It's OK to relax + * this as needed for new platforms, as these tests are *not* intended to + * validate the math library--they are only intended to check that the + * Swift bindings are calling the right functions in the math library. */ + expectEqualWithTolerance(1.1863995522992575361931268186727044683, Self.acos(0.375)) + expectEqualWithTolerance(0.3843967744956390830381948729670469737, Self.asin(0.375)) + expectEqualWithTolerance(0.3587706702705722203959200639264604997, Self.atan(0.375)) + expectEqualWithTolerance(0.9305076219123142911494767922295555080, Self.cos(0.375)) + expectEqualWithTolerance(0.3662725290860475613729093517162641571, Self.sin(0.375)) + expectEqualWithTolerance(0.3936265759256327582294137871012180981, Self.tan(0.375)) + expectEqualWithTolerance(0.4949329230945269058895630995767185785, Self.acosh(1.125)) + expectEqualWithTolerance(0.9670596312833237113713762009167286709, Self.asinh(1.125)) + expectEqualWithTolerance(0.7331685343967135223291211023213964500, Self.atanh(0.625)) + expectEqualWithTolerance(1.0711403467045867672994980155670160493, Self.cosh(0.375)) + expectEqualWithTolerance(0.3838510679136145687542956764205024589, Self.sinh(0.375)) + expectEqualWithTolerance(0.3583573983507859463193602315531580424, Self.tanh(0.375)) + expectEqualWithTolerance(1.4549914146182013360537936919875185083, Self.exp(0.375)) + expectEqualWithTolerance(1.2968395546510096659337541177924511598, Self.exp2(0.375)) + expectEqualWithTolerance(2.3713737056616552616517527574788898386, Self.exp10(0.375)) + expectEqualWithTolerance(0.4549914146182013360537936919875185083, Self.expm1(0.375)) + expectEqualWithTolerance(-0.980829253011726236856451127452003999, Self.log(0.375)) + expectEqualWithTolerance(-1.415037499278843818546261056052183491, Self.log2(0.375)) + expectEqualWithTolerance(0.3184537311185346158102472135905995955, Self.log1p(0.375)) + expectEqualWithTolerance(-0.425968732272281148346188780918363771, Self.log10(0.375)) + expectEqualWithTolerance(0.7211247851537041911608191553900547941, Self.root(0.375, 3)) + expectEqualWithTolerance(0.6123724356957945245493210186764728479, Self.sqrt(0.375)) + expectEqualWithTolerance(0.54171335479545025876069682133938570, Self.pow(0.375, 0.625)) + expectEqualWithTolerance(-0.052734375, Self.pow(-0.375, 3)) + + expectEqual(Self.acos(0.375), acos(0.375)) + expectEqual(Self.asin(0.375), asin(0.375)) + expectEqual(Self.atan(0.375), atan(0.375)) + expectEqual(Self.cos(0.375), cos(0.375)) + expectEqual(Self.sin(0.375), sin(0.375)) + expectEqual(Self.tan(0.375), tan(0.375)) + expectEqual(Self.acosh(1.125), acosh(1.125)) + expectEqual(Self.asinh(1.125), asinh(1.125)) + expectEqual(Self.atanh(0.625), atanh(0.625)) + expectEqual(Self.cosh(0.375), cosh(0.375)) + expectEqual(Self.sinh(0.375), sinh(0.375)) + expectEqual(Self.tanh(0.375), tanh(0.375)) + expectEqual(Self.exp(0.375), exp(0.375)) + expectEqual(Self.exp2(0.375), exp2(0.375)) + expectEqual(Self.exp10(0.375), exp10(0.375)) + expectEqual(Self.expm1(0.375), expm1(0.375)) + expectEqual(Self.log(0.375), log(0.375)) + expectEqual(Self.log2(0.375), log2(0.375)) + expectEqual(Self.log1p(0.375), log1p(0.375)) + expectEqual(Self.log10(0.375), log10(0.375)) + expectEqual(Self.sqrt(0.375), sqrt(0.375)) + expectEqual(Self.pow(0.375, 0.625), pow(0.375, 0.625)) + expectEqual(Self.root(0.375, 3), root(0.375, 3)) + expectEqual(Self.pow(-0.375, 3), pow(-0.375, 3)) + } +} + +internal extension Real where Self: BinaryFloatingPoint { + static func realFunctionTests() { + expectEqualWithTolerance(0.54041950027058415544357836460859991, Self.atan2(y: 0.375, x: 0.625)) + expectEqualWithTolerance(0.72886898685566255885926910969319788, Self.hypot(0.375, 0.625)) + expectEqualWithTolerance(0.4041169094348222983238250859191217675, Self.erf(0.375)) + expectEqualWithTolerance(0.5958830905651777016761749140808782324, Self.erfc(0.375)) + expectEqualWithTolerance(2.3704361844166009086464735041766525098, Self.gamma(0.375)) +#if !os(Windows) + expectEqualWithTolerance( -0.11775527074107877445136203331798850, Self.logGamma(1.375), ulps: 16) + expectEqual(.plus, Self.signGamma(1.375)) + expectEqual(.minus, Self.signGamma(-2.375)) +#endif + + expectEqual(Self.atan2(y: 0.375, x: 0.625), atan2(y: 0.375, x: 0.625)) + expectEqual(Self.hypot(0.375, 0.625), hypot(0.375, 0.625)) + expectEqual(Self.erf(0.375), erf(0.375)) + expectEqual(Self.erfc(0.375), erfc(0.375)) + expectEqual(Self.gamma(0.375), gamma(0.375)) +#if !os(Windows) + expectEqual(Self.logGamma(1.375), logGamma(1.375)) + expectEqual(Self.signGamma(1.375), signGamma(1.375)) + expectEqual(Self.signGamma(-2.375), signGamma(-2.375)) +#endif + } +} + +internal extension BinaryFloatingPoint { + static func floatingPointFunctionTests() { + expectEqual(1 as Self, ceil(0.375)) + expectEqual(0 as Self, floor(0.375)) + expectEqual(0 as Self, Swift.round(0.375)) + expectEqual(0 as Self, trunc(0.375)) + expectEqual(0 as Self, ceil(-0.625)) + expectEqual(-1 as Self, floor(-0.625)) + expectEqual(-1 as Self, Swift.round(-0.625)) + expectEqual(0 as Self, trunc(-0.625)) + expectEqual(1 as Self, ceil(0.5)) + expectEqual(0 as Self, floor(0.5)) + expectEqual(1 as Self, Swift.round(0.5)) + expectEqual(0 as Self, trunc(0.5)) + } +} + +%for T in ['Float', 'Double', 'CGFloat', 'Float80']: +% if T == 'Float80': +#if (arch(i386) || arch(x86_64)) && !os(Windows) +% elif T == 'CGFloat': +#if canImport(CoreGraphics) + import CoreGraphics +% end + +MathTests.test("${T}") { + ${T}.elementaryFunctionTests() + ${T}.realFunctionTests() + ${T}.floatingPointFunctionTests() +} + +% if T in ['CGFloat', 'Float80']: +#endif +% end +%end + +runAllTests() diff --git a/test/stdlib/tgmath.swift.gyb b/test/stdlib/tgmath.swift.gyb index 6d233c667ddfd..b4b7f123cab61 100644 --- a/test/stdlib/tgmath.swift.gyb +++ b/test/stdlib/tgmath.swift.gyb @@ -118,7 +118,6 @@ internal extension TGMath { expectEqual(-2, Self._logb(0.375)) expectEqual(0.375, Self._fabs(-0.375)) expectEqualWithTolerance(0.7211247851537041911608191553900547941, Self._cbrt(0.375)) - expectEqualWithTolerance(0.6123724356957945245493210186764728479, Self._sqrt(0.375)) expectEqualWithTolerance(0.4041169094348222983238250859191217675, Self._erf(0.375)) expectEqualWithTolerance(0.5958830905651777016761749140808782324, Self._erfc(0.375)) expectEqualWithTolerance(2.3704361844166009086464735041766525098, Self._tgamma(0.375))