rbop 0.2.0

Rust framework for writing mathematical expression editors
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

use alloc::{vec::Vec, vec};
use num_integer::Integer;
use rust_decimal::{MathematicalOps, Decimal};

use crate::{Number, error::MathsError};

use super::{structured::{EvaluationSettings, AngleUnit}, unstructured::Serializable};

/// A mathematical function, for which an invocation may appear in an unstructured or structured
/// node tree.
#[derive(PartialEq, Eq, Debug, Copy, Clone)]
pub enum Function {
    Sine,
    Cosine,
    GreatestCommonDenominator,
}

impl Function {
    /// The suggested text displayed when this function is rendered.
    /// (Renderer implementations are free to ignore this.)
    pub fn render_name(&self) -> &'static str {
        match self {
            Self::Sine => "sin",
            Self::Cosine => "cos",
            Self::GreatestCommonDenominator => "gcd",
        }
    }

    /// The number of arguments for this function.
    pub fn argument_count(&self) -> usize {
        match self {
            Self::Sine | Self::Cosine => 1,
            Self::GreatestCommonDenominator => 2,
        }
    }

    /// Evaluates this function, given values for its arguments. 
    /// Panics if the number of arguments does not equal the expected number. This case shouldn't be
    /// possible for invocations built using rbop's input system, as a fixed number of slots are
    /// created for each argument.
    pub fn evaluate(&self, arguments: &[Number], settings: &EvaluationSettings) -> Result<Number, MathsError> {
        if arguments.len() != self.argument_count() {
            panic!("rbop function {:?} expected {} arguments, but got {}", self, self.argument_count(), arguments.len());
        }

        match self {
            Self::Sine | Self::Cosine => {
                // rust_decimal only lets us sine or cosine by interpreting the input as radians, so
                // do a conversion ourselves first if need be
                let mut target = arguments[0].to_decimal();
                if settings.angle_unit == AngleUnit::Degree {
                    target *= Decimal::PI / Decimal::from(180)
                }

                Ok(Number::Decimal(match self {
                    Self::Sine => target.sin(),
                    Self::Cosine => target.cos(),
                    _ => unreachable!()
                }))
            },

            Self::GreatestCommonDenominator => {
                // This is an integer operation, so convert both numbers to integers - if we can't,
                // just return 1
                let int_a = if let Some(x) = arguments[0].to_whole() { x } else {
                    return Ok(Number::Decimal(Decimal::ONE))
                };
                let int_b = if let Some(x) = arguments[1].to_whole() { x } else {
                    return Ok(Number::Decimal(Decimal::ONE))
                };

                Ok(int_a.gcd(&int_b).into())
            }
        }
    }
}

impl Serializable for Function {
    fn serialize(&self) -> Vec<u8> {
        vec![match self {
            Function::Sine => 1,
            Function::Cosine => 2,
            Function::GreatestCommonDenominator => 3,
        }]
    }

    fn deserialize(bytes: &mut dyn Iterator<Item = u8>) -> Option<Self> {
        match bytes.next() {
            Some(1) => Some(Function::Sine),
            Some(2) => Some(Function::Cosine),
            Some(3) => Some(Function::GreatestCommonDenominator),

            _ => None,
        }
    }
}