Calculated timing function for manual interpolation

TimingFunction.swift

import QuartzCore

struct TimingFunction {
    private let function: (Double) -> Double
    
    init(_ function: @escaping (Double) -> Double) {
        self.function = function
    }
}

extension TimingFunction {
    func apply(to value: Double) -> Double {
        function(value)
    }
    
    func apply(to value: Double, in range: ClosedRange<Double>) -> Double {
        range.lowerBound + function((value - range.lowerBound) / (range.upperBound - range.lowerBound))
    }
}

extension TimingFunction {
    func reversed() -> Self {
        Self { 1 - (function(1 - $0)) }
    }
    static func powered(_ power: Double) -> Self {
        Self { pow($0, power) }
    }
}

extension TimingFunction {
    static let linear = Self { $0 }
    static let quadIn = Self.powered(2)
    static let quadOut = quadIn.reversed()
    static let cubicIn = Self.powered(3)
    static let cubicOut = cubicIn.reversed()
    static let quartIn = Self.powered(4)
    static let quartOut = quartIn.reversed()
    static let quintIn = Self.powered(5)
    static let quintOut = quintIn.reversed()
}