Something went wrong. Try again.
An auto tiler for macOS
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182import Foundationimport Testing
@testable import ParcelAnimation
@Suite struct SpringTests { let critical = SpringParameters(duration: 0.2, bounce: 0) let bouncy = SpringParameters(duration: 0.25, bounce: 0.3)
@Test func physicalParametersArePreserved() { let spring = SpringParameters(mass: 2, stiffness: 100, damping: 8) #expect(spring.mass == 2) #expect(spring.stiffness == 100) #expect(spring.damping == 8) }
@Test func responseMapsToNaturalFrequency() { let spring = SpringParameters(response: 0.5, dampingFraction: 0.7) #expect(near(spring.stiffness, pow(4 * Double.pi, 2))) #expect(near(spring.dampingFraction, 0.7)) }
@Test func durationBounceMatchesPhysicalForm() { let spring = SpringParameters(duration: 0.5, bounce: 0.3) #expect(near(spring.stiffness, 157.91367041742973)) #expect(near(spring.damping, 17.59291886010284)) #expect(spring.mass == 1) }
@Test func zeroBounceIsCriticallyDamped() { #expect(near(critical.dampingFraction, 1)) }
@Test func zeroStepPreservesValueAndVelocity() { let state = SpringState(value: 42, velocity: -100) #expect(state.advanced(to: 8, by: 0, using: bouncy) == state) }
@Test func equilibriumRemainsStill() { #expect(SpringState(value: 8).advanced(to: 8, by: 0.1, using: critical) == SpringState(value: 8)) }
@Test func criticalSpringConverges() { let result = SpringState(value: 0).advanced(to: 100, by: 2, using: critical) #expect(near(result.value, 100)) #expect(near(result.velocity, 0)) }
@Test func underdampedSpringConverges() { let result = SpringState(value: -50, velocity: 200).advanced(to: 100, by: 2, using: bouncy) #expect(near(result.value, 100)) #expect(near(result.velocity, 0)) }
@Test func overdampedSpringConverges() { let spring = SpringParameters(response: 0.2, dampingFraction: 2) let result = SpringState(value: 0).advanced(to: 100, by: 10, using: spring) #expect(near(result.value, 100)) #expect(near(result.velocity, 0)) }
@Test func bouncySpringCrossesTarget() { let values = (0...100).map { SpringState(value: 0).advanced(to: 1, by: Double($0) / 200, using: bouncy).value } #expect(values.contains { $0 > 1 }) #expect((values.max() ?? 0) < 1.06) }
@Test func criticalSpringIsMonotonicWithoutInitialVelocity() { let values = (0...100).map { SpringState(value: 0).advanced(to: 1, by: Double($0) / 200, using: critical).value } #expect(zip(values, values.dropFirst()).allSatisfy { $0 <= $1 }) #expect(values.allSatisfy { (0...1).contains($0) }) }
@Test func negativeDirectionIsSymmetric() { let positive = SpringState(value: 0).advanced(to: 10, by: 0.1, using: bouncy) let negative = SpringState(value: 0).advanced(to: -10, by: 0.1, using: bouncy) #expect(near(positive.value, -negative.value)) #expect(near(positive.velocity, -negative.velocity)) }
@Test func partitionedStepsMatchSingleStep() { var partitioned = SpringState(value: 3, velocity: -20) for _ in 0..<100 { partitioned.advance(to: 90, by: 0.003, using: bouncy) } let single = SpringState(value: 3, velocity: -20).advanced(to: 90, by: 0.3, using: bouncy) #expect(near(partitioned.value, single.value)) #expect(near(partitioned.velocity, single.velocity)) }
@Test func unevenStepsAreStable() { var state = SpringState(value: 0, velocity: 100) for step in [0.001, 0.05, 0.4, 0.009, 3.0] { state.advance(to: 10, by: step, using: bouncy) } #expect(near(state.value, 10)) #expect(state.velocity.isFinite) }
@Test func largeStepDoesNotExplode() { let state = SpringState(value: 0, velocity: 100).advanced(to: 10, by: 1000, using: bouncy) #expect(state == SpringState(value: 10)) }
@Test func heavyDampingAvoidsOverflow() { let spring = SpringParameters(response: 0.2, dampingFraction: 1_000_000) let state = SpringState(value: 0).advanced(to: 10, by: 1_000_000, using: spring) #expect(state.value.isFinite && state.velocity.isFinite) #expect(state.value > 9.99) }
@Test func nearCriticalDampingIsStable() { let spring = SpringParameters(response: 0.2, dampingFraction: 1 + 1e-12) let state = SpringState(value: 0).advanced(to: 1, by: 0.1, using: spring) let reference = SpringState(value: 0).advanced(to: 1, by: 0.1, using: critical) #expect(near(state.value, reference.value)) #expect(near(state.velocity, reference.velocity)) }
@Test func massScalingPreservesTrajectory() { let spring = SpringParameters(mass: 2, stiffness: bouncy.stiffness * 2, damping: bouncy.damping * 2) let state = SpringState(value: 0, velocity: 10) #expect(state.advanced(to: 20, by: 0.1, using: spring) == state.advanced(to: 20, by: 0.1, using: bouncy)) }
@Test func retargetingKeepsPresentationAndMomentum() { let state = SpringState(value: 0).advanced(to: 100, by: 0.04, using: bouncy) let retargeted = state.advanced(to: -20, by: 0, using: bouncy) #expect(retargeted == state) #expect(retargeted.velocity > 0) }
@Test func retargetingEventuallyChangesDirection() { let state = SpringState(value: 0).advanced(to: 100, by: 0.04, using: bouncy) let retargeted = state.advanced(to: -20, by: 1, using: bouncy) #expect(near(retargeted.value, -20, tolerance: 1e-4)) }
@Test func velocityMatchesPositionDerivative() { let initial = SpringState(value: 0, velocity: 30) let state = initial.advanced(to: 10, by: 0.1, using: bouncy) let before = initial.advanced(to: 10, by: 0.1 - 1e-6, using: bouncy) let after = initial.advanced(to: 10, by: 0.1 + 1e-6, using: bouncy) #expect(near(state.velocity, (after.value - before.value) / 2e-6, tolerance: 1e-6)) }
@Test func undampedSpringIsPeriodic() { let spring = SpringParameters(response: 0.2, dampingFraction: 0) let state = SpringState(value: 0, velocity: 5) let result = state.advanced(to: 10, by: 0.2, using: spring) #expect(near(result.value, state.value)) #expect(near(result.velocity, state.velocity)) }
@Test func movingAtTargetCarriesVelocity() { let result = SpringState(value: 10, velocity: 100).advanced(to: 10, by: 0.01, using: bouncy) #expect(result.value > 10) #expect(result.velocity > 0) }
@Test(arguments: [0.5, 1.0, 2.0]) func largestFiniteStepConvergesWithoutOverflow(_ dampingFraction: Double) { let spring = SpringParameters(response: 0.2, dampingFraction: dampingFraction) let result = SpringState(value: 1, velocity: 3).advanced(to: 10, by: .greatestFiniteMagnitude, using: spring) #expect(result == SpringState(value: 10)) }
@Test func largestFiniteUndampedStepKeepsFiniteEnergy() { let spring = SpringParameters(response: 0.2, dampingFraction: 0) let initial = SpringState(value: 1, velocity: 3) let result = initial.advanced(to: 0, by: .greatestFiniteMagnitude, using: spring) #expect(result.value.isFinite && result.velocity.isFinite) let initialEnergy = pow(initial.velocity, 2) + spring.stiffness * pow(initial.value, 2) let finalEnergy = pow(result.velocity, 2) + spring.stiffness * pow(result.value, 2) #expect(near(initialEnergy, finalEnergy, tolerance: 1e-8)) }
@Test func dampingDissipatesEnergy() { let initial = SpringState(value: 0, velocity: 100) let after = initial.advanced(to: 10, by: 0.1, using: bouncy) let initialEnergy = bouncy.mass * pow(initial.velocity, 2) + bouncy.stiffness * pow(initial.value - 10, 2) let finalEnergy = bouncy.mass * pow(after.velocity, 2) + bouncy.stiffness * pow(after.value - 10, 2) #expect(finalEnergy < initialEnergy) }}