Method call_round

compiler/src/modules/vm/builtins/numeric.rs:214–250

(&mut self, op: u16)

    }

    pub fn call_round(&mut self, op: u16) -> Result<(), VmErr> {
        let args = self.pop_n(op as usize)?;
        let v = match (args.first().copied(), args.get(1).copied()) {
            (Some(o), Some(n)) if o.is_float() && n.is_int() => {
                let x = o.as_float();
                let nd = n.as_int();
                if !x.is_finite() {
                    Val::float(x)
                } else if nd >= 0 {
                    // Correctly-rounded decimal (round-half-even on the true value); avoids the double-rounding `x*10^n` would introduce (e.g. round(2.675, 2) -> 2.67).
                    let s = alloc::format!("{:.*}", (nd as usize).min(323), x);
                    Val::float(s.parse().unwrap_or(x))
                } else {
                    let factor = fpowi(10.0, (-nd) as i32);
                    Val::float(fround(x / factor) * factor)
                }
            }
            (Some(o), None) if o.is_float() => {
                // 1-arg round returns an int; promote via int_to_val so large results don't wrap.
                let f = o.as_float();
                if f.is_nan() { return Err(cold_value("cannot convert float NaN to integer")); }
                if f.is_infinite() { return Err(VmErr::Raised(alloc::string::String::from("OverflowError: cannot convert float infinity to integer"))); }
                let r = fround(f);
                if !(-1.7014118346046923e38..=1.7014118346046921e38).contains(&r) { return Err(cold_overflow()); }
                self.int_to_val(Some(r as i128))?
            }
            // Ints/bools round to themselves; negative ndigits round to tens/hundreds.
            (Some(o), n) if o.is_bool() || o.is_int() || (o.is_heap() && matches!(self.heap.get(o), HeapObj::LongInt(_))) => {
                let i = if o.is_bool() { o.as_bool() as i128 } else { self.as_i128(o).ok_or(cold_type("round() requires a number"))? };
                let nd = match n { Some(n) if n.is_int() => n.as_int(), _ => 0 };
                let r = if nd < 0 { round_int_banker(i, (-nd) as u32) } else { i };
                self.int_to_val(Some(r))?
            }
            _ => return Err(cold_type("round() requires a number")),
        };
        self.push(v); Ok(())
    }

    pub fn call_min(&mut self, op: u16, chunk: &crate::modules::parser::SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> { self.call_minmax(op, true, chunk, slots) }
    pub fn call_max(&mut self, op: u16, chunk: &crate::modules::parser::SSAChunk, slots: &mut [Val]) -> Result<(), VmErr> { self.call_minmax(op, false, chunk, slots) }