kalk 3.2.3

A math evaluator library that supports user-defined functions, variables and units, and can handle fairly ambiguous syntax.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

pub mod special_funcs {
    use crate::{as_number_or_return, errors::KalkError, float, prelude::KalkValue};

    pub fn factorial(x: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, unit) = as_number_or_return!(x);

        Ok(KalkValue::Number((real + 1f64).gamma(), float!(0), unit))
    }
}

pub(crate) mod funcs {
    use crate::errors::KalkError;
    use crate::kalk_value::KalkValue;
    use crate::prelude::funcs::abs;
    use crate::{as_number_or_return, float};

    pub fn arg(x: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, imaginary, unit) = as_number_or_return!(x);

        Ok(KalkValue::Number(imaginary.atan2(&real), float!(0), unit))
    }

    pub fn gamma(x: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, unit) = as_number_or_return!(x);

        Ok(KalkValue::Number(real.gamma(), float!(0), unit))
    }

    pub fn bitcmp(x: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, _) = as_number_or_return!(x);

        Ok(KalkValue::from(
            !real.to_i32_saturating().unwrap_or(i32::MAX),
        ))
    }

    pub fn bitand(x: KalkValue, y: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, _) = as_number_or_return!(x);
        let (real_rhs, _, _) = as_number_or_return!(y);

        Ok(KalkValue::from(
            real.to_i32_saturating().unwrap_or(i32::MAX)
                & real_rhs.to_i32_saturating().unwrap_or(i32::MAX),
        ))
    }

    pub fn bitor(x: KalkValue, y: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, _) = as_number_or_return!(x);
        let (real_rhs, _, _) = as_number_or_return!(y);

        Ok(KalkValue::from(
            real.to_i32_saturating().unwrap_or(i32::MAX)
                | real_rhs.to_i32_saturating().unwrap_or(i32::MAX),
        ))
    }

    pub fn bitxor(x: KalkValue, y: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, _) = as_number_or_return!(x);
        let (real_rhs, _, _) = as_number_or_return!(y);

        Ok(KalkValue::from(
            real.to_i32_saturating().unwrap_or(i32::MAX)
                ^ real_rhs.to_i32_saturating().unwrap_or(i32::MAX),
        ))
    }

    pub fn bitshift(x: KalkValue, y: KalkValue) -> Result<KalkValue, KalkError> {
        let (real, _, _) = as_number_or_return!(x);
        let (real_rhs, _, _) = as_number_or_return!(y);

        let x = real.to_i32_saturating().unwrap_or(i32::MAX);
        let y = real_rhs.to_i32_saturating().unwrap_or(i32::MAX);
        if y < 0 {
            Ok(KalkValue::from(x >> y.abs()))
        } else {
            Ok(KalkValue::from(x << y))
        }
    }

    pub fn hypot(x: KalkValue, y: KalkValue) -> Result<KalkValue, KalkError> {
        let is_complex = x.has_imaginary() || y.has_imaginary();
        let (real, imaginary, unit) = as_number_or_return!(x);
        let (real_rhs, imaginary_rhs, unit_rhs) = as_number_or_return!(y);
        if is_complex {
            let abs_x = abs(KalkValue::Number(real, imaginary, unit))?;
            let abs_y = abs(KalkValue::Number(real_rhs, imaginary_rhs, unit_rhs))?;
            crate::prelude::funcs::sqrt(
                abs_x
                    .clone()
                    .mul_without_unit(&abs_x)?
                    .add_without_unit(&abs_y.clone().mul_without_unit(&abs_y)?)?,
            )
        } else {
            Ok(KalkValue::Number(real.hypot(&real_rhs), float!(0), unit))
        }
    }
}