calculi 0.2.0

A crate used to apply calculus functions on equations in string form
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
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use super::utils::*;
use super::component::Component;
use super::operators::Operator::*;

fn chain_rule(left: Component, right: &Component) -> Component {
  create_binary(Multiply, left, derive_component(right))
}

pub fn derive_component(expr: &Component) -> Component {
  match expr {
    Component::Number(_) => Component::Number(0.0),
    Component::Variable(_) => Component::Number(1.0),

    Component::Function { operator, values } => match operator {
      Add => create_binary(
        Add,
        derive_component(&values[0]),
        derive_component(&values[1]),
      ),

      Subtract => create_binary(
        Subtract,
        derive_component(&values[0]),
        derive_component(&values[1]),
      ),

      Multiply => create_binary(
        Add,
        chain_rule(values[0].clone(), &values[1]),
        chain_rule(values[1].clone(), &values[0]),
      ),

      Exponent | Pow => {
        // x^n
        if let Component::Number(f) = &values[1] {
          chain_rule(
            create_binary(
              Multiply,
              Component::Number(*f),
              create_binary(Exponent, values[0].clone(), Component::Number(f - 1.0)),
            ),
            &values[0],
          )
        // n^x
        } else if let Component::Number(f) = &values[0] {
          create_binary(
            Multiply,
            create_unary(Ln, Component::Number(*f)),
            chain_rule(expr.clone(), &expr),
          )
        } else {
          // x^x
          create_binary(
            Multiply,
            expr.clone(),
            create_binary(
              Add,
              create_binary(
                Multiply,
                derive_component(&values[1]),
                create_unary(Ln, values[0].clone()),
              ),
              create_binary(
                Multiply,
                values[1].clone(),
                create_binary(Divide, derive_component(&values[0]), values[0].clone()),
              ),
            ),
          )
        }
      }

      Log => chain_rule(
        create_binary(
          Divide,
          derive_component(&values[0]),
          create_binary(
            Multiply,
            create_unary(Ln, values[1].clone()),
            values[0].clone(),
          ),
        ),
        &values[0],
      ),

      Ln => chain_rule(
        create_binary(Divide, derive_component(&values[0]), values[0].clone()),
        &values[0],
      ),

      Sin => chain_rule(create_unary(Cos, values[0].clone()), &values[0]),

      Cos => chain_rule(
        create_binary(
          Multiply,
          Component::Number(-1.0),
          create_unary(Sin, values[0].clone()),
        ),
        &values[0],
      ),

      Tan => chain_rule(
        create_binary(
          Pow,
          create_unary(Sec, values[0].clone()),
          Component::Number(2.0),
        ),
        &values[0],
      ),

      Sec => chain_rule(
        create_binary(
          Multiply,
          create_unary(Sec, values[0].clone()),
          create_unary(Tan, values[0].clone()),
        ),
        &values[0],
      ),

      Csc => chain_rule(
        create_binary(
          Multiply,
          Component::Number(-1.0),
          create_binary(
            Multiply,
            create_unary(Csc, values[0].clone()),
            create_unary(Cot, values[0].clone()),
          ),
        ),
        &values[0],
      ),

      Cot => chain_rule(
        create_binary(
          Multiply,
          Component::Number(-1.0),
          create_binary(
            Pow,
            create_unary(Csc, values[0].clone()),
            Component::Number(2.0),
          ),
        ),
        &values[0],
      ),

      _ => Component::End,
    },
    _ => Component::End,
  }
}