Written by models,
read in your language.

// … 5 lines of generated header and runtime shim elided …

class Span {
    low!: number;
    high!: number;
    toString(): string {
        return "Span { low = " + display.value(this.low, "fractus", { true_: "true", false_: "false", none: "none" }) + ", high = " + display.value(this.high, "fractus", { true_: "true", false_: "false", none: "none" }) + " }";
    }
    contains(p_x: number): boolean {
        return (this.low <= p_x) && (p_x <= this.high);
    }
    center(): number {
        return ((this.low + this.high) / 2);
    }
}

// Code generated by faber. DO NOT EDIT.

package main

type Span struct {
    Low float64
    High float64
}

func (self *Span) Contains(p_x float64) bool {
    return ((float64(self.Low) <= float64(p_x)) && (float64(p_x) <= float64(self.High)))
}

func (self *Span) Center() float64 {
    return float64(((self.Low + self.High) / 2.0))
}

// Generated by radix - do not edit

func faberFractusPlain(_ description: String) -> String {
    var text = Substring(description)
    var sign = ""
    if text.hasPrefix("-") {
        sign = "-"
        text = text.dropFirst()
    }
    var exponent = 0
    if let marker = text.firstIndex(where: { $0 == "e" || $0 == "E" }) {
        exponent = Int(text[text.index(after: marker)...]) ?? 0
        text = text[..<marker]
    }
    var whole = Substring(text)
    var fraction = Substring("")
    if let dot = text.firstIndex(of: ".") {
        whole = text[..<dot]
        fraction = text[text.index(after: dot)...]
    }
    let digits = Array(String(whole) + String(fraction))
    let point = whole.count + exponent
    var shown: String
    if point <= 0 {
        shown = "0." + String(repeating: "0", count: -point) + String(digits)
    } else if point >= digits.count {
        shown = String(digits) + String(repeating: "0", count: point - digits.count) + ".0"
    } else {
        shown = String(digits[..<point]) + "." + String(digits[point...])
    }
    return sign + shown
}

func faberFractus64(_ value: Double) -> String {
    if value.isNaN { return "NaN" }
    if value.isInfinite { return value < 0 ? "-inf" : "inf" }
    if value.rounded(.towardZero) == value {
        let sign = value.sign == .minus ? "-" : ""
        let magnitude = value.magnitude
        if magnitude < 9.0e18 { return sign + String(UInt64(magnitude)) + ".0" }
        var digits = Array(String(magnitude.significandBitPattern | (UInt64(1) << 52)).utf8.reversed().map { $0 - 48 })
        for _ in 0..<(Int(magnitude.exponent) - 52) {
            var carry: UInt8 = 0
            for index in 0..<digits.count {
                let doubled = digits[index] * 2 + carry
                digits[index] = doubled % 10
                carry = doubled / 10
            }
            if carry > 0 { digits.append(carry) }
        }
        return sign + String(decoding: digits.reversed().map { $0 + 48 }, as: UTF8.self) + ".0"
    }
    return faberFractusPlain(value.description)
}

func faberFractus32(_ value: Float) -> String {
    if value.isNaN { return "NaN" }
    if value.isInfinite { return value < 0 ? "-inf" : "inf" }
    return faberFractusPlain(value.description)
}

class Span {
    var low: Double
    var high: Double

    init(low p_low: Double, high p_high: Double) {
        self.low = p_low
        self.high = p_high
    }

    func contains(x p_x: Double) -> Bool {
        return ((self.low <= p_x) && (p_x <= self.high))
    }

    func center() -> Double {
        return ((self.low + self.high) / 2.0)
    }
}

extension Span: CustomStringConvertible {
    var description: String { return "Span { low = \(faberFractus64(self.low)), high = \(faberFractus64(self.high)) }" }
}