beamr 0.3.12

A Rust runtime with the BEAM's execution model, targeting Gleam
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Math module BIFs.

use crate::atom::Atom;
use crate::native::ProcessContext;
use crate::term::Term;
use crate::term::boxed::{Float, write_float};

pub fn bif_ceil(args: &[Term], context: &mut ProcessContext) -> Result<Term, Term> {
    let _ = context;
    let [value] = args else {
        return Err(badarg());
    };
    make_float(number_to_f64(*value)?.ceil())
}

pub fn bif_floor(args: &[Term], context: &mut ProcessContext) -> Result<Term, Term> {
    let _ = context;
    let [value] = args else {
        return Err(badarg());
    };
    make_float(number_to_f64(*value)?.floor())
}

pub fn bif_exp(args: &[Term], context: &mut ProcessContext) -> Result<Term, Term> {
    let _ = context;
    let [value] = args else {
        return Err(badarg());
    };
    make_float(number_to_f64(*value)?.exp())
}

pub fn bif_log(args: &[Term], context: &mut ProcessContext) -> Result<Term, Term> {
    let _ = context;
    let [value] = args else {
        return Err(badarg());
    };
    let value = number_to_f64(*value)?;
    if value <= 0.0 {
        return Err(badarg());
    }
    make_float(value.ln())
}

pub fn bif_pow(args: &[Term], context: &mut ProcessContext) -> Result<Term, Term> {
    let _ = context;
    let [base, exponent] = args else {
        return Err(badarg());
    };
    make_float(number_to_f64(*base)?.powf(number_to_f64(*exponent)?))
}

fn number_to_f64(term: Term) -> Result<f64, Term> {
    if let Some(value) = term.as_small_int() {
        return Ok(value as f64);
    }

    let value = Float::new(term).ok_or_else(badarg)?.value();
    if value.is_finite() {
        Ok(value)
    } else {
        Err(badarg())
    }
}

fn make_float(value: f64) -> Result<Term, Term> {
    if !value.is_finite() {
        return Err(badarg());
    }
    let heap = Box::leak(Box::new([0u64; 2]));
    write_float(heap, value).ok_or_else(badarg)
}

fn badarg() -> Term {
    Term::atom(Atom::BADARG)
}