Swift Package Index

Build Information

Failed to build Euler, reference main (f54c76), with Swift 6.3 for Wasm on 20 Apr 2026 21:00:15 UTC.

Build Command

bash -c docker run --pull=always --rm -v "checkouts-4606859-0":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/swiftpackageindex/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3-RELEASE_wasm 2>&1

Build Log

331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:119:20: error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
119 |         guard div2 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
120 |         let p2 = (n - 1) / div2
121 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
[41/75] Compiling Euler DateLinker.swift
/host/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 }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:113:21: error: ambiguous use of operator '!='
111 |         }
112 |         let powed = pow(stats.standardDeviation, 4)
113 |         guard powed != 0 else { return 0 }
    |                     `- error: ambiguous use of operator '!='
114 |         sigma = sigma / powed
115 |         let div1 = ((n - 1) * (n - 2) * (n - 3))
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:116:20: error: ambiguous use of operator '!='
114 |         sigma = sigma / powed
115 |         let div1 = ((n - 1) * (n - 2) * (n - 3))
116 |         guard div1 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:119:20: error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
119 |         guard div2 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
120 |         let p2 = (n - 1) / div2
121 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
[42/75] Compiling Euler EngineeringLinker.swift
/host/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 }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:113:21: error: ambiguous use of operator '!='
111 |         }
112 |         let powed = pow(stats.standardDeviation, 4)
113 |         guard powed != 0 else { return 0 }
    |                     `- error: ambiguous use of operator '!='
114 |         sigma = sigma / powed
115 |         let div1 = ((n - 1) * (n - 2) * (n - 3))
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:116:20: error: ambiguous use of operator '!='
114 |         sigma = sigma / powed
115 |         let div1 = ((n - 1) * (n - 2) * (n - 3))
116 |         guard div1 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:119:20: error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
119 |         guard div2 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
120 |         let p2 = (n - 1) / div2
121 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
[43/75] Compiling Euler FinancialLinker.swift
/host/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 }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:113:21: error: ambiguous use of operator '!='
111 |         }
112 |         let powed = pow(stats.standardDeviation, 4)
113 |         guard powed != 0 else { return 0 }
    |                     `- error: ambiguous use of operator '!='
114 |         sigma = sigma / powed
115 |         let div1 = ((n - 1) * (n - 2) * (n - 3))
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:116:20: error: ambiguous use of operator '!='
114 |         sigma = sigma / powed
115 |         let div1 = ((n - 1) * (n - 2) * (n - 3))
116 |         guard div1 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Tables/Formulas/Statistical.swift:119:20: error: ambiguous use of operator '!='
117 |         let p1 = (n * (n + 1)) / div1
118 |         let div2 = ((n - 2) * (n - 3))
119 |         guard div2 != 0 else { return .zero }
    |                    `- error: ambiguous use of operator '!='
