MarfSmokeTest.kt

    @JvmStatic
    fun main(args: Array<String>) {
        val failures = mutableListOf<String>()

        println("── one bank, two readers ───────────────────────────────────────────────")
        val shared = bank()
        val a = shared.read(pat("<0 1 2 1 3 4>").nums(), name = "A")
        val b = shared.read(pat("<0 2 4 1 3>").nums().slow(3), name = "B")
        val plainA = render(a)
        val plainB = render(b)
        print(plainA)
        print(plainB)

        println()
        println("── the same bank, one reader's address reversed every fourth cycle ─────")
        val flipped = shared.read(pat("<0 1 2 1 3 4>").nums().every(4) { it.rev() }, name = "A'")
        val flippedB = shared.read(pat("<0 2 4 1 3>").nums().slow(3), name = "B")
        print(render(flipped))
        print(render(flippedB))

        // `<…>` holds one event per cycle, so rev() inside a cycle is a no-op — a Tidal fact, and
        // the reason the interesting reversal below uses an address with steps inside the cycle.
        if (render(flippedB) != plainB) failures += "transforming A's address changed B"
        if (shared.stages.map { it.label } != listOf("a", "b", "c", "d", "e")) {
            failures += "the bank was mutated by being read"
        }

        println()
        println("── four stages a cycle, so rev() has something to reverse ──────────────")
        val quarters = constant(0.25)
        val stepped = shared.read(pat("0 1 2 3").nums(), duration = quarters, name = "C")
        val reversed = shared.read(
            pat("0 1 2 3").nums().every(4) { it.rev() },
            duration = quarters,
            name = "C'"
        )
        print(render(stepped))
        print(render(reversed))
        if (render(stepped) == render(reversed)) failures += "every(4) { rev() } changed nothing"
        val firstCycle = (0..3).map { reversed.at(it * 0.25 + 0.05).address }
        if (firstCycle != listOf(3.0, 2.0, 1.0, 0.0)) failures += "cycle 0 not reversed: $firstCycle"
        val secondCycle = (4..7).map { reversed.at(it * 0.25 + 0.05).address }
        if (secondCycle != listOf(0.0, 1.0, 2.0, 3.0)) failures += "cycle 1 was touched: $secondCycle"

        println()
        println("── a continuous address glides through the bank ────────────────────────")
        // A periodic address is latched once per stage, so it is only ever a *sequence* of
        // lcm(address period, stage period) / stage period steps. Eight cycles of saw against
        // quarter-cycle stages is 32 of them, which reads as a glide; one cycle of sine against the
        // same stages is four, which reads as a four-step sequencer. See the note in `Marf.kt`.
        val glide = shared.read(saw().slow(8).range(0.0, 4.0), duration = quarters, name = "~")
        print(render(glide))
        val addresses = (0 until 32).map { glide.at(it * 0.25 + 0.05).address }
        if (addresses.count { it % 1.0 > 1e-4 } < 20) {
            failures += "a continuous address mostly landed on whole slots: $addresses"
        }
        if (addresses.zipWithNext().any { (p, q) -> q <= p }) {
            failures += "a rising address did not rise monotonically: $addresses"
        }

        val aliased = shared.read(sine().range(0.0, 4.0), duration = quarters, name = "aliased")
        val aliasedAddresses = (0 until 32).map { aliased.at(it * 0.25 + 0.05).address }
        // Count distinct addresses to 3dp, not as raw doubles: an aliased address repeats to
        // within a few parts in 10^4 rather than bit-exactly, because the probe instant is
        // rationally exact but `PatQ.toDouble()` rounds it at 12 places. Raw `distinct()` reports
        // 17 "different" addresses for a sequence that visibly cycles through four.
        fun coarse(xs: List<Double>) = xs.map { "%.3f".format(it) }.distinct().size
        println("  saw slowed 8x:  ${coarse(addresses)} distinct addresses over 32 stages")
        println("  plain sine:     ${coarse(aliasedAddresses)} distinct addresses over 32 stages")
        println("  plain sine, first eight: " + aliasedAddresses.take(8).joinToString(" ") { "%.4f".format(it) })
        if (coarse(aliasedAddresses) > 6) failures += "the one-cycle address did not alias: ${coarse(aliasedAddresses)}"
        if (coarse(addresses) < 24) failures += "the eight-cycle address did not glide: ${coarse(addresses)}"

        println()
        println("── three readers of one bank as three coordinates ──────────────────────")
        val x = shared.read(pat("<0 1 2 3 4>").nums(), name = "x")
        val y = shared.read(pat("<0 2 4 1 3>").nums().slow(3), name = "y")
        val r = shared.read(sine().slow(5).range(0.0, 4.0), duration = constant(0.5), name = "r")
        println("  cycle      x       y       r    stage x/y/r")
        for (step in 0 until 12) {
            val t = step * 1.1
            val sx = x.at(t)
            val sy = y.at(t)
            val sr = r.at(t)
            println(
                "  %5.2f  %6.3f  %6.3f  %6.3f    %s / %s / %s".format(
                    t, sx.value, sy.value, sr.value, sx.label, sy.label, sr.label
                )
            )
        }
        if (x.at(3.0).value == y.at(3.0).value && y.at(3.0).value == r.at(3.0).value) {
            failures += "three readers of one bank agreed exactly, which means they are not independent"
        }

        println()
        println("── pulses come from the same structure as the curve ────────────────────")
        val pulses = a.triggers().events(PatArc(PatQ.ZERO, PatQ.of(CYCLES.toLong())))
        val stages = a.stagesIn(PatArc(PatQ.ZERO, PatQ.of(CYCLES.toLong())))
        println("  ${stages.size} stages over $CYCLES cycles, ${pulses.size} pulses")
        if (pulses.size != stages.size) failures += "pulse count ${pulses.size} != stage count ${stages.size}"
        val rebuilt = shared.read(pat("<0 1 2 1 3 4>").nums(), name = "A-again")
        val gated = marf(
            value = pat("0 .3 .6 .9").nums(),
            duration = quarters,
            trigger = bools("1 0 0 1")
        )
        val gatedPulses = gated.triggers().events(PatArc(PatQ.ZERO, PatQ.ONE)).size
        println("  a `1 0 0 1` trigger over four stages a cycle gives $gatedPulses pulses")
        if (gatedPulses != 2) failures += "trigger gating gave $gatedPulses pulses, expected 2"
        if (rebuilt.at(1.5).value != a.at(1.5).value) failures += "two identically built readers disagreed"

        println()
        if (failures.isEmpty()) {
            println("MARF reader smoke tests passed")
        } else {
            failures.forEach { println("FAIL: $it") }
            error("MARF reader smoke tests failed: ${failures.size} failure(s)")
        }
    }