Swift Package IndexBuild Information
Failed to build Euler, reference 0.3.12 (f54c76), with Swift 6.3 for macOS (SPM) on 20 Apr 2026 21:11:55 UTC.
Build Command
env DEVELOPER_DIR=/Applications/Xcode-26.4.0.app xcrun swift build --arch arm64Build Log
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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)
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/spi-builder-workspace/Sources/Euler/Tables/Formulas/Financial.swift:25:20: error: ambiguous use of operator '>'
23 | /// - Returns: Accrued interest for a security that pays periodic interest
24 | func ACCRINT(_ issue: Int, _ first: Int, _ settlement: Int, _ rate: BigDouble, _ par: BigDouble = 1000, _ frequency: Int = 1, _ basis: Int = 0) throws -> BigDouble {
25 | guard rate > 0 && par > 0 else { throw TablesError.Arguments }
| `- error: ambiguous use of operator '>'
26 | guard [1, 2, 4].contains(frequency) && [0, 1, 2, 3, 4].contains(basis) else { throw TablesError.Arguments }
27 | guard settlement > issue else { throw TablesError.Arguments }
/Users/admin/builder/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 |
[41/85] Compiling Euler DateTime.swift
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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)
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/spi-builder-workspace/Sources/Euler/Tables/Formulas/Financial.swift:25:20: error: ambiguous use of operator '>'
23 | /// - Returns: Accrued interest for a security that pays periodic interest
24 | func ACCRINT(_ issue: Int, _ first: Int, _ settlement: Int, _ rate: BigDouble, _ par: BigDouble = 1000, _ frequency: Int = 1, _ basis: Int = 0) throws -> BigDouble {
25 | guard rate > 0 && par > 0 else { throw TablesError.Arguments }
| `- error: ambiguous use of operator '>'
26 | guard [1, 2, 4].contains(frequency) && [0, 1, 2, 3, 4].contains(basis) else { throw TablesError.Arguments }
27 | guard settlement > issue else { throw TablesError.Arguments }
/Users/admin/builder/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 |
[42/85] Compiling Euler Engineering.swift
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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)
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/spi-builder-workspace/Sources/Euler/Tables/Formulas/Financial.swift:25:20: error: ambiguous use of operator '>'
23 | /// - Returns: Accrued interest for a security that pays periodic interest
24 | func ACCRINT(_ issue: Int, _ first: Int, _ settlement: Int, _ rate: BigDouble, _ par: BigDouble = 1000, _ frequency: Int = 1, _ basis: Int = 0) throws -> BigDouble {
25 | guard rate > 0 && par > 0 else { throw TablesError.Arguments }
| `- error: ambiguous use of operator '>'
26 | guard [1, 2, 4].contains(frequency) && [0, 1, 2, 3, 4].contains(basis) else { throw TablesError.Arguments }
27 | guard settlement > issue else { throw TablesError.Arguments }
/Users/admin/builder/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 |
[43/85] Compiling Euler Financial.swift
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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)
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/spi-builder-workspace/Sources/Euler/Tables/Formulas/Financial.swift:25:20: error: ambiguous use of operator '>'
23 | /// - Returns: Accrued interest for a security that pays periodic interest
24 | func ACCRINT(_ issue: Int, _ first: Int, _ settlement: Int, _ rate: BigDouble, _ par: BigDouble = 1000, _ frequency: Int = 1, _ basis: Int = 0) throws -> BigDouble {
25 | guard rate > 0 && par > 0 else { throw TablesError.Arguments }
| `- error: ambiguous use of operator '>'
26 | guard [1, 2, 4].contains(frequency) && [0, 1, 2, 3, 4].contains(basis) else { throw TablesError.Arguments }
27 | guard settlement > issue else { throw TablesError.Arguments }
/Users/admin/builder/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 |
[44/85] Compiling Euler Logical.swift
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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)
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/spi-builder-workspace/Sources/Euler/Tables/Formulas/Financial.swift:25:20: error: ambiguous use of operator '>'
23 | /// - Returns: Accrued interest for a security that pays periodic interest
24 | func ACCRINT(_ issue: Int, _ first: Int, _ settlement: Int, _ rate: BigDouble, _ par: BigDouble = 1000, _ frequency: Int = 1, _ basis: Int = 0) throws -> BigDouble {
25 | guard rate > 0 && par > 0 else { throw TablesError.Arguments }
| `- error: ambiguous use of operator '>'
26 | guard [1, 2, 4].contains(frequency) && [0, 1, 2, 3, 4].contains(basis) else { throw TablesError.Arguments }
27 | guard settlement > issue else { throw TablesError.Arguments }
/Users/admin/builder/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 |
[45/85] Compiling Euler Tree.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[46/85] Compiling Euler BNativeExtensions.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[47/85] Compiling Euler BasicOperators.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[48/85] Compiling Euler BigDouble.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[49/85] Compiling Euler OperationsBigDouble.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[50/85] Compiling Euler BigInt.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[51/85] Compiling Euler BinaryBigInt.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[52/85] Compiling Euler OperationsBigInt.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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: "")
/Users/admin/builder/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 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[53/85] Compiling Euler Tables.swift
[54/85] Compiling Euler TablesDataSource.swift
[55/85] Compiling Euler TablesDelegate.swift
[56/85] Compiling Euler KnuthDSupport.swift
[57/85] Compiling Euler Pointers.swift
[58/85] Compiling Euler Substring.swift
[59/85] Compiling Euler UnsafeMemory.swift
[60/85] Compiling Euler UnsafeMutableMemory.swift
[61/85] Compiling Euler Node.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[62/85] Compiling Euler NullNode.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[63/85] Compiling Euler OperatorNode.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[64/85] Compiling Euler StringNode.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[65/85] Compiling Euler SymbolNode.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[66/85] Compiling Euler Parser.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[67/85] Compiling Euler Regex.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[68/85] Compiling Euler Polynomial.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[69/85] Compiling Euler simplify.swift
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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 {
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
/Users/admin/builder/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
/Users/admin/builder/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 |
/Users/admin/builder/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)]
/Users/admin/builder/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 | }
/Users/admin/builder/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 | }
/Users/admin/builder/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 |
[70/85] Compiling Euler Limbs.swift
/Users/admin/builder/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
/Users/admin/builder/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
/Users/admin/builder/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
/Users/admin/builder/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
/Users/admin/builder/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
/Users/admin/builder/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 Collatz.swift
/Users/admin/builder/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>
[77/85] Compiling Euler Fibonacci.swift
/Users/admin/builder/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>
remark: Incremental compilation has been disabled: malformed dependencies file '/Users/admin/builder/spi-builder-workspace/.build/arm64-apple-macosx/debug/Euler.build/Fibonacci.swiftdeps'
[78/85] Compiling Euler Sieve.swift
[79/85] Compiling Euler Graph.swift
[80/85] Compiling Euler Point.swift
[81/85] Compiling Euler Vector.swift
[82/85] Compiling Euler MOperations.swift
[83/85] Compiling Euler MProperties.swift
[84/85] Compiling Euler Matrix.swift
[85/85] Compiling Euler Constants.swift
BUILD FAILURE 6.3 macosSpm