Swift Package IndexBuild Information
Failed to build Euler, reference main (f54c76), with Swift 6.3 for Linux on 20 Apr 2026 21:02:02 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-4606859-1":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:basic-6.3-latest swift build --triple x86_64-unknown-linux-gnu 2>&1Build Log
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 | let delta = b * b - 4 * a * c
321 | guard delta >= 0 else { return [] }
322 | if delta == 0 {
| `- error: ambiguous use of operator '=='
323 | return [(-b) / (2*a)]
324 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
45 | diff.sign = false
46 |
47 | if diff > 0 && base.sign == true {
| `- error: ambiguous use of operator '>'
48 | return div - 1
49 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
62 |
63 | div.sign = base.sign
64 | if diff > 0 {
| `- error: ambiguous use of operator '>'
65 | return div + 1
66 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 | */
305 | public var scientificDescription: String {
306 | if self == .zero {
| `- error: ambiguous use of operator '=='
307 | return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 | return self.decimalDescription
323 | } else {
324 | guard let index = d.index(of: ".") else {
| |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
| `- note: use 'firstIndex(of:)' instead
325 | let rounded = self.rounded()
326 | return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 | return rounded.scientificDescription
327 | }
328 | power = index.encodedOffset - 1
| `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 | }
330 | d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[64/85] Compiling Euler BasicOperators.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 | return ConstantNode(ev1 - ev2)
112 | case "/":
113 | guard ev2 != .zero else {
| `- error: ambiguous use of operator '!='
114 | return self
115 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 | return ConstantNode(ev1 ** ev2)
121 | case "!":
122 | guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
| `- error: ambiguous use of operator '>='
123 | let i = ev1.rounded()
124 | if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 | public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 | return CellValue(number: ev1 - ev2)
154 | case "/":
155 | guard ev2 != .zero else {
| `- error: ambiguous use of operator '!='
156 | throw EvaluationError.ImpossibleOperation
157 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 | return CellValue(number: ev1 ** ev2)
163 | case "!":
164 | guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
| `- error: ambiguous use of operator '>='
165 | let i = ev1.rounded()
166 | if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 | public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
85 | var i = 0;
86 | for coef in self.coefs {
87 | if coef != 0 {
| `- error: ambiguous use of operator '!='
88 | return power(at: i)
89 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 | if i == first_idx {
217 | let val = self.coefs[i]
218 | if val != 1 {
| `- error: ambiguous use of operator '!='
219 | do_normalize = true
220 | norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 | let delta = b * b - 4 * a * c
321 | guard delta >= 0 else { return [] }
| `- error: ambiguous use of operator '>='
322 | if delta == 0 {
323 | return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 | public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 | let delta = b * b - 4 * a * c
321 | guard delta >= 0 else { return [] }
322 | if delta == 0 {
| `- error: ambiguous use of operator '=='
323 | return [(-b) / (2*a)]
324 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
45 | diff.sign = false
46 |
47 | if diff > 0 && base.sign == true {
| `- error: ambiguous use of operator '>'
48 | return div - 1
49 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
62 |
63 | div.sign = base.sign
64 | if diff > 0 {
| `- error: ambiguous use of operator '>'
65 | return div + 1
66 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 | */
305 | public var scientificDescription: String {
306 | if self == .zero {
| `- error: ambiguous use of operator '=='
307 | return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 | return self.decimalDescription
323 | } else {
324 | guard let index = d.index(of: ".") else {
| |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
| `- note: use 'firstIndex(of:)' instead
325 | let rounded = self.rounded()
326 | return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 | return rounded.scientificDescription
327 | }
328 | power = index.encodedOffset - 1
| `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 | }
330 | d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[65/85] Compiling Euler BigDouble.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 | return ConstantNode(ev1 - ev2)
112 | case "/":
113 | guard ev2 != .zero else {
| `- error: ambiguous use of operator '!='
114 | return self
115 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 | return ConstantNode(ev1 ** ev2)
121 | case "!":
122 | guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
| `- error: ambiguous use of operator '>='
123 | let i = ev1.rounded()
124 | if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 | public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 | return CellValue(number: ev1 - ev2)
154 | case "/":
155 | guard ev2 != .zero else {
| `- error: ambiguous use of operator '!='
156 | throw EvaluationError.ImpossibleOperation
157 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 | return CellValue(number: ev1 ** ev2)
163 | case "!":
164 | guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
| `- error: ambiguous use of operator '>='
165 | let i = ev1.rounded()
166 | if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 | public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
85 | var i = 0;
86 | for coef in self.coefs {
87 | if coef != 0 {
| `- error: ambiguous use of operator '!='
88 | return power(at: i)
89 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 | if i == first_idx {
217 | let val = self.coefs[i]
218 | if val != 1 {
| `- error: ambiguous use of operator '!='
219 | do_normalize = true
220 | norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 | let delta = b * b - 4 * a * c
321 | guard delta >= 0 else { return [] }
| `- error: ambiguous use of operator '>='
322 | if delta == 0 {
323 | return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 | public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 | public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
| `- note: found this candidate
359 | public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
| `- note: found this candidate
360 | public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 | let delta = b * b - 4 * a * c
321 | guard delta >= 0 else { return [] }
322 | if delta == 0 {
| `- error: ambiguous use of operator '=='
323 | return [(-b) / (2*a)]
324 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
45 | diff.sign = false
46 |
47 | if diff > 0 && base.sign == true {
| `- error: ambiguous use of operator '>'
48 | return div - 1
49 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
62 |
63 | div.sign = base.sign
64 | if diff > 0 {
| `- error: ambiguous use of operator '>'
65 | return div + 1
66 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 | */
305 | public var scientificDescription: String {
306 | if self == .zero {
| `- error: ambiguous use of operator '=='
307 | return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 | return self.decimalDescription
323 | } else {
324 | guard let index = d.index(of: ".") else {
| |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
| `- note: use 'firstIndex(of:)' instead
325 | let rounded = self.rounded()
326 | return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 | return rounded.scientificDescription
327 | }
328 | power = index.encodedOffset - 1
| `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 | }
330 | d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[66/85] Compiling Euler OperationsBigDouble.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[67/85] Compiling Euler BigInt.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[68/85] Compiling Euler BinaryBigInt.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[69/85] Compiling Euler OperationsBigInt.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[70/85] Compiling Euler Limbs.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[71/85] Compiling Euler RSA.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[72/85] Compiling Euler md5.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[73/85] Compiling Euler sha256.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[74/85] Compiling Euler Euler.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[75/85] Compiling Euler Array.swift
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:302:24: error: ambiguous use of operator '=='
300 | } else if diff <= epsilon {
301 | return true // shortcut
302 | } else if (lhs == 0 || rhs == 0 || diff < Double.leastNormalMagnitude) {
| `- error: ambiguous use of operator '=='
303 | // lhs or rhs is zero or both are extremely close to it
304 | // relative error is less meaningful here
:
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Cryptography/sha256.swift:28:16: warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
26 | let bytes: Array<UInt8> = Array(self)
27 | let result = SHA256(bytes).calculate32()
28 | return Data(bytes: result)
| `- warning: 'init(bytes:)' is deprecated: use `init(_:)` instead [#DeprecatedDeclaration]
29 | }
30 | }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[76/85] Compiling Euler Average.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[77/85] Compiling Euler Correlation.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[78/85] Compiling Euler Fisher.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[79/85] Compiling Euler Gauss.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[80/85] Compiling Euler Quantile.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[81/85] Compiling Euler Regression.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[82/85] Compiling Euler Statistics.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[83/85] Compiling Euler Variance.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[84/85] Compiling Euler CellValue.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
[85/85] Compiling Euler CommonFormulas.swift
/host/spi-builder-workspace/Sources/Euler/Statistics/Average.swift:100:23: error: ambiguous use of operator '!='
98 | let sum = tmp.reduce(0, +) // Sum of the entire list
99 | let coefSum = coefficients.reduce(0, +)
100 | guard coefSum != 0 else { throw AverageError.CoefficientIssue }
| `- error: ambiguous use of operator '!='
101 | let av = sum / coefSum
102 | return av
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:17:14: error: ambiguous use of operator '>'
15 | /// - Returns: `$\operatorname{erf}(x)$`
16 | static func ERF(at x: BigDouble) -> BigDouble {
17 | if x > 10 {
| `- error: ambiguous use of operator '>'
18 | return 1
19 | } else if x < -10 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Statistics/Gauss.swift:19:21: error: ambiguous use of operator '<'
17 | if x > 10 {
18 | return 1
19 | } else if x < -10 {
| `- error: ambiguous use of operator '<'
20 | return -1
21 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:335:24: note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
335 | public static func <(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
336 | {
337 | if lhs.sign != rhs.sign { return lhs.sign }
:
345 | return ad.lessThan(bc)
346 | }
347 | public static func <(lhs: BigDouble, rhs: Double) -> Bool { return lhs < BigDouble(rhs) }
| `- note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:117:28: error: ambiguous use of operator '!='
115 | /// - mode: Either 0 or 1 (0 by default, flooring). It will choose between flooring or ceiling the number if it's negative.
116 | func CEILING(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
117 | guard significance != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
118 | if number.isPositive() {
119 | return ceil(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:182:18: error: ambiguous use of operator '!='
180 | func COTH(_ number: BigNumber) throws -> BigNumber {
181 | let e2 = exp(2 * number)
182 | guard e2 != 1 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
183 | return (e2 + 1) / (e2 - 1)
184 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:255:28: error: ambiguous use of operator '!='
253 | /// - mode: Either 0 or 1 (0 by default, ceiling). It will choose between flooring or ceiling the number if it's negative.
254 | func FLOOR(_ number: BigDouble, significance: BigDouble = 1, mode: Int = 0) throws -> BigDouble {
255 | guard significance != .zero else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
256 | if number.isPositive() {
257 | return floor(number / significance) * significance
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:331:19: error: ambiguous use of operator '!='
329 | func LOG(_ n: BigDouble, base: BigDouble = 10) throws -> BigDouble {
330 | let den = LN(base)
331 | guard den != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
332 | return LN(n) / den
333 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:452:27: error: ambiguous use of operator '!='
450 | /// - denominator: The divisor.
451 | func QUOTIENT(_ numerator: BigDouble, _ denominator: BigDouble) throws -> BigInt {
452 | guard denominator != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
453 | let div = numerator / denominator
454 | return ceil(div)
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:507:34: error: ambiguous use of operator '>'
505 | /// - digits: The number of digits to which you want to round number.
506 | func ROUNDDOWN(_ n: BigDouble, digits: BigInt) -> BigDouble {
507 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
508 | let powed = pow(10, digits)
509 | return sign * BigDouble(floor(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:517:34: error: ambiguous use of operator '>'
515 | /// - digits: The number of digits to which you want to round number.
516 | func ROUNDUP(_ n: BigDouble, digits: BigInt) -> BigDouble {
517 | let sign: BigDouble = (n > 0) ? 1 : -1
| `- error: ambiguous use of operator '>'
518 | let powed = pow(10, digits)
519 | return sign * BigDouble(ceil(abs(n) * powed)) / powed
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:578:22: error: ambiguous use of operator '=='
576 | if (n.sign == true) {
577 | return -1;
578 | } else if (n == .zero) {
| `- error: ambiguous use of operator '=='
579 | return 0;
580 | } else {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 | return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 | }
318 | public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
| `- note: found this candidate
319 | if lhs.sign != rhs.sign { return false }
320 | if lhs.numerator != rhs.numerator { return false }
:
323 | return true
324 | }
325 | public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
| `- note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:647:17: error: ambiguous use of operator '!='
645 | /// - b: Any real
646 | func DIVIDE(_ a: BigDouble, _ b: BigDouble) throws -> BigDouble {
647 | guard b != 0 else { throw TablesError.DivisionByZero }
| `- error: ambiguous use of operator '!='
648 | return a / b
649 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 | public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 | public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
| `- note: found this candidate
329 | {
330 | return !(lhs == rhs)
331 | }
332 | public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
| `- note: found this candidate
333 | public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/CommonFormulas.swift:806:28: error: ambiguous use of operator '>'
804 | /// - digits: Optional. A number specifying the precision of the truncation.
805 | func TRUNC(_ number: BigDouble, _ digits: Int = 0) -> BigDouble {
806 | let sign = (number > 0) ? 1 : -1;
| `- error: ambiguous use of operator '>'
807 | return BigDouble(sign) * BigDouble(floor(abs(number) * pow(10, digits))) / pow(10, digits)
808 | }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 | public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 | public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
| `- note: found this candidate
351 | public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
| `- note: found this candidate
352 | public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
BUILD FAILURE 6.3 linux