Merge branch 'mistress' into website

Author: vanilla-extracts

CHANGELOG.md

@@ -1,3 +1,6 @@
+# Version 3.3.4 : Bug fix
+Fix bug #61 and #59
+
 # Version 3.3.2 : CI
 
 # Version 3.3.0 : Colours

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mini-calc"
-version = "3.3.3"
+version = "3.3.4"
 license = "GPL-3.0-or-later"
 description = "A Fully-Featured Configurable (mini) Rust Calculator"
 homepage = "https://calc.charlotte-thomas.me"

Cargo.toml

@@ -1,5 +1,5 @@
 watch:
-	cargo watch -x check -x fmt -x run
+	cargo watch -x fmt -x run
 compile:
 	cargo build
 release: 

Makefile

@@ -1,4 +1,6 @@
 #import "@preview/codly:1.0.0": *
+#import "@preview/colorful-boxes:1.4.1": *
+
 #set page(numbering: "1/1")
 #set align(center)
 #set text(font: "Monaspace Xenon")
@@ -100,6 +102,14 @@ Visit #calc to see all the install page
 - `/` for the division (or for a rational)
 - `^` for the exponentation
 
+#colorbox(
+ title: "Warning",
+ color: "red",
+)[
+  You shoudln't use the `^` operator with functions, it is not taken into
+  account for differentiations
+]
+
 == Variables
 
 It also supports variable the syntax is
@@ -492,12 +502,13 @@ As of `3.2.0`, the calculator can differentiate known functions (function
 constructed using the standard functions). It supports both built-in and
 user-defined functions. 
 
-#text(20pt)[#emoji.warning] Beware as of `3.3.3` there is some bugs to iron out.
+#colorbox(title: "Warning", color: "red")[Beware as of `3.3.3` there is some bugs to iron out.
 It doesn't differentiates vars (differentiation of $x*x$ works but not $x^2$.).
 And differentiation of function 
-referencing each other (example $v(x) = f(x) + x*x$) doesn't work either. 
+referencing each other (example $v(x) = f(x) + x*x$) doesn't work either.] 
 
-It's currently being fixed, and will be fixed before `3.4.0`
+#colorbox(title: "Fixed", color: "blue")[As of `3.3.4` functions referencing
+each other works with *diff*]
 
 === Examples
 

manual.pdf

