titaniumtown/YTBN-Graphing-Software
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename some variables

Browse Source
This commit is contained in:
Simon Gardling 2022-03-28 08:33:36 -04:00
parent e0709ae845
commit 6e281e0569
2 changed files with 49 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
src/egui_app.rs
View File

@ -243,10 +243,12 @@ pub struct AppSettings {
pub show_side_panel: bool, pub show_side_panel: bool,
/// Stores the type of Rienmann sum that should be calculated /// Stores the type of Rienmann sum that should be calculated
pub sum: Riemann, pub riemann_sum: Riemann,
/// Min and Max range for calculating an integral /// Min and Max range for calculating an integral
pub integral_min_x: f64, pub integral_min_x: f64,
/// Max value for calculating an
pub integral_max_x: f64, pub integral_max_x: f64,
pub integral_changed: bool, pub integral_changed: bool,
@ -258,12 +260,13 @@ pub struct AppSettings {
pub dark_mode: bool, pub dark_mode: bool,
/// Stores whether or not displaying extrema is enabled /// Stores whether or not displaying extrema is enabled
pub extrema: bool, pub do_extrema: bool,
/// Stores whether or not displaying roots is enabled /// Stores whether or not displaying roots is enabled
pub roots: bool, pub do_roots: bool,
pub pixel_width: usize, /// Stores current plot pixel width
pub plot_width: usize,
} }
impl Default for AppSettings { impl Default for AppSettings {
@ -274,15 +277,15 @@ impl Default for AppSettings {
help_open: true, help_open: true,
info_open: false, info_open: false,
show_side_panel: true, show_side_panel: true,
sum: DEFAULT_RIEMANN, riemann_sum: DEFAULT_RIEMANN,
integral_min_x: DEFAULT_MIN_X, integral_min_x: DEFAULT_MIN_X,
integral_max_x: DEFAULT_MAX_X, integral_max_x: DEFAULT_MAX_X,
integral_changed: true, integral_changed: true,
integral_num: DEFAULT_INTEGRAL_NUM, integral_num: DEFAULT_INTEGRAL_NUM,
dark_mode: true, dark_mode: true,
extrema: true, do_extrema: true,
roots: true, do_roots: true,
pixel_width: 0, plot_width: 0,
} }
} }
} }
@ -349,16 +352,24 @@ impl MathApp {
SidePanel::left("side_panel") SidePanel::left("side_panel")
.resizable(false) .resizable(false)
.show(ctx, |ui| { .show(ctx, |ui| {
let prev_sum = self.settings.sum; let prev_sum = self.settings.riemann_sum;
// ComboBox for selecting what Riemann sum type to use // ComboBox for selecting what Riemann sum type to use
ComboBox::from_label("Riemann Sum Type") ComboBox::from_label("Riemann Sum Type")
.selected_text(self.settings.sum.to_string()) .selected_text(self.settings.riemann_sum.to_string())
.show_ui(ui, |ui| { .show_ui(ui, |ui| {
ui.selectable_value(&mut self.settings.sum, Riemann::Left, "Left"); ui.selectable_value(&mut self.settings.riemann_sum, Riemann::Left, "Left");
ui.selectable_value(&mut self.settings.sum, Riemann::Middle, "Middle"); ui.selectable_value(
ui.selectable_value(&mut self.settings.sum, Riemann::Right, "Right"); &mut self.settings.riemann_sum,
Riemann::Middle,
"Middle",
);
ui.selectable_value(
&mut self.settings.riemann_sum,
Riemann::Right,
"Right",
);
}); });
let riemann_changed = prev_sum == self.settings.sum; let riemann_changed = prev_sum == self.settings.riemann_sum;
// Config options for Extrema and roots // Config options for Extrema and roots
let mut extrema_toggled: bool = false; let mut extrema_toggled: bool = false;
@ -366,7 +377,7 @@ impl MathApp {
ui.horizontal(|ui| { ui.horizontal(|ui| {
extrema_toggled = ui extrema_toggled = ui
.add(Button::new("Extrema")) .add(Button::new("Extrema"))
.on_hover_text(match self.settings.extrema { .on_hover_text(match self.settings.do_extrema {
true => "Disable Displaying Extrema", true => "Disable Displaying Extrema",
false => "Display Extrema", false => "Display Extrema",
}) })
@ -374,7 +385,7 @@ impl MathApp {
roots_toggled = ui roots_toggled = ui
.add(Button::new("Roots")) .add(Button::new("Roots"))
.on_hover_text(match self.settings.roots { .on_hover_text(match self.settings.do_roots {
true => "Disable Displaying Roots", true => "Disable Displaying Roots",
false => "Display Roots", false => "Display Roots",
}) })
@ -382,8 +393,8 @@ impl MathApp {
}); });
// If options toggled, flip the boolean // If options toggled, flip the boolean
self.settings.extrema.bitxor_assign(extrema_toggled); self.settings.do_extrema.bitxor_assign(extrema_toggled);
self.settings.roots.bitxor_assign(roots_toggled); self.settings.do_roots.bitxor_assign(roots_toggled);
let min_x_old = self.settings.integral_min_x; let min_x_old = self.settings.integral_min_x;
let min_x_changed = ui let min_x_changed = ui
@ -669,10 +680,10 @@ impl epi::App for MathApp {
} }
let available_width: usize = (ui.available_width() as usize) + 1; // Used in later logic let available_width: usize = (ui.available_width() as usize) + 1; // Used in later logic
let width_changed = available_width != self.settings.pixel_width; let width_changed = available_width != self.settings.plot_width;
if width_changed { if width_changed {
self.settings.pixel_width = available_width; self.settings.plot_width = available_width;
} }
let settings_copy = self.settings; let settings_copy = self.settings;

36
src/function.rs
View File

@ -166,8 +166,8 @@ impl FunctionEntry {
pub fn calculate( pub fn calculate(
&mut self, min_x: f64, max_x: f64, width_changed: bool, settings: AppSettings, &mut self, min_x: f64, max_x: f64, width_changed: bool, settings: AppSettings,
) { ) {
let resolution: f64 = settings.pixel_width as f64 / (max_x.abs() + min_x.abs()); let resolution: f64 = settings.plot_width as f64 / (max_x.abs() + min_x.abs());
let resolution_iter = resolution_helper(settings.pixel_width + 1, min_x, resolution); let resolution_iter = resolution_helper(settings.plot_width + 1, min_x, resolution);
// Makes sure proper arguments are passed when integral is enabled // Makes sure proper arguments are passed when integral is enabled
if self.integral && settings.integral_changed { if self.integral && settings.integral_changed {
@ -203,7 +203,7 @@ impl FunctionEntry {
} }
}) })
.collect(); .collect();
assert_eq!(back_data.len(), settings.pixel_width + 1); assert_eq!(back_data.len(), settings.plot_width + 1);
self.output.back = Some(back_data); self.output.back = Some(back_data);
let derivative_cache = self.output.derivative.as_ref().unwrap(); let derivative_cache = self.output.derivative.as_ref().unwrap();
@ -217,7 +217,7 @@ impl FunctionEntry {
}) })
.collect(); .collect();
assert_eq!(new_derivative_data.len(), settings.pixel_width + 1); assert_eq!(new_derivative_data.len(), settings.plot_width + 1);
self.output.derivative = Some(new_derivative_data); self.output.derivative = Some(new_derivative_data);
} else { } else {
@ -236,7 +236,7 @@ impl FunctionEntry {
let data: Vec<Value> = dyn_iter(&resolution_iter) let data: Vec<Value> = dyn_iter(&resolution_iter)
.map(|x| Value::new(*x, self.function.get(*x))) .map(|x| Value::new(*x, self.function.get(*x)))
.collect(); .collect();
assert_eq!(data.len(), settings.pixel_width + 1); assert_eq!(data.len(), settings.plot_width + 1);
self.output.back = Some(data); self.output.back = Some(data);
} }
@ -249,7 +249,7 @@ impl FunctionEntry {
let data: Vec<Value> = dyn_iter(&resolution_iter) let data: Vec<Value> = dyn_iter(&resolution_iter)
.map(|x| Value::new(*x, self.function.get_derivative_1(*x))) .map(|x| Value::new(*x, self.function.get_derivative_1(*x)))
.collect(); .collect();
assert_eq!(data.len(), settings.pixel_width + 1); assert_eq!(data.len(), settings.plot_width + 1);
self.output.derivative = Some(data); self.output.derivative = Some(data);
} }
@ -263,7 +263,7 @@ impl FunctionEntry {
let (data, area) = self.integral_rectangles( let (data, area) = self.integral_rectangles(
settings.integral_min_x, settings.integral_min_x,
settings.integral_max_x, settings.integral_max_x,
settings.sum, settings.riemann_sum,
settings.integral_num, settings.integral_num,
); );
self.output.integral = self.output.integral =
@ -277,12 +277,12 @@ impl FunctionEntry {
}; };
// Calculates extrema // Calculates extrema
if settings.extrema && (min_max_changed | self.output.extrema.is_none()) { if settings.do_extrema && (min_max_changed | self.output.extrema.is_none()) {
self.output.extrema = self.newtons_method_helper(threshold, 1); self.output.extrema = self.newtons_method_helper(threshold, 1);
} }
// Calculates roots // Calculates roots
if settings.roots && (min_max_changed | self.output.roots.is_none()) { if settings.do_roots && (min_max_changed | self.output.roots.is_none()) {
self.output.roots = self.newtons_method_helper(threshold, 0); self.output.roots = self.newtons_method_helper(threshold, 0);
} }
} }
@ -314,7 +314,7 @@ impl FunctionEntry {
} }
// Plot extrema points // Plot extrema points
if settings.extrema { if settings.do_extrema {
if let Some(extrema_data) = self.output.extrema.clone() { if let Some(extrema_data) = self.output.extrema.clone() {
plot_ui.points( plot_ui.points(
vec_tuple_to_points(extrema_data) vec_tuple_to_points(extrema_data)
@ -326,7 +326,7 @@ impl FunctionEntry {
} }
// Plot roots points // Plot roots points
if settings.roots { if settings.do_roots {
if let Some(roots_data) = self.output.roots.clone() { if let Some(roots_data) = self.output.roots.clone() {
plot_ui.points( plot_ui.points(
vec_tuple_to_points(roots_data) vec_tuple_to_points(roots_data)
@ -363,15 +363,15 @@ impl FunctionEntry {
let back_target = back_target; let back_target = back_target;
assert!(self.output.back.is_some()); assert!(self.output.back.is_some());
let back_data = self.output.back.as_ref().unwrap().clone(); let back_data = self.output.back.as_ref().unwrap().clone();
assert_eq!(back_data.len(), settings.pixel_width + 1); assert_eq!(back_data.len(), settings.plot_width + 1);
let back_vec_tuple = back_data.to_tuple(); let back_vec_tuple = back_data.to_tuple();
assert_eq!(back_vec_tuple, back_target); assert_eq!(back_vec_tuple, back_target);
assert!(self.integral); assert!(self.integral);
assert!(self.derivative); assert!(self.derivative);
assert_eq!(self.output.roots.is_some(), settings.roots); assert_eq!(self.output.roots.is_some(), settings.do_roots);
assert_eq!(self.output.extrema.is_some(), settings.extrema); assert_eq!(self.output.extrema.is_some(), settings.do_extrema);
assert!(self.output.derivative.is_some()); assert!(self.output.derivative.is_some());
assert!(self.output.integral.is_some()); assert!(self.output.integral.is_some());
@ -397,15 +397,15 @@ mod tests {
help_open: false, help_open: false,
info_open: false, info_open: false,
show_side_panel: false, show_side_panel: false,
sum, riemann_sum: sum,
integral_min_x, integral_min_x,
integral_max_x, integral_max_x,
integral_changed: true, integral_changed: true,
integral_num, integral_num,
dark_mode: false, dark_mode: false,
extrema: false, do_extrema: false,
roots: false, do_roots: false,
pixel_width, plot_width: pixel_width,
} }
} }