Merge pull request #27 from coco33920/add-vector

Add vector
coco33920 · Nov 22, 2023 · b17c10b · b17c10b
2 parents c9934e6 + f69e15d
commit b17c10b
Show file tree

Hide file tree

Showing 6 changed files with 120 additions and 53 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,3 +1,12 @@
+# Version 2.9.10 : Fix bug, vector plotting
+
+## Plot 
+- add vector plotting
+
+## Terminal plot
+- fix edge case by changing the coefficient a little bit 
+- add vector termploting
+
 # Version 2.9.9 : Terminal plot
 
 - fix bug if yscale or xscale is 0

diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "mini-calc"
-version = "2.9.9"
+version = "2.9.10"
 license = "GPL-3.0-or-later"
 description = "A fully-featured minimalistic configurable rust calculator"
 homepage = "https://calc.nwa2coco.fr"

diff --git a/src/configuration/loader.rs b/src/configuration/loader.rs
@@ -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%", "v2.9.9")
+        .replace("%version%", "v2.9.10")
         .to_string()
 }
 

diff --git a/src/interpreting/stdlib.rs b/src/interpreting/stdlib.rs
@@ -1055,7 +1055,14 @@ pub fn plot_fn(
     let mut f: fn(&Vec<Parameters>, &Option<&mut HashMap<String, Parameters>>) -> Parameters = cos;
     let mut fd: String = "".to_string();
     let mut rad: bool = false;
+    let mut fun: bool = true;
+    let mut first_vector = None;
+    let mut second_vector = None;
     match fs {
+        Parameters::InterpreterVector(vec) => {
+            fun = false;
+            first_vector = Some(&**vec)
+        }
         Parameters::Identifier(s) => match s.as_str() {
             "cos" => {
                 f = cos;
@@ -1089,12 +1096,26 @@ pub fn plot_fn(
             "log" => f = ln,
             "sqrt" => f = sqrt,
             s => match functions {
-                None => (),
+                None => match ram.as_ref().unwrap().get(s) {
+                    None => return Parameters::Null,
+                    Some(Parameters::InterpreterVector(vec)) => {
+                        fun = false;
+                        first_vector = Some(&**vec);
+                    }
+                    _ => return Parameters::Null,
+                },
                 Some(ref t) => {
                     if t.contains_key(s) {
                         fd = s.to_string();
                     } else {
-                        return Parameters::Null;
+                        match ram.as_ref().unwrap().get(s) {
+                            None => return Parameters::Null,
+                            Some(Parameters::InterpreterVector(vec)) => {
+                                fun = false;
+                                first_vector = Some(&**vec)
+                            }
+                            _ => return Parameters::Null,
+                        }
                     }
                 }
             },
@@ -1119,11 +1140,14 @@ pub fn plot_fn(
         Some(p) => match p {
             Parameters::Float(f) => start = *f,
             Parameters::Int(i) => start = *i as f64,
+            Parameters::InterpreterVector(vec) => second_vector = Some(&**vec),
 
             Parameters::Identifier(s) if ram.as_ref().unwrap().contains_key(s) => {
                 match ram.as_ref().unwrap().get(s) {
                     Some(Parameters::Float(f)) => start = *f,
                     Some(Parameters::Int(i)) => start = *i as f64,
+                    Some(Parameters::InterpreterVector(vec)) => second_vector = Some(&**vec),
+
                     _ => (),
                 }
             }
@@ -1283,63 +1307,96 @@ pub fn plot_fn(
         },
     }
 
+    let st = start;
     let mut x = Vec::new();
     let mut y = Vec::new();
-
-    let (mut vec, mut ast): (Vec<Ast>, Ast) = (Vec::new(), Ast::Nil);
-    match functions {
-        None => (),
-        Some(ref s) => {
-            if s.contains_key(&fd) {
-                (vec, ast) = s.get(&fd).unwrap().clone();
+    if fun {
+        let (mut vec, mut ast): (Vec<Ast>, Ast) = (Vec::new(), Ast::Nil);
+        match functions {
+            None => (),
+            Some(ref s) => {
+                if s.contains_key(&fd) {
+                    (vec, ast) = s.get(&fd).unwrap().clone();
+                }
             }
         }
-    }
 
-    let mut sram: HashMap<String, Parameters> = HashMap::new();
-    sram.insert("pi".to_string(), Parameters::Float(PI));
-    sram.insert("e".to_string(), Parameters::Float(E));
-    let st = start;
-    while start <= end {
-        x.push(start);
-        if &fd == "" {
-            let p = f(&vec![Parameters::Float(start)], ram);
-            y.push(match p {
-                Parameters::Float(f) => f,
-                Parameters::Int(i) => i as f64,
-                _ => f64::NAN,
-            });
-        } else {
-            let mut names = Vec::new();
-            for v in vec.clone() {
-                match v {
-                    Ast::Nil => (),
-                    Ast::Call { .. } => (),
-                    Ast::Node {
-                        value: v,
-                        left: _l,
-                        right: _r,
-                    } => match v {
-                        Parameters::Identifier(s) => names.push(s.clone()),
+        let mut sram: HashMap<String, Parameters> = HashMap::new();
+        sram.insert("pi".to_string(), Parameters::Float(PI));
+        sram.insert("e".to_string(), Parameters::Float(E));
+        while start <= end {
+            x.push(start);
+            if &fd == "" {
+                let p = f(&vec![Parameters::Float(start)], ram);
+                y.push(match p {
+                    Parameters::Float(f) => f,
+                    Parameters::Int(i) => i as f64,
+                    _ => f64::NAN,
+                });
+            } else {
+                let mut names = Vec::new();
+                for v in vec.clone() {
+                    match v {
+                        Ast::Nil => (),
+                        Ast::Call { .. } => (),
+                        Ast::Node {
+                            value: v,
+                            left: _l,
+                            right: _r,
+                        } => match v {
+                            Parameters::Identifier(s) => names.push(s.clone()),
+                            _ => (),
+                        },
+                    }
+                }
+                names
+                    .iter()
+                    .zip(vec![Parameters::Float(start)])
+                    .for_each(|(name, param)| {
+                        sram.insert(name.to_string(), param.clone());
+                    });
+                y.push(match interpret(&ast, &mut sram, &mut HashMap::new()) {
+                    Parameters::Float(p) => p,
+                    Parameters::Int(i) => i as f64,
+                    _ => f64::NAN,
+                });
+            }
+            start += steps;
+        }
+    } else {
+        match first_vector {
+            Some(t) => {
+                t.into_iter().for_each(|j| match j {
+                    Parameters::Int(i) => x.push(*i as f64),
+                    Parameters::Float(f) => x.push(*f),
+                    Parameters::Identifier(s) => match ram.as_ref().unwrap().get(s) {
+                        Some(Parameters::Int(i)) => x.push(*i as f64),
+                        Some(Parameters::Float(f)) => x.push(*f),
                         _ => (),
                     },
-                }
+                    _ => (),
+                });
             }
-            names
-                .iter()
-                .zip(vec![Parameters::Float(start)])
-                .for_each(|(name, param)| {
-                    sram.insert(name.to_string(), param.clone());
+            _ => return Parameters::Null,
+        }
+
+        match second_vector {
+            Some(t) => {
+                t.into_iter().for_each(|j| match j {
+                    Parameters::Int(i) => y.push(*i as f64),
+                    Parameters::Float(f) => y.push(*f),
+                    Parameters::Identifier(s) => match ram.as_ref().unwrap().get(s) {
+                        Some(Parameters::Int(i)) => y.push(*i as f64),
+                        Some(Parameters::Float(f)) => y.push(*f),
+                        _ => (),
+                    },
+                    _ => (),
                 });
-            y.push(match interpret(&ast, &mut sram, &mut HashMap::new()) {
-                Parameters::Float(p) => p,
-                Parameters::Int(i) => i as f64,
-                _ => f64::NAN,
-            });
+            }
+            _ => return Parameters::Null,
         }
-        start += steps;
     }
-
+    println!("{:?}/{:?}", &x, &y);
     let mut f: Figure = Figure::new();
     let _ = match mode.to_lowercase().as_str() {
         "marks" => f

diff --git a/src/main.rs b/src/main.rs
@@ -278,7 +278,7 @@ fn main() {
     let style = &loaded.clone().prompt_style;
     let mut text = &loaded.clone().prompt;
     let mut verbose = false;
-    let version: String = "v2.9.9".to_string();
+    let version: String = "v2.9.10".to_string();
     interface.set_completer(Arc::new(CalcCompleter));
     interface
         .set_prompt(&format!(

diff --git a/src/utils/plot_utils.rs b/src/utils/plot_utils.rs
@@ -22,8 +22,8 @@ pub fn computes_lines(
         }
     });
 
-    let mut x_scale = (end - start) / 100.0;
-    let mut y_scale = (ymax - ymin) / 30.0;
+    let mut x_scale = (end - start) / 99.0;
+    let mut y_scale = (ymax - ymin) / 29.0;
 
     if x_scale == 0.0 {
         x_scale = 1.0;
@@ -40,6 +40,7 @@ pub fn computes_lines(
     });
 
     z.for_each(|(x, y)| {
+        println!("x: {x}, y: {y}");
         if x < 100 && y < 30 {
             bitmap[y][x] = '+';
         }