@@ -131,7 +131,7 @@ pub fn load_color(string: String) -> Color {
 
 pub fn replace_variable(str: String) -> String {
     str.replace("%author%", "Charlotte Thomas")
-        .replace("%version%", "v3.3.3")
+        .replace("%version%", "v3.3.4")
         .to_string()
 }
 

manual/main.pdf

@@ -40,27 +40,26 @@ pub fn exec(
         "ceil" => ceil(&lst, &ram),
         "floor" => floor(&lst, &ram),
         "round" => round(&lst, &ram),
-        "norm" => norm(&lst, &ram, functions),
+        "norm" => norm(&lst, &ram, &functions),
         "transpose_vector" => transpose_vectors(&lst, &ram),
         "transpose" => transpose_matrices(&lst, &ram),
         "det" => det_matrix(&lst, &ram),
         "invert" => inverse_matrix(&lst, &ram),
-        "plot" => plot_fn(&lst, &ram, functions, false),
-        "termplot" => plot_fn(&lst, &ram, functions, true),
-        "diff" => diff(&lst, &ram, functions),
+        "plot" => plot_fn(&lst, &ram, &functions, false),
+        "termplot" => plot_fn(&lst, &ram, &functions, true),
+        "diff" => diff(&lst, &ram, &functions),
         s => {
             let mut sram: HashMap<String, Parameters> = HashMap::new();
             sram.insert("pi".to_string(), Float(PI));
             sram.insert("e".to_string(), Float(E));
             match functions.cloned() {
-                None => Identifier("This function is unknown".to_string()),
+                None => Identifier("@This function is unknown".to_string()),
                 Some(mut f) => {
-                    let fs = f.get_mut(s);
-                    let (vec, ast): (&mut Vec<Ast>, &mut Ast) = match fs {
+                    let (vec, ast): (Vec<Ast>, Ast) = match f.get(s) {
                         None => {
-                            return Identifier("This function is unknown".to_string());
+                            return Identifier("@This function is unknown".to_string());
                         }
-                        Some((a, b)) => (a, b),
+                        Some((a, b)) => (a.clone(), b.clone()),
                     };
 
                     let mut names = Vec::new();
@@ -88,7 +87,7 @@ pub fn exec(
                         .for_each(|(name, param)| {
                             sram.insert(name.to_string(), param);
                         });
-                    interpret(ast, &mut sram, &mut HashMap::new())
+                    interpret(&ast, &mut sram, &mut f)
                 }
             }
         }
@@ -1299,7 +1298,7 @@ pub fn round(p: &Vec<Parameters>, ram: &Option<&mut HashMap<String, Parameters>>
 pub fn norm(
     p: &Vec<Parameters>,
     ram: &Option<&mut HashMap<String, Parameters>>,
-    function: Option<&mut HashMap<String, (Vec<Ast>, Ast)>>,
+    function: &Option<&mut HashMap<String, (Vec<Ast>, Ast)>>,
 ) -> Parameters {
     if p.len() < 1 {
         return Null;
@@ -1556,7 +1555,7 @@ pub fn inverse_matrix(
 pub fn diff(
     p: &Vec<Parameters>,
     ram: &Option<&mut HashMap<String, Parameters>>,
-    function: Option<&mut HashMap<String, (Vec<Ast>, Ast)>>,
+    function: &Option<&mut HashMap<String, (Vec<Ast>, Ast)>>,
 ) -> Parameters {
     let color = match load() {
         Ok(cfg) => load_config(cfg).general_color,
@@ -1645,7 +1644,7 @@ pub fn diff(
                     p.to_string(),
                     vec![Identifier("x".to_string())],
                     Some(&mut c),
-                    function,
+                    Some(&mut s),
                 );
                 match param {
                     Identifier(_) => Int(1),
@@ -1654,20 +1653,21 @@ pub fn diff(
                         y - 1,
                         z,
                     ),
+
                     Plus(x, y) => other_add(
-                        diff(&vec![*x.clone()], &Some(&mut c), Some(&mut s)),
-                        diff(&vec![*y.clone()], &Some(&mut c), Some(&mut s)),
+                        diff(&vec![*x.clone()], &Some(&mut c), &Some(&mut s)),
+                        diff(&vec![*y.clone()], &Some(&mut c), &Some(&mut s)),
                         Some(&c),
                     ),
                     Mul(x, y) => other_add(
                         mult(
                             *x.clone(),
-                            diff(&vec![*y.clone()], &Some(&mut c), Some(&mut s)),
+                            diff(&vec![*y.clone()], &Some(&mut c), &Some(&mut s)),
                             Some(&c),
                         ),
                         mult(
                             *y.clone(),
-                            diff(&vec![*x.clone()], &Some(&mut c), Some(&mut s)),
+                            diff(&vec![*x.clone()], &Some(&mut c), &Some(&mut s)),
                             Some(&c),
                         ),
                         Some(&c),
@@ -1676,24 +1676,24 @@ pub fn diff(
                         Box::from(other_add(
                             mult(
                                 *x.clone(),
-                                diff(&vec![*y.clone()], &Some(&mut c), Some(&mut s)),
+                                diff(&vec![*y.clone()], &Some(&mut c), &Some(&mut s)),
                                 Some(&c),
                             ),
                             mult(
                                 mult(Int(-1), *y.clone(), Some(&c)),
-                                diff(&vec![*x.clone()], &Some(&mut c), Some(&mut s)),
+                                diff(&vec![*x.clone()], &Some(&mut c), &Some(&mut s)),
                                 Some(&c),
                             ),
                             Some(&c),
                         )),
                         Box::from(mult(*y.clone(), *y.clone(), Some(&c))),
                     ),
                     Call(name, pst) => {
-                        let prefix = diff(&vec![*pst.clone()], &Some(&mut c), Some(&mut s));
+                        let prefix = diff(&vec![*pst.clone()], &Some(&mut c), &Some(&mut s));
                         let call = diff(
                             &vec![Identifier(name), *pst.clone()],
                             &Some(&mut c),
-                            Some(&mut s),
+                            &Some(&mut s),
                         );
                         mult(prefix, call, Some(&c))
                     }
@@ -1707,19 +1707,19 @@ pub fn diff(
             z.clone(),
         ),
         Plus(x, y) => other_add(
-            diff(&vec![*x.clone()], &Some(&mut c), Some(&mut s)),
-            diff(&vec![*y.clone()], &Some(&mut c), Some(&mut s)),
+            diff(&vec![*x.clone()], &Some(&mut c), &Some(&mut s)),
+            diff(&vec![*y.clone()], &Some(&mut c), &Some(&mut s)),
             Some(&c),
         ),
         Mul(x, y) => other_add(
             mult(
                 *x.clone(),
-                diff(&vec![*y.clone()], &Some(&mut c), Some(&mut s)),
+                diff(&vec![*y.clone()], &Some(&mut c), &Some(&mut s)),
                 Some(&c),
             ),
             mult(
                 *y.clone(),
-                diff(&vec![*x.clone()], &Some(&mut c), Some(&mut s)),
+                diff(&vec![*x.clone()], &Some(&mut c), &Some(&mut s)),
                 Some(&c),
             ),
             Some(&c),
@@ -1728,12 +1728,12 @@ pub fn diff(
             Box::from(other_add(
                 mult(
                     *x.clone(),
-                    diff(&vec![*y.clone()], &Some(&mut c), Some(&mut s)),
+                    diff(&vec![*y.clone()], &Some(&mut c), &Some(&mut s)),
                     Some(&c),
                 ),
                 mult(
                     Mul(Box::from(Int(-1)), y.clone()),
-                    diff(&vec![*x.clone()], &Some(&mut c), Some(&mut s)),
+                    diff(&vec![*x.clone()], &Some(&mut c), &Some(&mut s)),
                     Some(&c),
                 ),
                 Some(&c),
@@ -1742,11 +1742,11 @@ pub fn diff(
         ),
 
         Call(name, pst) => {
-            let prefix = diff(&vec![*pst.clone()], &Some(&mut c), Some(&mut s));
+            let prefix = diff(&vec![*pst.clone()], &Some(&mut c), &Some(&mut s));
             let call = diff(
                 &vec![Identifier(name.to_string()), *pst.clone()],
                 &Some(&mut c),
-                Some(&mut s),
+                &Some(&mut s),
             );
             mult(prefix, call, Some(&c))
         }
@@ -1757,7 +1757,7 @@ pub fn diff(
 pub fn plot_fn(
     p: &Vec<Parameters>,
     ram: &Option<&mut HashMap<String, Parameters>>,
-    functions: Option<&mut HashMap<String, (Vec<Ast>, Ast)>>,
+    functions: &Option<&mut HashMap<String, (Vec<Ast>, Ast)>>,
     terminal: bool,
 ) -> Parameters {
     let color = match load() {

manual/main.typ

@@ -263,7 +263,7 @@ fn handle_config(line: &str, config: Config) -> (String, Option<Config>) {
 fn main() {
     let mut args: Args = env::args();
 
-    let version: String = "v3.3.3".to_string();
+    let version: String = "v3.3.4".to_string();
     if args.len() > 1 || !atty::is(Stream::Stdin) {
         let mut a = vec![];
 

src/configuration/loader.rs

@@ -156,7 +156,7 @@ impl Parameters {
                 if s.starts_with("@") {
                     match s.strip_prefix("@") {
                         None => format!(""),
-                        Some(c) => format!("{c}"),
+                        Some(c) => format!("Error: {}", Color::Red.paint(c)),
                     }
                 } else {
                     if ram == None {