Feat: demo songs

crates/forth/src/ops.rs

@@ -95,6 +95,8 @@ pub enum Op {
     Ramp,
     Triangle,
     Range,
+    LinMap,
+    ExpMap,
     Perlin,
     Loop,
     Degree(&'static [i64]),

crates/forth/src/vm.rs

@@ -1083,6 +1083,28 @@ impl Forth {
                     let val = pop_float(stack)?;
                     stack.push(Value::Float(min + val * (max - min), None));
                 }
+                Op::LinMap => {
+                    let out_hi = pop_float(stack)?;
+                    let out_lo = pop_float(stack)?;
+                    let in_hi = pop_float(stack)?;
+                    let in_lo = pop_float(stack)?;
+                    let val = pop_float(stack)?;
+                    let t = if (in_hi - in_lo).abs() < f64::EPSILON {
+                        0.0
+                    } else {
+                        (val - in_lo) / (in_hi - in_lo)
+                    };
+                    stack.push(Value::Float(out_lo + t * (out_hi - out_lo), None));
+                }
+                Op::ExpMap => {
+                    let hi = pop_float(stack)?;
+                    let lo = pop_float(stack)?;
+                    let val = pop_float(stack)?;
+                    if lo <= 0.0 || hi <= 0.0 {
+                        return Err("expmap requires positive bounds".into());
+                    }
+                    stack.push(Value::Float(lo * (hi / lo).powf(val), None));
+                }
                 Op::Perlin => {
                     let freq = pop_float(stack)?;
                     let val = perlin_noise_1d(freq * ctx.beat);

crates/forth/src/words/compile.rs

@@ -88,6 +88,8 @@ pub(super) fn simple_op(name: &str) -> Option<Op> {
         "ramp" => Op::Ramp,
         "triangle" => Op::Triangle,
         "range" => Op::Range,
+        "linmap" => Op::LinMap,
+        "expmap" => Op::ExpMap,
         "perlin" => Op::Perlin,
         "loop" => Op::Loop,
         "oct" => Op::Oct,

crates/forth/src/words/core.rs

@@ -354,6 +354,26 @@ pub(super) const WORDS: &[Word] = &[
         compile: Simple,
         varargs: false,
     },
+    Word {
+        name: "linmap",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(val inlo inhi outlo outhi -- mapped)",
+        desc: "Linear map from [inlo,inhi] to [outlo,outhi]",
+        example: "64 0 127 200 2000 linmap => 1007.87",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "expmap",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(val lo hi -- mapped)",
+        desc: "Exponential map from [0,1] to [lo,hi]",
+        example: "0.5 200 8000 expmap => 1264.91",
+        compile: Simple,
+        varargs: false,
+    },
     // Comparison
     Word {
         name: "=",