120 |         let p2 = (n - 1) / div2
121 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
[44/75] Compiling Euler OperatorNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[45/75] Compiling Euler StringNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[46/75] Compiling Euler SymbolNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[47/75] Compiling Euler Parser.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[48/75] Compiling Euler Regex.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[49/75] Compiling Euler Polynomial.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[50/75] Compiling Euler simplify.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[51/75] Compiling Euler Tree.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[52/75] Compiling Euler BNativeExtensions.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[53/75] Compiling Euler BasicOperators.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[54/75] Compiling Euler BigDouble.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:113:31: error: ambiguous use of operator '!='
111 |                     return ConstantNode(ev1 - ev2)
112 |                 case "/":
113 |                     guard ev2 != .zero else {
    |                               `- error: ambiguous use of operator '!='
114 |                         return self
115 |                     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:122:31: error: ambiguous use of operator '>='
120 |                     return ConstantNode(ev1 ** ev2)
121 |                 case "!":
122 |                     guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                               `- error: ambiguous use of operator '>='
123 |                     let i = ev1.rounded()
124 |                     if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:155:23: error: ambiguous use of operator '!='
153 |             return CellValue(number: ev1 - ev2)
154 |         case "/":
155 |             guard ev2 != .zero else {
    |                       `- error: ambiguous use of operator '!='
156 |                 throw EvaluationError.ImpossibleOperation
157 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Node/OperatorNode.swift:164:23: error: ambiguous use of operator '>='
162 |             return CellValue(number: ev1 ** ev2)
163 |         case "!":
164 |             guard ev1 >= .zero else { throw EvaluationError.ImpossibleOperation }
    |                       `- error: ambiguous use of operator '>='
165 |             let i = ev1.rounded()
166 |             if BN(i) == ev1 {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:87:21: error: ambiguous use of operator '!='
 85 |         var i = 0;
 86 |         for coef in self.coefs {
 87 |             if coef != 0 {
    |                     `- error: ambiguous use of operator '!='
 88 |                 return power(at: i)
 89 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:218:24: error: ambiguous use of operator '!='
216 |             if i == first_idx {
217 |                 let val = self.coefs[i]
218 |                 if val != 1 {
    |                        `- error: ambiguous use of operator '!='
219 |                     do_normalize = true
220 |                     norm_const = val
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:321:25: error: ambiguous use of operator '>='
319 |
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
    |                         `- error: ambiguous use of operator '>='
322 |             if delta == 0 {
323 |                 return [(-b) / (2*a)]
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:358:24: note: found this candidate
356 |     public static func <=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) <= rhs }
357 |
358 |     public static func >=(lhs: BigDouble, rhs: BigDouble) -> Bool { return !(lhs < rhs) }
    |                        `- note: found this candidate
359 |     public static func >=(lhs: BigDouble, rhs: Double) -> Bool { return lhs >= BigDouble(rhs) }
    |                        `- note: found this candidate
360 |     public static func >=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) >= rhs }
361 | }
/host/spi-builder-workspace/Sources/Euler/Algebra/Polynomial.swift:322:22: error: ambiguous use of operator '=='
320 |             let delta = b * b - 4 * a * c
321 |             guard delta >= 0 else { return [] }
322 |             if delta == 0 {
    |                      `- error: ambiguous use of operator '=='
323 |                 return [(-b) / (2*a)]
324 |             }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:47:13: error: ambiguous use of operator '>'
 45 |     diff.sign = false
 46 |
 47 |     if diff > 0 && base.sign == true {
    |             `- error: ambiguous use of operator '>'
 48 |         return div - 1
 49 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BasicOperators.swift:64:13: error: ambiguous use of operator '>'
 62 |
 63 |     div.sign = base.sign
 64 |     if diff > 0 {
    |             `- error: ambiguous use of operator '>'
 65 |         return div + 1
 66 |     }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:350:24: note: found this candidate
348 |     public static func <(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) < rhs }
349 |
350 |     public static func >(lhs: BigDouble, rhs: BigDouble) -> Bool { return rhs < lhs }
    |                        `- note: found this candidate
351 |     public static func >(lhs: BigDouble, rhs: Double) -> Bool { return lhs > BigDouble(rhs) }
    |                        `- note: found this candidate
352 |     public static func >(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) > rhs }
353 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:306:17: error: ambiguous use of operator '=='
304 |      */
305 |     public var scientificDescription: String {
306 |         if self == .zero {
    |                 `- error: ambiguous use of operator '=='
307 |             return "0.\(String(repeating: "0", count: self.precision))×10⁰"
308 |         }
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:318:24: note: found this candidate
316 |         return BigDouble.nearlyEqual(self, rhs, epsilon: epsilon)
317 |     }
318 |     public static func ==(lhs: BigDouble, rhs: BigDouble) -> Bool {
    |                        `- note: found this candidate
319 |         if lhs.sign != rhs.sign { return false }
320 |         if lhs.numerator != rhs.numerator { return false }
    :
323 |         return true
324 |     }
325 |     public static func ==(lhs: BigDouble, rhs: Double) -> Bool { return lhs == BigDouble(rhs) }
    |                        `- note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:324:33: warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
322 |             return self.decimalDescription
323 |         } else {
324 |             guard let index = d.index(of: ".") else {
    |                                 |- warning: 'index(of:)' is deprecated: renamed to 'firstIndex(of:)' [#DeprecatedDeclaration]
    |                                 `- note: use 'firstIndex(of:)' instead
325 |                 let rounded = self.rounded()
326 |                 return rounded.scientificDescription
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/BigDouble.swift:328:27: warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
326 |                 return rounded.scientificDescription
327 |             }
328 |             power = index.encodedOffset - 1
    |                           `- warning: 'encodedOffset' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use utf16Offset(in:) to achieve the same behavior. [#DeprecatedDeclaration]
329 |         }
330 |         d = d.replacingOccurrences(of: ".", with: "")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[55/75] Compiling Euler Collatz.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[56/75] Compiling Euler Fibonacci.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[57/75] Compiling Euler Sieve.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[58/75] Compiling Euler Graph.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[59/75] Compiling Euler Point.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[60/75] Compiling Euler Vector.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[61/75] Compiling Euler MOperations.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[62/75] Compiling Euler MProperties.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[63/75] Compiling Euler Matrix.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[64/75] Compiling Euler Constants.swift
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:53:24: error: cannot find type 'Matrix' in scope
51 |     #if !os(Linux)
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
   |                        `- error: cannot find type 'Matrix' in scope
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
55 |     }
/host/spi-builder-workspace/Sources/Euler/Geometry/Vector.swift:54:16: error: cannot find 'Matrix' in scope
52 |     /// Converts a Vector into a Matrix
53 |     public var matrix: Matrix {
54 |         return Matrix(self.dims.map { $0.asDouble() ?? Double.infinity }, isColumnVector: true)
   |                `- error: cannot find 'Matrix' in scope
55 |     }
56 |     #endif
[65/75] Compiling Euler Expression.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[66/75] Compiling Euler ExpressionSolver.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[67/75] Compiling Euler Grouper.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[68/75] Compiling Euler LaTeX.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[69/75] Compiling Euler Lexer.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[70/75] Compiling Euler CellAddressNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[71/75] Compiling Euler ConstantNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[72/75] Compiling Euler ExpressionNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[73/75] Compiling Euler FunctionNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[74/75] Compiling Euler Node.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[75/75] Compiling Euler NullNode.swift
/host/spi-builder-workspace/Sources/Euler/Algebra/Expression/ExpressionSolver.swift:75:18: error: ambiguous use of operator '!='
 73 |         }
 74 |
 75 |         while fb != 0 && abs(b - a) > precision {
    |                  `- error: ambiguous use of operator '!='
 76 |             var s = BigDouble.zero
 77 |             if fa != fc && fb != fc {
/host/spi-builder-workspace/Sources/Euler/BigNumber/BigDouble/OperationsBigDouble.swift:328:24: note: found this candidate
326 |     public static func ==(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) == rhs }
327 |
328 |     public static func !=(lhs: BigDouble, rhs: BigDouble) -> Bool
    |                        `- note: found this candidate
329 |     {
330 |         return !(lhs == rhs)
331 |     }
332 |     public static func !=(lhs: BigDouble, rhs: Double) -> Bool { return lhs != BigDouble(rhs) }
    |                        `- note: found this candidate
333 |     public static func !=(lhs: Double, rhs: BigDouble) -> Bool { return BigDouble(lhs) != rhs }
334 |
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:69:38: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 67 |         let ps = i.matches(regex: "\\(\\)")
 68 |         for (lower, _) in ps {
 69 |             i.insert("0", at: String.Index(encodedOffset: lower + 1))
    |                                      `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 70 |         }
 71 |         return i
/host/spi-builder-workspace/Sources/Euler/Algebra/Parser/Lexer.swift:87:45: warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 85 |                         tokens.append(t)
 86 |                     }
 87 |                     let firstIndex = String.Index(encodedOffset: m.count - 1)
    |                                             `- warning: 'init(encodedOffset:)' is deprecated: encodedOffset has been deprecated as most common usage is incorrect. Use String.Index(utf16Offset:in:) to achieve the same behavior. [#DeprecatedDeclaration]
 88 |                     let index = content.index(after: firstIndex)
 89 |                     content = String(content[index...])
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[76/85] Compiling Euler LogicalLinker.swift
[77/85] Compiling Euler StatsLinker.swift
[78/85] Compiling Euler Tables.swift
[79/85] Compiling Euler TablesDataSource.swift
[80/85] Compiling Euler TablesDelegate.swift
[81/85] Compiling Euler KnuthDSupport.swift
[82/85] Compiling Euler Pointers.swift
[83/85] Compiling Euler Substring.swift
[84/85] Compiling Euler UnsafeMemory.swift
[85/85] Compiling Euler UnsafeMutableMemory.swift
BUILD FAILURE 6.3 wasm