SPB Git

Repository Public MIT

MathLogicTests.swift 22.2 KB 502 lines swift

1// ORIX Calc2// File: Packages/ORIXFeatureMath/Tests/ORIXFeatureMathTests/MathLogicTests.swift3// Description: Tests of the Math tools against independently known answers, result-kind mapping, the angle-mode override, persistence and the keypad editing logic.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import Foundation8import SwiftUI9import Testing10import ORIXExpression11import ORIXNumerics12import ORIXSymbolic13import ORIXUI14@testable import ORIXFeatureMath1516private func close(_ a: Double?, _ b: Double, _ tol: Double = 1e-9) -> Bool { a.map { abs($0 - b) <= tol * max(1, abs(b)) } ?? false }1718/// Evaluates parseable text at x (radians).19private func value(_ ascii: String, x: Double) -> Double? {20    guard let e = try? Parser.parse(ascii) else { return nil }21    var c = EvalContext()22    c.variables["x"] = Value(x)23    return (try? Evaluator(context: c).evaluate(e))?.doubleValue24}2526@MainActor private func makeApp() -> AppModel {27    AppModel(settings: AppSettings(defaults: UserDefaults(suiteName: "orix.math.tests.\(UUID().uuidString)")!), inMemory: true)28}2930@Suite struct ToolAnswerTests {31    let env = MathEnv()3233    @Test func solveQuadratic() {34        let o = SolveProblem.demo.compute(env)35        #expect(o.kind == .exact)36        #expect(o.sections.first?.items.map(\.text) == ["2", "3"])37        #expect(o.main?.text == "x ∈ {2, 3}")38        #expect(o.verification.isVerified)39        #expect(o.graph?.expressions.count == 2)40    }4142    @Test func solveListsExtraneousAndComplexRoots() {43        var p = SolveProblem(); p.equation = "sqrt(x+1) = x - 1"44        let o = p.compute(env)45        #expect(o.sections.contains { $0.items.contains { $0.isRejected } })46        #expect(o.sections.first?.items.map(\.text) == ["3"])47        p.equation = "x^2 + 1 = 0"48        let c = p.compute(env)49        #expect(c.sections.first?.items.count == 2)50        #expect(c.sections.first?.items.allSatisfy { $0.detail.contains("complex") } == true)51        p.equation = "(x-1)^2 = 0"52        #expect(p.compute(env).sections.first?.items.first?.detail.contains("multiplicity 2") == true)53    }5455    @Test func solveNumericalIsLabelledNumerical() {56        var p = SolveProblem(); p.equation = "cos(x) = x"; p.useInterval = true; p.lower = "0"; p.upper = "2"57        let o = p.compute(env)58        #expect(o.kind == .numerical)59        #expect(close(o.sections.first?.items.first?.value, 0.7390851332151607, 1e-8))60        #expect(o.main?.text.contains("≈") == true)61    }6263    @Test func derivativeOfProduct() throws {64        let o = DerivativeProblem.demo.compute(env)65        #expect(o.kind == .symbolic)66        let ascii = try #require(o.main?.ascii)67        for x in [0.3, 1.3, -2.1] { #expect(close(value(ascii, x: x), 2 * x * sin(x) + x * x * cos(x), 1e-12)) }68        #expect(!o.explanation.steps.isEmpty)69        #expect(o.main?.latex.isEmpty == false)70    }7172    @Test func derivativeOrderPointPartialsAndGradient() {73        var p = DerivativeProblem(); p.expression = "x^5"; p.order = 3; p.point = "2"74        let o = p.compute(env)75        #expect(o.main?.text == "60x²")76        #expect(o.sections.first?.items.first?.text == "240")77        var q = DerivativeProblem(); q.expression = "x^2*y^3"; q.mixed = "x, y"78        let m = q.compute(env)79        #expect(m.sections.first { $0.title == "Partial derivatives" }?.items.count == 2)80        #expect(m.sections.contains { $0.title == "Gradient" })81        #expect(m.sections.first { $0.title == "Mixed partial derivative" }?.items.first?.text.replacingOccurrences(of: " ", with: "") == "6x·y²")82    }8384    @Test func indefiniteIntegralIsVerifiedByDifferentiation() throws {85        let o = IntegralProblem.demo.compute(env)86        #expect(o.kind == .symbolic)87        #expect(o.main?.text.hasSuffix("+ C") == true)88        #expect(o.verification.isVerified)89        let ascii = try #require(o.main?.ascii)90        // Independent check: central difference of the antiderivative equals x·eˣ.91        for x in [0.5, 1.7] {92            let h = 1e-593            let d = (value(ascii, x: x + h)! - value(ascii, x: x - h)!) / (2 * h)94            #expect(close(d, x * exp(x), 1e-7))95        }96    }9798    @Test func gaussianIntegralIsNumericalNotExact() {99        var p = IntegralProblem(); p.integrand = "e^(-x^2)"; p.definite = true; p.lower = "0"; p.upper = "inf"100        let o = p.compute(env)101        #expect(o.kind == .numerical)102        #expect(close(o.main?.value, Double.pi.squareRoot() / 2, 1e-8))103        #expect(o.main?.text.hasPrefix("≈") == true)104        #expect(!o.accuracy.isEmpty)105        #expect(!o.isExact)106    }107108    @Test func definiteIntegralExactAndSingular() {109        var p = IntegralProblem(); p.integrand = "sin(x)"; p.definite = true; p.lower = "0"; p.upper = "pi"110        #expect(p.compute(env).main?.text == "2")111        p.integrand = "1/x"; p.lower = "-1"; p.upper = "1"112        let s = p.compute(env)113        #expect(s.kind == .unsupported)114        #expect(s.main == nil)115        #expect(!s.note.isEmpty)116    }117118    @Test func unsupportedIntegralShowsNoClosedForm() {119        var p = IntegralProblem(); p.integrand = "x^x"120        let o = p.compute(env)121        #expect(o.kind == .unsupported)122        #expect(o.main == nil, "no fake closed form")123        #expect(o.sections.isEmpty)124        #expect(!o.note.isEmpty)125        #expect(!o.needsRadians)126    }127128    @Test func limits() {129        let o = LimitProblem.demo.compute(env)130        #expect(o.kind == .exact)131        #expect(o.main?.text == "1")132        var p = LimitProblem(); p.expression = "1/x"133        let none = p.compute(env)134        #expect(none.main?.text == "does not exist")135        #expect(none.sections.first?.items.map(\.text) == ["−∞", "∞"])136        p.direction = "right"137        #expect(p.compute(env).main?.text == "∞")138        p.expression = "(1+1/x)^x"; p.point = "inf"; p.direction = "both"139        #expect(p.compute(env).main?.text == "e")140    }141142    @Test func maclaurinOfSine() {143        let o = SeriesProblem.demo.compute(env)144        #expect(o.kind == .exact || o.kind == .symbolic)145        #expect(o.main?.text == "x − x³/6 + x⁵/120 + O(x⁶)")146        #expect(o.sections.first?.items.count == 6)147        #expect(o.sections.first?.items[3].text == "−1/6")148        #expect(o.graph?.expressions.count == 2)149    }150151    @Test func finiteSumClosedForm() throws {152        var p = SeriesProblem.demo; p.mode = "sum"153        let o = p.compute(env)154        let ascii = try #require(o.main?.ascii)155        var c = EvalContext(); c.variables["n"] = Value(10)156        let v = try Evaluator(context: c).evaluate(Parser.parse(ascii)).doubleValue157        #expect(v == 385)158        p.term = "1/k"; p.to = "4"159        #expect(p.compute(env).main?.text == "25/12")160    }161162    @Test func factorCubic() {163        let o = SimplifyProblem.demo.compute(env)164        #expect(o.kind == .symbolic || o.kind == .exact)165        let text = o.main?.text ?? ""166        for f in ["(x − 1)", "(x − 2)", "(x − 3)"] { #expect(text.contains(f)) }167        let factors = o.sections.first { $0.title == "Factors" }168        #expect(factors?.items.count == 3)169        #expect(factors?.items.allSatisfy { $0.detail.contains("proven irreducible") } == true)170    }171172    @Test func simplifyExpandAndAssumePositive() {173        var p = SimplifyProblem(); p.expression = "sqrt(x^2)"174        #expect(p.compute(env).main?.text == "|x|")175        p.assumePositive = true176        #expect(p.compute(env).main?.text == "x")177        p = SimplifyProblem(); p.mode = "expand"; p.expression = "(x+1)^3"178        #expect(p.compute(env).main?.text == "x³ + 3x² + 3x + 1")179    }180181    @Test func polynomialTools() {182        var p = SimplifyProblem.demo; p.mode = "polynomial"183        let o = p.compute(env)184        let division = o.sections.first { $0.title.hasPrefix("Division") }185        #expect(division?.items.map(\.text) == ["x − 3", "0"])186        #expect(o.sections.first { $0.title.hasPrefix("Greatest") }?.items.first?.text == "x² − 3x + 2")187        #expect(o.sections.first { $0.title == "Roots of p" }?.items.map(\.text) == ["1", "2", "3"])188        p.p = "sin(x)"189        #expect(p.compute(env).kind == .unsupported)190    }191192    @Test func linearSystemThreeByThree() {193        let o = SystemProblem.demo.compute(env)194        #expect(o.kind == .exact)195        #expect(o.sections.first?.items.map { "\($0.label)=\($0.text)" } == ["x=2", "y=3", "z=−1"])196        #expect(o.title.hasPrefix("Unique solution"))197        var p = SystemProblem(); p.equations = ["x + y = 1", "2x + 2y = 2"]198        #expect(p.compute(env).title.hasPrefix("Infinitely many solutions (rank 1"))199        p.equations = ["x + y = 1", "x + y = 2"]200        #expect(p.compute(env).title.hasPrefix("No solution"))201    }202203    @Test func nonlinearSystemIsNumericalWithResiduals() {204        let o = SystemProblem.nonlinearDemo.compute(env)205        #expect(o.kind == .numerical)206        #expect(!o.sections.isEmpty)207        for s in o.sections {208            let x = s.items[0].value!, y = s.items[1].value!209            #expect(abs(x * x + y * y - 4) < 1e-8 && abs(x * y - 1) < 1e-8)210            #expect(s.footnote.contains("residual"))211        }212    }213214    @Test func optimizeOnInterval() {215        let o = OptimizeProblem.demo.compute(env)216        #expect(o.kind == .exact)217        let global = o.sections.first { $0.title == "Global extrema" }218        #expect(close(global?.items[0].value, -18) && close(global?.items[1].value, 18))219        let critical = o.sections.first { $0.title.hasPrefix("Critical") }220        #expect(critical?.items.map(\.label) == ["Local maximum", "Local minimum"])221        #expect(o.sections.contains { $0.title == "Endpoints" })222    }223224    @Test func rosenbrockMinimum() {225        let o = OptimizeProblem.multiDemo.compute(env)226        #expect(o.kind == .numerical)227        let point = o.sections.first { $0.title == "Point" }228        #expect(close(point?.items[0].value, 1, 1e-4) && close(point?.items[1].value, 1, 1e-4))229        #expect(o.accuracy.contains("gradient norm"))230    }231232    @Test func exponentialDecayMatchesClosedForm() {233        let o = ODEProblem.demo.compute(env)234        #expect(o.kind == .numerical)235        #expect(close(o.main?.value, exp(-6), 1e-6))236        #expect(o.table?.rows.count == 11)237        #expect(o.trajectory?.times.first == 0 && o.trajectory?.times.last == 3)238        #expect(o.sections.contains { $0.title == "Step statistics" })239        #expect(!o.verification.isEmpty)240        var rk4 = ODEProblem.demo; rk4.method = "rk4"; rk4.steps = 1000241        #expect(close(rk4.compute(env).main?.value, exp(-6), 1e-8))242    }243244    @Test func secondOrderOscillatorAndBlowUp() {245        let o = ODEProblem.oscillatorDemo.compute(env)246        #expect(close(o.main?.value, cos(10), 1e-5))247        #expect(o.trajectory?.states == ["y", "v"])248        var p = ODEProblem(); p.states = [.init(name: "y", rhs: "y^2", initial: "1")]; p.end = "2"249        let blow = p.compute(env)250        #expect(blow.kind == .failedConvergence)251        #expect(!blow.note.isEmpty)252        #expect(blow.main == nil)253    }254255    @Test func rationalMatrixStaysExact() {256        var p = MatrixProblem.demo257        let inverse = p.compute(env)258        #expect(inverse.kind == .exact)259        #expect(inverse.main?.text == "[6, −2; −2, 1]")260        p.operation = .det261        let det = p.compute(env)262        #expect(det.kind == .exact && det.main?.text == "1/2" && det.main?.decimal == "0.5")263        p.operation = .solve264        #expect(p.compute(env).main?.ascii == "[2, 0]")265        p.operation = .mul266        #expect(p.compute(env).main?.text == "[2, 1; 5, 3]")267        p.operation = .pow; p.power = 2268        #expect(p.compute(env).main?.text == "[5/4, 7/2; 7/2, 10]")269        p.operation = .rank270        #expect(p.compute(env).main?.text == "2")271    }272273    @Test func eigenvaluesAreNumericalAndComplexWhenNeeded() {274        var p = MatrixProblem(); p.a = MatrixGrid([["0", "-1"], ["1", "0"]]); p.operation = .eig275        let o = p.compute(env)276        #expect(o.kind == .numerical)277        #expect(o.sections.first?.items.count == 2)278        #expect(o.sections.first?.items.allSatisfy { $0.detail == "complex" } == true)279        #expect(!o.verification.isEmpty, "trace check")280        p.a = MatrixGrid([["1", "2"], ["2", "4"]]); p.operation = .inv281        let singular = p.compute(env)282        #expect(singular.kind == nil && singular.inputError.contains("singular"))283    }284285    @Test func inputErrorsCarryTheParserMessage() {286        var p = SolveProblem(); p.equation = "x^2 +"287        let o = p.compute(env)288        #expect(o.kind == nil && o.inputError.hasPrefix("Equation:"))289        #expect(p.preview(env).errors.count == 1)290        p.equation = "xy = 6"291        #expect(mathVariables([try! env.parse(p.equation)]) == ["x", "y"], "xy reads as x·y")292    }293}294295@Suite struct AngleModeTests {296    @Test func degreeModeIsRefusedAndTheLocalOverrideWorks() {297        var env = MathEnv()298        env.angleMode = .degrees299        let refused = DerivativeProblem.demo.compute(env)300        #expect(refused.kind == .unsupported)301        #expect(refused.needsRadians)302        #expect(refused.note.contains("radians"))303        #expect(refused.main == nil)304        // No trigonometry: every mode works.305        var p = DerivativeProblem(); p.expression = "x^3"306        #expect(p.compute(env).kind == .symbolic)307    }308309    @MainActor @Test func overrideIsLocalToTheTool() {310        let app = makeApp()311        app.settings.data.angleMode = .degrees312        app.applySettings()313        let store = MathStore()314        store.derivative.loadDemo()315        #expect(store.derivative.mentionsTrig)316        #expect(store.derivative.calculateNow(env: store.env(app, for: .derivative)).needsRadians)317        store.derivative.radians = true318        let o = store.derivative.calculateNow(env: store.env(app, for: .derivative))319        #expect(o.kind == .symbolic)320        #expect(app.engine.context.angleMode == .degrees, "the global setting is untouched")321        #expect(app.settings.data.angleMode == .degrees)322        #expect(store.env(app, for: .integral).angleMode == .degrees, "other tools keep the user's mode")323    }324}325326@MainActor @Suite struct StoreTests {327    @Test func demoComputesEveryTool() {328        let app = makeApp()329        app.settings.data.angleMode = .radians330        app.applySettings()331        let store = MathStore()332        let started = Date()333        store.loadDemo { store.env(app, for: $0) }334        let elapsed = Date().timeIntervalSince(started)335        print("ORIX Math demo computed in \(elapsed) s")336        #expect(elapsed < 2, "the demo is computed synchronously at launch and must stay quick")337        for tool in MathTool.allCases {338            let o = store.model(tool).outcome339            #expect(o?.kind == .exact || o?.kind == .symbolic || o?.kind == .numerical, "\(tool.rawValue)")340            #expect(store.model(tool).isStale == false)341        }342    }343344    @Test func snapshotRoundTrip() throws {345        let store = MathStore()346        store.tool = .limit347        store.substituteVariables = true348        store.limit.problem.expression = "tan(x)/x"349        store.matrix.problem = .demo350        store.system.problem = .nonlinearDemo351        store.solve.problem = .demo352        store.solve.calculateNow(env: MathEnv())353        let data = try JSONEncoder().encode(store.snapshot)354        let restored = MathStore()355        restored.restore(try #require(MathSnapshot.decode(data)))356        #expect(restored.tool == .limit && restored.substituteVariables)357        #expect(restored.limit.problem == store.limit.problem)358        #expect(restored.matrix.problem == MatrixProblem.demo)359        #expect(restored.system.problem == SystemProblem.nonlinearDemo)360        #expect(restored.solve.recentSummaries == store.solve.recentSummaries)361        #expect(restored.snapshot == store.snapshot)362    }363364    @Test func damagedDataFallsBackToDefaults() throws {365        #expect(MathSnapshot.decode(Data("not json".utf8)) == nil)366        #expect(MathSnapshot.decode(Data()) == nil)367        var s = MathStore().snapshot368        s.tool = "nonsense"369        s.problems["solve"] = Data("{broken".utf8)370        s.problems["derivative"] = try JSONEncoder().encode(["expression": "x"])       // missing keys371        var wild = DerivativeProblem(); wild.order = 9999372        s.problems["derivative"] = try JSONEncoder().encode(wild)373        var grid = MatrixProblem(); grid.a = MatrixGrid([["1", "2", "3"], ["4"]]); grid.vector = []374        s.problems["matrix"] = try JSONEncoder().encode(grid)375        var keep = IntegralProblem(); keep.integrand = "x^2"376        s.problems["integral"] = try JSONEncoder().encode(keep)377        s.recents["limit"] = Data([0xFF, 0x00])378        let store = MathStore()379        store.restore(s)380        #expect(store.tool == .solve)381        #expect(store.solve.problem == SolveProblem())382        #expect(store.derivative.problem.order == DerivativeProblem.maxOrder)383        #expect(store.matrix.problem.a.cells == [["1", "2", "3"], ["4", "", ""]])384        #expect(store.matrix.problem.vector.count == 2)385        #expect(store.integral.problem.integrand == "x^2", "one damaged tool does not lose the others")386        #expect(store.limit.recentSummaries.isEmpty)387    }388389    @Test func stateSurvivesTheAppStore() throws {390        let app = makeApp()391        let store = MathStore()392        store.tool = .series393        store.series.problem.expression = "cos(x)"394        app.saveState(store.snapshot, key: MathStore.stateKey)395        let loaded = try #require(app.loadState(MathSnapshot.self, key: MathStore.stateKey))396        let second = MathStore()397        second.restore(loaded)398        #expect(second.tool == .series && second.series.problem.expression == "cos(x)")399    }400401    @Test func calculateRunsOffTheMainActorAndLogsToTheSharedHistory() async throws {402        let app = makeApp()403        let store = MathStore()404        store.solve.problem = .demo405        store.calculate(app)406        #expect(store.solve.isRunning)407        for _ in 0..<400 where store.solve.isRunning { try await Task.sleep(for: .milliseconds(10)) }408        #expect(store.solve.outcome?.kind == .exact)409        let entry = try #require(app.history.first)410        #expect(entry.mode == .math && entry.display == "x ∈ {2, 3}" && entry.isExact && entry.status == "verified")411        #expect(entry.input.contains("x² − 5x + 6"))412        // An input error is shown but never logged.413        store.solve.problem.equation = "x +* 2"414        store.calculate(app)415        for _ in 0..<400 where store.solve.isRunning { try await Task.sleep(for: .milliseconds(10)) }416        #expect(store.solve.outcome?.kind == nil && app.history.count == 1)417    }418419    @Test func latestCalculationWinsAndCancelDiscards() async throws {420        let model = ToolModel<SolveProblem>()421        model.problem.equation = "x - 1 = 0"422        model.calculate(env: MathEnv())423        model.problem.equation = "x - 2 = 0"424        model.calculate(env: MathEnv())425        for _ in 0..<400 where model.isRunning { try await Task.sleep(for: .milliseconds(10)) }426        #expect(model.outcome?.main?.text == "x = 2")427        #expect(model.recentSummaries.count == 1)428        model.problem.equation = "x - 3 = 0"429        model.calculate(env: MathEnv())430        model.cancel()431        #expect(!model.isRunning)432        try await Task.sleep(for: .milliseconds(300))433        #expect(model.outcome?.main?.text == "x = 2", "a cancelled job never replaces the result")434        #expect(model.isStale)435    }436437    @Test func storedVariablesAreSymbolsUnlessSubstitutionIsOn() {438        let app = makeApp()439        _ = app.setVariable("a", Value(3))440        _ = app.setVariable("x", Value(5))441        let store = MathStore()442        store.derivative.problem.expression = "a*x^2"443        #expect(store.derivative.calculateNow(env: store.env(app, for: .derivative)).main?.text.replacingOccurrences(of: " ", with: "") == "2a·x")444        store.substituteVariables = true445        #expect(store.derivative.calculateNow(env: store.env(app, for: .derivative)).main?.text == "6x", "x stays the unknown")446    }447}448449@MainActor @Suite struct KeyboardTests {450    @Test func caretEditing() {451        var s = MathEditing.insert("x^2", into: "", caret: 0)452        #expect(s.text == "x^2" && s.caret == 3)453        s = MathEditing.apply("left", to: s.text, caret: s.caret)!454        s = MathEditing.apply("sin", to: s.text, caret: s.caret)!455        #expect(s.text == "x^sin(2" && s.caret == 6)456        s = MathEditing.apply("back", to: s.text, caret: s.caret)!457        #expect(s.text == "x^2" && s.caret == 2, "a function is deleted as one token")458        s = MathEditing.apply("back", to: s.text, caret: s.caret)!459        #expect(s.text == "x2" && s.caret == 1)460        #expect(MathEditing.apply("left", to: "", caret: 0)! == ("", 0))461        #expect(MathEditing.apply("right", to: "ab", caret: 9)! == ("ab", 2))462        #expect(MathEditing.apply("pi", to: "2", caret: 1)!.text == "2π")463        #expect(MathEditing.apply("clear", to: "abc", caret: 1)! == ("", 0))464        #expect(MathEditing.apply("enter", to: "abc", caret: 1) == nil)465    }466467    @Test func everyKeyIsHandledAndIdentified() {468        for second in [false, true] {469            let rows = MathKeys.rows(second: second)470            #expect(rows.count == 6)471            for row in rows {472                #expect(row.reduce(0) { $0 + $1.span } == 7)473                #expect(Set(row.map(\.id)).count == row.count)474                for key in row where !["2nd", "enter", "back", "clear", "left", "right"].contains(key.id) {475                    #expect(MathEditing.insertion(for: key.id) != nil, "\(key.id)")476                    #expect(key.identifier == "math.key." + key.id)477                }478            }479        }480    }481482    @Test func controllerRoutesKeysToTheActiveField() throws {483        let model = ToolModel<SolveProblem>()484        let keyboard = KeyboardController()485        let binding = Binding(get: { model.problem.equation }, set: { model.problem.equation = $0 })486        keyboard.press("x")487        #expect(model.problem.equation.isEmpty, "no field is active")488        keyboard.activate("solve.equation", binding)489        for k in ["x", "^", "2", "-", "4", "=", "0"] { keyboard.press(k) }490        #expect(model.problem.equation == "x^2-4=0")491        #expect(model.problem.compute(MathEnv()).sections.first?.items.map(\.text) == ["−2", "2"])492        var entered = false493        keyboard.onEnter = { entered = true }494        keyboard.press("enter")495        #expect(entered)496        keyboard.press("2nd")497        #expect(keyboard.second)498        keyboard.useSystemKeyboard = true499        #expect(keyboard.activeID == nil)500    }501}502
Files main
Menu

Theme