reddb-io-tq 0.29.8

jq-style CLI for TOON v4.1, TOONL v0.2, JSON, YAML, and XML
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use reddb_io_toon::Value;

use super::super::ast::Expr;
use super::super::eval::Env;
use super::Builtin;

pub(super) const BUILTINS: &[Builtin] = &[
    Builtin::new("abs", 0, call_abs),
    Builtin::new("ceil", 0, call_ceil),
    Builtin::new("exp", 0, call_exp),
    Builtin::new("fabs", 0, call_fabs),
    Builtin::new("floor", 0, call_floor),
    Builtin::new("log", 0, call_log),
    Builtin::new("log2", 0, call_log2),
    Builtin::new("log10", 0, call_log10),
    Builtin::new("pow", 2, call_pow),
    Builtin::new("round", 0, call_round),
    Builtin::new("significand", 0, call_significand),
    Builtin::new("sqrt", 0, call_sqrt),
    Builtin::new("trunc", 0, call_trunc),
];

fn call_abs(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, |value| if value < 0.0 { -value } else { value })
}

fn call_ceil(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::ceil)
}

fn call_exp(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::exp)
}

fn call_fabs(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::abs)
}

fn call_floor(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::floor)
}

fn call_log(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::ln)
}

fn call_log2(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::log2)
}

fn call_log10(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::log10)
}

fn call_pow(arguments: &[Expr], input: &Value, env: &Env) -> Result<Vec<Value>, String> {
    let bases = arguments[0].eval(input, env)?;
    let exponents = arguments[1].eval(input, env)?;
    let mut output = Vec::new();
    for exponent in &exponents {
        let exponent = required_number(exponent)?;
        for base in &bases {
            output.push(number_value(required_number(base)?.powf(exponent)));
        }
    }
    Ok(output)
}

fn call_round(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::round)
}

fn call_significand(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, significand)
}

fn call_sqrt(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::sqrt)
}

fn call_trunc(_: &[Expr], input: &Value, _: &Env) -> Result<Vec<Value>, String> {
    call_unary(input, f64::trunc)
}

fn call_unary(input: &Value, operation: fn(f64) -> f64) -> Result<Vec<Value>, String> {
    Ok(vec![number_value(operation(required_number(input)?))])
}

fn required_number(value: &Value) -> Result<f64, String> {
    let Value::Number(value) = value else {
        return Err("number required".to_owned());
    };
    value.parse().map_err(|_| "number required".to_owned())
}

fn number_value(value: f64) -> Value {
    let encoded = if value.is_nan() {
        "NaN".to_owned()
    } else if value == f64::INFINITY {
        "inf".to_owned()
    } else if value == f64::NEG_INFINITY {
        "-inf".to_owned()
    } else if value.fract() == 0.0 {
        format!("{value:.0}")
    } else {
        serde_json::Number::from_f64(value)
            .expect("finite f64 is a JSON number")
            .to_string()
    };
    Value::Number(encoded)
}

fn significand(value: f64) -> f64 {
    const FRACTION_MASK: u64 = (1_u64 << 52) - 1;
    const EXPONENT_ONE: u64 = 1023_u64 << 52;

    let bits = value.to_bits();
    let sign = bits & (1_u64 << 63);
    let exponent = bits & (0x7ff_u64 << 52);
    let fraction = bits & FRACTION_MASK;
    if exponent == 0 {
        if fraction == 0 {
            return value;
        }
        let highest = 63 - fraction.leading_zeros() as u64;
        let normalized = fraction << (52 - highest);
        return f64::from_bits(sign | EXPONENT_ONE | (normalized & FRACTION_MASK));
    }
    if exponent == 0x7ff_u64 << 52 {
        return value;
    }
    f64::from_bits(sign | EXPONENT_ONE | fraction)
}