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

cargo clippy + fmt

Browse Source
This commit is contained in:
Simon Gardling
2025-12-03 11:43:42 -05:00
parent 5a92020dae
commit aa07631296
15 changed files with 2069 additions and 2016 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/consts.rs
View File

@@ -5,13 +5,13 @@ shadow!(build);
/// Constant string that has a string containing information about the build.
pub const BUILD_INFO: &str = formatc!(
"Commit: {} ({})\nBuild Date: {}\nPackage Version: {}\nRust Channel: {}\nRust Version: {}",
&build::SHORT_COMMIT,
&build::BRANCH,
&build::BUILD_TIME,
&build::PKG_VERSION,
&build::RUST_CHANNEL,
&build::RUST_VERSION,
"Commit: {} ({})\nBuild Date: {}\nPackage Version: {}\nRust Channel: {}\nRust Version: {}",
&build::SHORT_COMMIT,
&build::BRANCH,
&build::BUILD_TIME,
&build::PKG_VERSION,
&build::RUST_CHANNEL,
&build::RUST_VERSION,
);
pub const FONT_SIZE: f32 = 14.0;
@@ -31,24 +31,24 @@ pub const DEFAULT_INTEGRAL_NUM: usize = 100;
/// Colors used for plotting
// Colors commented out are used elsewhere and are not included here for better user experience
pub const COLORS: [Color32; 13] = [
Color32::RED,
// Color32::GREEN,
// Color32::YELLOW,
// Color32::BLUE,
Color32::BROWN,
Color32::GOLD,
Color32::GRAY,
Color32::WHITE,
Color32::LIGHT_YELLOW,
Color32::LIGHT_GREEN,
// Color32::LIGHT_BLUE,
Color32::LIGHT_GRAY,
Color32::LIGHT_RED,
Color32::DARK_GRAY,
// Color32::DARK_RED,
Color32::KHAKI,
Color32::DARK_GREEN,
Color32::DARK_BLUE,
Color32::RED,
// Color32::GREEN,
// Color32::YELLOW,
// Color32::BLUE,
Color32::BROWN,
Color32::GOLD,
Color32::GRAY,
Color32::WHITE,
Color32::LIGHT_YELLOW,
Color32::LIGHT_GREEN,
// Color32::LIGHT_BLUE,
Color32::LIGHT_GRAY,
Color32::LIGHT_RED,
Color32::DARK_GRAY,
// Color32::DARK_RED,
Color32::KHAKI,
Color32::DARK_GREEN,
Color32::DARK_BLUE,
];
const_assert!(!COLORS.is_empty());

797
src/function_entry.rs
View File

@@ -1,479 +1,510 @@
use crate::math_app::AppSettings;
use crate::misc::{newtons_method_helper, step_helper, EguiHelper};
use crate::misc::{EguiHelper, newtons_method_helper, step_helper};
use egui::{Checkbox, Context};
use egui_plot::{Bar, BarChart, PlotPoint, PlotUi};
use epaint::Color32;
use parsing::{generate_hint, AutoComplete};
use parsing::{process_func_str, BackingFunction};
use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
use parsing::{AutoComplete, generate_hint};
use parsing::{BackingFunction, process_func_str};
use serde::{Deserialize, Deserializer, Serialize, Serializer, ser::SerializeStruct};
use std::{
fmt::{self, Debug},
hash::{Hash, Hasher},
fmt::{self, Debug},
hash::{Hash, Hasher},
};
/// Represents the possible variations of Riemann Sums
#[derive(PartialEq, Eq, Debug, Copy, Clone, Default)]
pub enum Riemann {
#[default]
Left,
#[default]
Left,
Middle,
Right,
Middle,
Right,
}
impl fmt::Display for Riemann {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self) }
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{:?}", self)
}
}
/// `FunctionEntry` is a function that can calculate values, integrals, derivatives, etc etc
#[derive(Clone)]
pub struct FunctionEntry {
/// The `BackingFunction` instance that is used to generate `f(x)`, `f'(x)`, and `f''(x)`
function: BackingFunction,
/// The `BackingFunction` instance that is used to generate `f(x)`, `f'(x)`, and `f''(x)`
function: BackingFunction,
/// Stores a function string (that hasn't been processed via `process_func_str`) to display to the user
pub raw_func_str: String,
/// Stores a function string (that hasn't been processed via `process_func_str`) to display to the user
pub raw_func_str: String,
/// If calculating/displayingintegrals are enabled
pub integral: bool,
/// If calculating/displayingintegrals are enabled
pub integral: bool,
/// If displaying derivatives are enabled (note, they are still calculated for other purposes)
pub derivative: bool,
/// If displaying derivatives are enabled (note, they are still calculated for other purposes)
pub derivative: bool,
pub nth_derviative: bool,
pub nth_derviative: bool,
pub back_data: Vec<PlotPoint>,
pub integral_data: Option<(Vec<Bar>, f64)>,
pub derivative_data: Vec<PlotPoint>,
pub extrema_data: Vec<PlotPoint>,
pub root_data: Vec<PlotPoint>,
nth_derivative_data: Option<Vec<PlotPoint>>,
pub back_data: Vec<PlotPoint>,
pub integral_data: Option<(Vec<Bar>, f64)>,
pub derivative_data: Vec<PlotPoint>,
pub extrema_data: Vec<PlotPoint>,
pub root_data: Vec<PlotPoint>,
nth_derivative_data: Option<Vec<PlotPoint>>,
pub autocomplete: AutoComplete<'static>,
pub autocomplete: AutoComplete<'static>,
test_result: Option<String>,
curr_nth: usize,
test_result: Option<String>,
curr_nth: usize,
pub settings_opened: bool,
pub settings_opened: bool,
}
impl Hash for FunctionEntry {
fn hash<H: Hasher>(&self, state: &mut H) {
self.raw_func_str.hash(state);
self.integral.hash(state);
self.nth_derviative.hash(state);
self.curr_nth.hash(state);
self.settings_opened.hash(state);
}
fn hash<H: Hasher>(&self, state: &mut H) {
self.raw_func_str.hash(state);
self.integral.hash(state);
self.nth_derviative.hash(state);
self.curr_nth.hash(state);
self.settings_opened.hash(state);
}
}
impl Serialize for FunctionEntry {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("FunctionEntry", 4)?;
s.serialize_field("raw_func_str", &self.raw_func_str)?;
s.serialize_field("integral", &self.integral)?;
s.serialize_field("derivative", &self.derivative)?;
s.serialize_field("curr_nth", &self.curr_nth)?;
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut s = serializer.serialize_struct("FunctionEntry", 4)?;
s.serialize_field("raw_func_str", &self.raw_func_str)?;
s.serialize_field("integral", &self.integral)?;
s.serialize_field("derivative", &self.derivative)?;
s.serialize_field("curr_nth", &self.curr_nth)?;
s.end()
}
s.end()
}
}
impl<'de> Deserialize<'de> for FunctionEntry {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
struct Helper {
raw_func_str: String,
integral: bool,
derivative: bool,
curr_nth: usize,
}
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
struct Helper {
raw_func_str: String,
integral: bool,
derivative: bool,
curr_nth: usize,
}
let helper = Helper::deserialize(deserializer)?;
let mut new_func_entry = FunctionEntry::default();
let gen_func = BackingFunction::new(&helper.raw_func_str);
match gen_func {
Ok(func) => new_func_entry.function = func,
Err(x) => new_func_entry.test_result = Some(x),
}
let helper = Helper::deserialize(deserializer)?;
let mut new_func_entry = FunctionEntry::default();
let gen_func = BackingFunction::new(&helper.raw_func_str);
match gen_func {
Ok(func) => new_func_entry.function = func,
Err(x) => new_func_entry.test_result = Some(x),
}
new_func_entry.autocomplete = AutoComplete {
i: 0,
hint: generate_hint(&helper.raw_func_str),
string: helper.raw_func_str,
};
new_func_entry.autocomplete = AutoComplete {
i: 0,
hint: generate_hint(&helper.raw_func_str),
string: helper.raw_func_str,
};
new_func_entry.integral = helper.integral;
new_func_entry.derivative = helper.derivative;
new_func_entry.curr_nth = helper.curr_nth;
new_func_entry.integral = helper.integral;
new_func_entry.derivative = helper.derivative;
new_func_entry.curr_nth = helper.curr_nth;
Ok(new_func_entry)
}
Ok(new_func_entry)
}
}
impl Default for FunctionEntry {
/// Creates default FunctionEntry instance (which is empty)
fn default() -> FunctionEntry {
FunctionEntry {
function: BackingFunction::default(),
raw_func_str: String::new(),
integral: false,
derivative: false,
nth_derviative: false,
back_data: Vec::new(),
integral_data: None,
derivative_data: Vec::new(),
extrema_data: Vec::new(),
root_data: Vec::new(),
nth_derivative_data: None,
autocomplete: AutoComplete::EMPTY,
test_result: None,
curr_nth: 3,
settings_opened: false,
}
}
/// Creates default FunctionEntry instance (which is empty)
fn default() -> FunctionEntry {
FunctionEntry {
function: BackingFunction::default(),
raw_func_str: String::new(),
integral: false,
derivative: false,
nth_derviative: false,
back_data: Vec::new(),
integral_data: None,
derivative_data: Vec::new(),
extrema_data: Vec::new(),
root_data: Vec::new(),
nth_derivative_data: None,
autocomplete: AutoComplete::EMPTY,
test_result: None,
curr_nth: 3,
settings_opened: false,
}
}
}
impl FunctionEntry {
pub const fn is_some(&self) -> bool { !self.function.is_none() }
pub const fn is_some(&self) -> bool {
!self.function.is_none()
}
pub fn settings_window(&mut self, ctx: &Context) {
let mut invalidate_nth = false;
egui::Window::new(format!("Settings: {}", self.raw_func_str))
.open(&mut self.settings_opened)
.default_pos([200.0, 200.0])
.resizable(false)
.collapsible(false)
.show(ctx, |ui| {
ui.add(Checkbox::new(
&mut self.nth_derviative,
"Display Nth Derivative",
));
pub fn settings_window(&mut self, ctx: &Context) {
let mut invalidate_nth = false;
egui::Window::new(format!("Settings: {}", self.raw_func_str))
.open(&mut self.settings_opened)
.default_pos([200.0, 200.0])
.resizable(false)
.collapsible(false)
.show(ctx, |ui| {
ui.add(Checkbox::new(
&mut self.nth_derviative,
"Display Nth Derivative",
));
if ui
.add(egui::Slider::new(&mut self.curr_nth, 3..=5).text("Nth Derivative"))
.changed()
{
invalidate_nth = true;
}
});
if ui
.add(egui::Slider::new(&mut self.curr_nth, 3..=5).text("Nth Derivative"))
.changed()
{
invalidate_nth = true;
}
});
if invalidate_nth {
self.function.generate_derivative(self.curr_nth);
self.clear_nth();
}
}
if invalidate_nth {
self.function.generate_derivative(self.curr_nth);
self.clear_nth();
}
}
/// Get function's cached test result
pub fn get_test_result(&self) -> &Option<String> { &self.test_result }
/// Get function's cached test result
pub fn get_test_result(&self) -> &Option<String> {
&self.test_result
}
/// Update function string and test it
pub fn update_string(&mut self, raw_func_str: &str) {
if raw_func_str == self.raw_func_str {
return;
}
/// Update function string and test it
pub fn update_string(&mut self, raw_func_str: &str) {
if raw_func_str == self.raw_func_str {
return;
}
self.raw_func_str = raw_func_str.to_owned();
let processed_func = process_func_str(raw_func_str);
let new_func_result = BackingFunction::new(&processed_func);
self.raw_func_str = raw_func_str.to_owned();
let processed_func = process_func_str(raw_func_str);
let new_func_result = BackingFunction::new(&processed_func);
match new_func_result {
Ok(new_function) => {
self.test_result = None;
self.function = new_function;
self.invalidate_whole();
}
Err(error) => {
self.test_result = Some(error);
}
}
}
match new_func_result {
Ok(new_function) => {
self.test_result = None;
self.function = new_function;
self.invalidate_whole();
}
Err(error) => {
self.test_result = Some(error);
}
}
}
/// Creates and does the math for creating all the rectangles under the graph
fn integral_rectangles(
&mut self, integral_min_x: f64, integral_max_x: f64, sum: Riemann, integral_num: usize,
) -> (Vec<(f64, f64)>, f64) {
let step = (integral_max_x - integral_min_x) / (integral_num as f64);
/// Creates and does the math for creating all the rectangles under the graph
fn integral_rectangles(
&mut self,
integral_min_x: f64,
integral_max_x: f64,
sum: Riemann,
integral_num: usize,
) -> (Vec<(f64, f64)>, f64) {
let step = (integral_max_x - integral_min_x) / (integral_num as f64);
// let sum_func = self.get_sum_func(sum);
// let sum_func = self.get_sum_func(sum);
let data2: Vec<(f64, f64)> = step_helper(integral_num, integral_min_x, step)
.into_iter()
.map(|x| {
let step_offset = step.copysign(x); // store the offset here so it doesn't have to be calculated multiple times
let x2: f64 = x + step_offset;
let data2: Vec<(f64, f64)> = step_helper(integral_num, integral_min_x, step)
.into_iter()
.map(|x| {
let step_offset = step.copysign(x); // store the offset here so it doesn't have to be calculated multiple times
let x2: f64 = x + step_offset;
let (left_x, right_x) = match x.is_sign_positive() {
true => (x, x2),
false => (x2, x),
};
let (left_x, right_x) = match x.is_sign_positive() {
true => (x, x2),
false => (x2, x),
};
let y = match sum {
Riemann::Left => self.function.get(0, left_x),
Riemann::Right => self.function.get(0, right_x),
Riemann::Middle => {
(self.function.get(0, left_x) + self.function.get(0, right_x)) / 2.0
}
};
let y = match sum {
Riemann::Left => self.function.get(0, left_x),
Riemann::Right => self.function.get(0, right_x),
Riemann::Middle => {
(self.function.get(0, left_x) + self.function.get(0, right_x)) / 2.0
}
};
(x + (step_offset / 2.0), y)
})
.filter(|(_, y)| y.is_finite())
.collect();
(x + (step_offset / 2.0), y)
})
.filter(|(_, y)| y.is_finite())
.collect();
let area = data2.iter().map(move |(_, y)| y * step).sum();
let area = data2.iter().map(move |(_, y)| y * step).sum();
(data2, area)
}
(data2, area)
}
/// Helps with processing newton's method depending on level of derivative
fn newtons_method_helper(
&mut self, threshold: f64, derivative_level: usize, range: &std::ops::Range<f64>,
) -> Vec<PlotPoint> {
self.function.generate_derivative(derivative_level);
self.function.generate_derivative(derivative_level + 1);
let newtons_method_output: Vec<f64> = match derivative_level {
0 => newtons_method_helper(
threshold,
range,
self.back_data.as_slice(),
&self.function.get_function_derivative(0),
&self.function.get_function_derivative(1),
),
1 => newtons_method_helper(
threshold,
range,
self.derivative_data.as_slice(),
&self.function.get_function_derivative(1),
&self.function.get_function_derivative(2),
),
_ => unreachable!(),
};
/// Helps with processing newton's method depending on level of derivative
fn newtons_method_helper(
&mut self,
threshold: f64,
derivative_level: usize,
range: &std::ops::Range<f64>,
) -> Vec<PlotPoint> {
self.function.generate_derivative(derivative_level);
self.function.generate_derivative(derivative_level + 1);
let newtons_method_output: Vec<f64> = match derivative_level {
0 => newtons_method_helper(
threshold,
range,
self.back_data.as_slice(),
self.function.get_function_derivative(0),
self.function.get_function_derivative(1),
),
1 => newtons_method_helper(
threshold,
range,
self.derivative_data.as_slice(),
self.function.get_function_derivative(1),
self.function.get_function_derivative(2),
),
_ => unreachable!(),
};
newtons_method_output
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
.collect()
}
newtons_method_output
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
.collect()
}
/// Does the calculations and stores results in `self`
pub fn calculate(
&mut self, width_changed: bool, min_max_changed: bool, did_zoom: bool,
settings: AppSettings,
) {
if self.test_result.is_some() | self.function.is_none() {
return;
}
/// Does the calculations and stores results in `self`
pub fn calculate(
&mut self,
width_changed: bool,
min_max_changed: bool,
did_zoom: bool,
settings: AppSettings,
) {
if self.test_result.is_some() | self.function.is_none() {
return;
}
let resolution = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
debug_assert!(resolution > 0.0);
let resolution_iter = step_helper(settings.plot_width + 1, settings.min_x, resolution);
let resolution = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
debug_assert!(resolution > 0.0);
let resolution_iter = step_helper(settings.plot_width + 1, settings.min_x, resolution);
// Makes sure proper arguments are passed when integral is enabled
if self.integral && settings.integral_changed {
self.clear_integral();
}
// Makes sure proper arguments are passed when integral is enabled
if self.integral && settings.integral_changed {
self.clear_integral();
}
if width_changed | min_max_changed | did_zoom {
self.clear_back();
self.clear_derivative();
self.clear_nth();
}
if width_changed | min_max_changed | did_zoom {
self.clear_back();
self.clear_derivative();
self.clear_nth();
}
if self.back_data.is_empty() {
let data: Vec<PlotPoint> = resolution_iter
.clone()
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
.collect();
debug_assert_eq!(data.len(), settings.plot_width + 1);
if self.back_data.is_empty() {
let data: Vec<PlotPoint> = resolution_iter
.clone()
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
.collect();
debug_assert_eq!(data.len(), settings.plot_width + 1);
self.back_data = data;
}
self.back_data = data;
}
if self.derivative_data.is_empty() {
self.function.generate_derivative(1);
let data: Vec<PlotPoint> = resolution_iter
.clone()
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(1, x)))
.collect();
debug_assert_eq!(data.len(), settings.plot_width + 1);
self.derivative_data = data;
}
if self.derivative_data.is_empty() {
self.function.generate_derivative(1);
let data: Vec<PlotPoint> = resolution_iter
.clone()
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(1, x)))
.collect();
debug_assert_eq!(data.len(), settings.plot_width + 1);
self.derivative_data = data;
}
if self.nth_derviative && self.nth_derivative_data.is_none() {
let data: Vec<PlotPoint> = resolution_iter
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(self.curr_nth, x)))
.collect();
debug_assert_eq!(data.len(), settings.plot_width + 1);
self.nth_derivative_data = Some(data);
}
if self.nth_derviative && self.nth_derivative_data.is_none() {
let data: Vec<PlotPoint> = resolution_iter
.into_iter()
.map(|x| PlotPoint::new(x, self.function.get(self.curr_nth, x)))
.collect();
debug_assert_eq!(data.len(), settings.plot_width + 1);
self.nth_derivative_data = Some(data);
}
if self.integral {
if self.integral_data.is_none() {
let (data, area) = self.integral_rectangles(
settings.integral_min_x,
settings.integral_max_x,
settings.riemann_sum,
settings.integral_num,
);
if self.integral {
if self.integral_data.is_none() {
let (data, area) = self.integral_rectangles(
settings.integral_min_x,
settings.integral_max_x,
settings.riemann_sum,
settings.integral_num,
);
self.integral_data = Some((
data.into_iter().map(|(x, y)| Bar::new(x, y)).collect(),
area,
));
}
} else {
self.clear_integral();
}
self.integral_data = Some((
data.into_iter().map(|(x, y)| Bar::new(x, y)).collect(),
area,
));
}
} else {
self.clear_integral();
}
let threshold: f64 = resolution / 2.0;
let x_range = settings.min_x..settings.max_x;
let threshold: f64 = resolution / 2.0;
let x_range = settings.min_x..settings.max_x;
// Calculates extrema
if settings.do_extrema && (min_max_changed | self.extrema_data.is_empty()) {
self.extrema_data = self.newtons_method_helper(threshold, 1, &x_range);
}
// Calculates extrema
if settings.do_extrema && (min_max_changed | self.extrema_data.is_empty()) {
self.extrema_data = self.newtons_method_helper(threshold, 1, &x_range);
}
// Calculates roots
if settings.do_roots && (min_max_changed | self.root_data.is_empty()) {
self.root_data = self.newtons_method_helper(threshold, 0, &x_range);
}
}
// Calculates roots
if settings.do_roots && (min_max_changed | self.root_data.is_empty()) {
self.root_data = self.newtons_method_helper(threshold, 0, &x_range);
}
}
/// Displays the function's output on PlotUI `plot_ui` with settings `settings`.
/// Returns an `Option<f64>` of the calculated integral.
pub fn display(
&self, plot_ui: &mut PlotUi, settings: &AppSettings, main_plot_color: Color32,
) -> Option<f64> {
if self.test_result.is_some() | self.function.is_none() {
return None;
}
/// Displays the function's output on PlotUI `plot_ui` with settings `settings`.
/// Returns an `Option<f64>` of the calculated integral.
pub fn display(
&self,
plot_ui: &mut PlotUi,
settings: &AppSettings,
main_plot_color: Color32,
) -> Option<f64> {
if self.test_result.is_some() | self.function.is_none() {
return None;
}
let integral_step =
(settings.integral_max_x - settings.integral_min_x) / (settings.integral_num as f64);
debug_assert!(integral_step > 0.0);
let integral_step =
(settings.integral_max_x - settings.integral_min_x) / (settings.integral_num as f64);
debug_assert!(integral_step > 0.0);
let step = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
debug_assert!(step > 0.0);
let step = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
debug_assert!(step > 0.0);
// Plot back data
if !self.back_data.is_empty() {
if self.integral && (step >= integral_step) {
plot_ui.line(
self.back_data
.iter()
.filter(|value| {
(value.x > settings.integral_min_x)
&& (settings.integral_max_x > value.x)
})
.cloned()
.collect::<Vec<PlotPoint>>()
.to_line()
.stroke(epaint::Stroke::NONE)
.color(Color32::from_rgb(4, 4, 255))
.fill(0.0),
);
}
plot_ui.line(
self.back_data
.clone()
.to_line()
.stroke(egui::Stroke::new(4.0, main_plot_color)),
);
}
// Plot back data
if !self.back_data.is_empty() {
if self.integral && (step >= integral_step) {
plot_ui.line(
self.back_data
.iter()
.filter(|value| {
(value.x > settings.integral_min_x)
&& (settings.integral_max_x > value.x)
})
.cloned()
.collect::<Vec<PlotPoint>>()
.to_line()
.stroke(epaint::Stroke::NONE)
.color(Color32::from_rgb(4, 4, 255))
.fill(0.0),
);
}
plot_ui.line(
self.back_data
.clone()
.to_line()
.stroke(egui::Stroke::new(4.0, main_plot_color)),
);
}
// Plot derivative data
if self.derivative && !self.derivative_data.is_empty() {
plot_ui.line(self.derivative_data.clone().to_line().color(Color32::GREEN));
}
// Plot derivative data
if self.derivative && !self.derivative_data.is_empty() {
plot_ui.line(self.derivative_data.clone().to_line().color(Color32::GREEN));
}
// Plot extrema points
if settings.do_extrema && !self.extrema_data.is_empty() {
plot_ui.points(
self.extrema_data
.clone()
.to_points()
.color(Color32::YELLOW)
.radius(5.0), // Radius of points of Extrema
);
}
// Plot extrema points
if settings.do_extrema && !self.extrema_data.is_empty() {
plot_ui.points(
self.extrema_data
.clone()
.to_points()
.color(Color32::YELLOW)
.radius(5.0), // Radius of points of Extrema
);
}
// Plot roots points
if settings.do_roots && !self.root_data.is_empty() {
plot_ui.points(
self.root_data
.clone()
.to_points()
.color(Color32::LIGHT_BLUE)
.radius(5.0), // Radius of points of Roots
);
}
// Plot roots points
if settings.do_roots && !self.root_data.is_empty() {
plot_ui.points(
self.root_data
.clone()
.to_points()
.color(Color32::LIGHT_BLUE)
.radius(5.0), // Radius of points of Roots
);
}
if self.nth_derviative
&& let Some(ref nth_derviative) = self.nth_derivative_data
{
plot_ui.line(nth_derviative.clone().to_line().color(Color32::DARK_RED));
}
if self.nth_derviative
&& let Some(ref nth_derviative) = self.nth_derivative_data
{
plot_ui.line(nth_derviative.clone().to_line().color(Color32::DARK_RED));
}
// Plot integral data
match &self.integral_data {
Some(integral_data) => {
if integral_step > step {
plot_ui.bar_chart(
BarChart::new(integral_data.0.clone())
.color(Color32::BLUE)
.width(integral_step),
);
}
// Plot integral data
match &self.integral_data {
Some(integral_data) => {
if integral_step > step {
plot_ui.bar_chart(
BarChart::new(integral_data.0.clone())
.color(Color32::BLUE)
.width(integral_step),
);
}
// return value rounded to 8 decimal places
Some(emath::round_to_decimals(integral_data.1, 8))
}
None => None,
}
}
// return value rounded to 8 decimal places
Some(emath::round_to_decimals(integral_data.1, 8))
}
None => None,
}
}
/// Invalidate entire cache
fn invalidate_whole(&mut self) {
self.clear_back();
self.clear_integral();
self.clear_derivative();
self.clear_nth();
self.clear_extrema();
self.clear_roots();
}
/// Invalidate entire cache
fn invalidate_whole(&mut self) {
self.clear_back();
self.clear_integral();
self.clear_derivative();
self.clear_nth();
self.clear_extrema();
self.clear_roots();
}
/// Invalidate `back` data
#[inline]
fn clear_back(&mut self) { self.back_data.clear(); }
/// Invalidate `back` data
#[inline]
fn clear_back(&mut self) {
self.back_data.clear();
}
/// Invalidate Integral data
#[inline]
fn clear_integral(&mut self) { self.integral_data = None; }
/// Invalidate Integral data
#[inline]
fn clear_integral(&mut self) {
self.integral_data = None;
}
/// Invalidate Derivative data
#[inline]
fn clear_derivative(&mut self) { self.derivative_data.clear(); }
/// Invalidate Derivative data
#[inline]
fn clear_derivative(&mut self) {
self.derivative_data.clear();
}
/// Invalidates `n`th derivative data
#[inline]
fn clear_nth(&mut self) { self.nth_derivative_data = None }
/// Invalidates `n`th derivative data
#[inline]
fn clear_nth(&mut self) {
self.nth_derivative_data = None
}
/// Invalidate extrema data
#[inline]
fn clear_extrema(&mut self) { self.extrema_data.clear() }
/// Invalidate extrema data
#[inline]
fn clear_extrema(&mut self) {
self.extrema_data.clear()
}
/// Invalidate root data
#[inline]
fn clear_roots(&mut self) { self.root_data.clear() }
/// Invalidate root data
#[inline]
fn clear_roots(&mut self) {
self.root_data.clear()
}
}

367
src/function_manager.rs
View File

@@ -1,8 +1,5 @@
use crate::{
consts::COLORS,
function_entry::FunctionEntry,
misc::{random_u64},
widgets::widgets_ontop,
consts::COLORS, function_entry::FunctionEntry, misc::random_u64, widgets::widgets_ontop,
};
use egui::{Button, Id, Key, Modifiers, TextEdit, WidgetText};
use emath::vec2;
@@ -15,21 +12,20 @@ use std::ops::BitXorAssign;
type Functions = Vec<(Id, FunctionEntry)>;
pub struct FunctionManager {
functions: Functions,
functions: Functions,
}
impl Default for FunctionManager {
fn default() -> Self {
let mut vec: Functions = Vec::with_capacity(COLORS.len());
vec.push((
Id::new(11414819524356497634 as u64), // Random number here to avoid call to crate::misc::random_u64()
FunctionEntry::default(),
));
Self { functions: vec }
}
fn default() -> Self {
let mut vec: Functions = Vec::with_capacity(COLORS.len());
vec.push((
Id::new(11414819524356497634_u64), // Random number here to avoid call to crate::misc::random_u64()
FunctionEntry::default(),
));
Self { functions: vec }
}
}
impl Serialize for FunctionManager {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
@@ -56,7 +52,7 @@ impl<'de> Deserialize<'de> for FunctionManager {
#[derive(Deserialize)]
struct Helper(Vec<(Id, FunctionEntry)>);
let helper = Helper::deserialize(deserializer)?;
let helper = Helper::deserialize(deserializer)?;
Ok(FunctionManager {
functions: helper.0.to_vec(),
@@ -66,207 +62,212 @@ impl<'de> Deserialize<'de> for FunctionManager {
/// Function that creates button that's used with the `button_area`
fn button_area_button<'a>(text: impl Into<WidgetText>) -> Button<'a> {
Button::new(text).frame(false)
Button::new(text).frame(false)
}
impl FunctionManager {
#[inline]
fn get_hash(&self) -> u64 {
let mut hasher = DefaultHasher::new();
self.functions.hash(&mut hasher);
hasher.finish()
}
#[inline]
fn get_hash(&self) -> u64 {
let mut hasher = DefaultHasher::new();
self.functions.hash(&mut hasher);
hasher.finish()
}
/// Displays function entries alongside returning whether or not functions have been modified
pub fn display_entries(&mut self, ui: &mut egui::Ui) -> bool {
let initial_hash = self.get_hash();
/// Displays function entries alongside returning whether or not functions have been modified
pub fn display_entries(&mut self, ui: &mut egui::Ui) -> bool {
let initial_hash = self.get_hash();
let can_remove = self.functions.len() > 1;
let can_remove = self.functions.len() > 1;
let available_width = ui.available_width();
let mut remove_i: Option<usize> = None;
let target_size = vec2(available_width, crate::consts::FONT_SIZE);
for (i, (te_id, function)) in self.functions.iter_mut().map(|(a, b)| (*a, b)).enumerate() {
let mut new_string = function.autocomplete.string.clone();
function.update_string(&new_string);
let available_width = ui.available_width();
let mut remove_i: Option<usize> = None;
let target_size = vec2(available_width, crate::consts::FONT_SIZE);
for (i, (te_id, function)) in self.functions.iter_mut().map(|(a, b)| (*a, b)).enumerate() {
let mut new_string = function.autocomplete.string.clone();
function.update_string(&new_string);
let mut movement: Movement = Movement::default();
let mut movement: Movement = Movement::default();
let size_multiplier = vec2(1.0, {
let had_focus = ui.memory(|x| x.has_focus(te_id));
(ui.ctx().animate_bool(te_id, had_focus) * 1.5) + 1.0
});
let size_multiplier = vec2(1.0, {
let had_focus = ui.memory(|x| x.has_focus(te_id));
(ui.ctx().animate_bool(te_id, had_focus) * 1.5) + 1.0
});
let re = ui.add_sized(
target_size * size_multiplier,
egui::TextEdit::singleline(&mut new_string)
.hint_forward(true) // Make the hint appear after the last text in the textbox
.lock_focus(true)
.id(te_id) // Set widget's id to `te_id`
.hint_text(
// If there's a single hint, go ahead and apply the hint here, if not, set the hint to an empty string
function.autocomplete.hint.single().unwrap_or(""),
),
);
let re = ui.add_sized(
target_size * size_multiplier,
egui::TextEdit::singleline(&mut new_string)
.hint_forward(true) // Make the hint appear after the last text in the textbox
.lock_focus(true)
.id(te_id) // Set widget's id to `te_id`
.hint_text(
// If there's a single hint, go ahead and apply the hint here, if not, set the hint to an empty string
function.autocomplete.hint.single().unwrap_or(""),
),
);
// Only keep valid chars
new_string.retain(crate::misc::is_valid_char);
// Only keep valid chars
new_string.retain(crate::misc::is_valid_char);
// If not fully open, return here as buttons cannot yet be displayed, therefore the user is inable to mark it for deletion
let animate_bool = ui.ctx().animate_bool(te_id, re.has_focus());
if animate_bool == 1.0 {
function.autocomplete.update_string(&new_string);
// If not fully open, return here as buttons cannot yet be displayed, therefore the user is inable to mark it for deletion
let animate_bool = ui.ctx().animate_bool(te_id, re.has_focus());
if animate_bool == 1.0 {
function.autocomplete.update_string(&new_string);
if function.autocomplete.hint.is_some() {
// only register up and down arrow movements if hint is type `Hint::Many`
if !function.autocomplete.hint.is_single() {
let (arrow_down, arrow_up) = ui.input(|x| {
(x.key_pressed(Key::ArrowDown), x.key_pressed(Key::ArrowUp))
});
if arrow_down {
movement = Movement::Down;
} else if arrow_up {
movement = Movement::Up;
}
}
if function.autocomplete.hint.is_some() {
// only register up and down arrow movements if hint is type `Hint::Many`
if !function.autocomplete.hint.is_single() {
let (arrow_down, arrow_up) = ui.input(|x| {
(x.key_pressed(Key::ArrowDown), x.key_pressed(Key::ArrowUp))
});
if arrow_down {
movement = Movement::Down;
} else if arrow_up {
movement = Movement::Up;
}
}
// Put here so these key presses don't interact with other elements
let movement_complete_action = ui.input_mut(|x| {
x.consume_key(Modifiers::NONE, Key::Enter)
| x.consume_key(Modifiers::NONE, Key::Tab)
| x.key_pressed(Key::ArrowRight)
});
// Put here so these key presses don't interact with other elements
let movement_complete_action = ui.input_mut(|x| {
x.consume_key(Modifiers::NONE, Key::Enter)
| x.consume_key(Modifiers::NONE, Key::Tab)
| x.key_pressed(Key::ArrowRight)
});
if movement_complete_action {
movement = Movement::Complete;
}
if movement_complete_action {
movement = Movement::Complete;
}
// Register movement and apply proper changes
function.autocomplete.register_movement(&movement);
// Register movement and apply proper changes
function.autocomplete.register_movement(&movement);
if movement != Movement::Complete
&& let Some(hints) = function.autocomplete.hint.many()
{
let mut clicked = false;
if movement != Movement::Complete
&& let Some(hints) = function.autocomplete.hint.many()
{
let mut clicked = false;
let autocomplete_popup_id = Id::new("autocomplete popup");
let autocomplete_popup_id = Id::new("autocomplete popup");
egui::popup_below_widget(ui, autocomplete_popup_id.clone(), &re, |ui| {
hints.iter().enumerate().for_each(|(i, candidate)| {
if ui
.selectable_label(i == function.autocomplete.i, *candidate)
.clicked()
{
clicked = true;
function.autocomplete.i = i;
}
});
});
egui::popup_below_widget(ui, autocomplete_popup_id, &re, |ui| {
hints.iter().enumerate().for_each(|(i, candidate)| {
if ui
.selectable_label(i == function.autocomplete.i, *candidate)
.clicked()
{
clicked = true;
function.autocomplete.i = i;
}
});
});
if clicked {
function
.autocomplete
.apply_hint(hints[function.autocomplete.i]);
if clicked {
function
.autocomplete
.apply_hint(hints[function.autocomplete.i]);
movement = Movement::Complete;
} else {
ui.memory_mut(|x| x.open_popup(autocomplete_popup_id.clone()));
}
}
movement = Movement::Complete;
} else {
ui.memory_mut(|x| x.open_popup(autocomplete_popup_id));
}
}
// Push cursor to end if needed
if movement == Movement::Complete {
let mut state =
unsafe { TextEdit::load_state(ui.ctx(), te_id).unwrap_unchecked() };
let ccursor = egui::text::CCursor::new(function.autocomplete.string.len());
state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
TextEdit::store_state(ui.ctx(), te_id, state);
}
}
// Push cursor to end if needed
if movement == Movement::Complete {
let mut state =
unsafe { TextEdit::load_state(ui.ctx(), te_id).unwrap_unchecked() };
let ccursor = egui::text::CCursor::new(function.autocomplete.string.len());
state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
TextEdit::store_state(ui.ctx(), te_id, state);
}
}
/// The y offset multiplier of the `buttons_area` area
const BUTTONS_Y_OFFSET: f32 = 1.32;
const Y_OFFSET: f32 = crate::consts::FONT_SIZE * BUTTONS_Y_OFFSET;
/// The y offset multiplier of the `buttons_area` area
const BUTTONS_Y_OFFSET: f32 = 1.32;
const Y_OFFSET: f32 = crate::consts::FONT_SIZE * BUTTONS_Y_OFFSET;
widgets_ontop(ui, Id::new(i), &re, Y_OFFSET, |ui| {
ui.horizontal(|ui| {
// There's more than 1 function! Functions can now be deleted
if ui
.add_enabled(can_remove, button_area_button("✖"))
.on_hover_text("Delete Function")
.clicked()
{
remove_i = Some(i);
}
widgets_ontop(ui, Id::new(i), &re, Y_OFFSET, |ui| {
ui.horizontal(|ui| {
// There's more than 1 function! Functions can now be deleted
if ui
.add_enabled(can_remove, button_area_button("✖"))
.on_hover_text("Delete Function")
.clicked()
{
remove_i = Some(i);
}
ui.add_enabled_ui(function.is_some(), |ui| {
// Toggle integral being enabled or not
function.integral.bitxor_assign(
ui.add(button_area_button("∫"))
.on_hover_text(match function.integral {
true => "Don't integrate",
false => "Integrate",
})
.clicked(),
);
ui.add_enabled_ui(function.is_some(), |ui| {
// Toggle integral being enabled or not
function.integral.bitxor_assign(
ui.add(button_area_button("∫"))
.on_hover_text(match function.integral {
true => "Don't integrate",
false => "Integrate",
})
.clicked(),
);
// Toggle showing the derivative (even though it's already calculated this option just toggles if it's displayed or not)
function.derivative.bitxor_assign(
ui.add(button_area_button("d/dx"))
.on_hover_text(match function.derivative {
true => "Don't Differentiate",
false => "Differentiate",
})
.clicked(),
);
// Toggle showing the derivative (even though it's already calculated this option just toggles if it's displayed or not)
function.derivative.bitxor_assign(
ui.add(button_area_button("d/dx"))
.on_hover_text(match function.derivative {
true => "Don't Differentiate",
false => "Differentiate",
})
.clicked(),
);
// Toggle showing the settings window
function.settings_opened.bitxor_assign(
ui.add(button_area_button("⚙"))
.on_hover_text(match function.settings_opened {
true => "Close Settings",
false => "Open Settings",
})
.clicked(),
);
});
});
});
}
// Toggle showing the settings window
function.settings_opened.bitxor_assign(
ui.add(button_area_button("⚙"))
.on_hover_text(match function.settings_opened {
true => "Close Settings",
false => "Open Settings",
})
.clicked(),
);
});
});
});
}
function.settings_window(ui.ctx());
}
function.settings_window(ui.ctx());
}
// Remove function if the user requests it
if let Some(remove_i_unwrap) = remove_i {
self.functions.remove(remove_i_unwrap);
}
// Remove function if the user requests it
if let Some(remove_i_unwrap) = remove_i {
self.functions.remove(remove_i_unwrap);
}
let final_hash = self.get_hash();
let final_hash = self.get_hash();
initial_hash != final_hash
}
initial_hash != final_hash
}
/// Create and push new empty function entry
pub fn push_empty(&mut self) {
self.functions.push((
Id::new(random_u64().expect("unable to generate random id")),
FunctionEntry::default(),
));
}
/// Create and push new empty function entry
pub fn push_empty(&mut self) {
self.functions.push((
Id::new(random_u64().expect("unable to generate random id")),
FunctionEntry::default(),
));
}
/// Detect if any functions are using integrals
pub fn any_using_integral(&self) -> bool {
self.functions.iter().any(|(_, func)| func.integral)
}
/// Detect if any functions are using integrals
pub fn any_using_integral(&self) -> bool {
self.functions.iter().any(|(_, func)| func.integral)
}
#[inline]
pub fn len(&self) -> usize { self.functions.len() }
#[inline]
pub fn len(&self) -> usize {
self.functions.len()
}
#[inline]
pub fn get_entries_mut(&mut self) -> &mut Functions {
&mut self.functions
}
#[inline]
pub fn get_entries_mut(&mut self) -> &mut Functions { &mut self.functions }
#[inline]
pub fn get_entries(&self) -> &Functions { &self.functions }
#[inline]
pub fn get_entries(&self) -> &Functions {
&self.functions
}
}

100
src/lib.rs
View File

@@ -10,65 +10,65 @@ mod unicode_helper;
mod widgets;
pub use crate::{
function_entry::{FunctionEntry, Riemann},
math_app::AppSettings,
misc::{
hashed_storage_create, hashed_storage_read, newtons_method, option_vec_printer,
step_helper, EguiHelper, HashBytes,
},
unicode_helper::{to_chars_array, to_unicode_hash},
function_entry::{FunctionEntry, Riemann},
math_app::AppSettings,
misc::{
EguiHelper, HashBytes, hashed_storage_create, hashed_storage_read, newtons_method,
option_vec_printer, step_helper,
},
unicode_helper::{to_chars_array, to_unicode_hash},
};
cfg_if::cfg_if! {
if #[cfg(target_arch = "wasm32")] {
use wasm_bindgen::prelude::*;
if #[cfg(target_arch = "wasm32")] {
use wasm_bindgen::prelude::*;
use lol_alloc::{FreeListAllocator, LockedAllocator};
#[global_allocator]
static ALLOCATOR: LockedAllocator<FreeListAllocator> = LockedAllocator::new(FreeListAllocator::new());
use lol_alloc::{FreeListAllocator, LockedAllocator};
#[global_allocator]
static ALLOCATOR: LockedAllocator<FreeListAllocator> = LockedAllocator::new(FreeListAllocator::new());
use eframe::WebRunner;
// use tracing::metadata::LevelFilter;
#[derive(Clone)]
#[wasm_bindgen]
pub struct WebHandle {
runner: WebRunner,
}
use eframe::WebRunner;
// use tracing::metadata::LevelFilter;
#[derive(Clone)]
#[wasm_bindgen]
pub struct WebHandle {
runner: WebRunner,
}
#[wasm_bindgen]
impl WebHandle {
/// Installs a panic hook, then returns.
#[allow(clippy::new_without_default)]
#[wasm_bindgen(constructor)]
pub fn new() -> Self {
// eframe::WebLogger::init(LevelFilter::Debug).ok();
tracing_wasm::set_as_global_default();
#[wasm_bindgen]
impl WebHandle {
/// Installs a panic hook, then returns.
#[allow(clippy::new_without_default)]
#[wasm_bindgen(constructor)]
pub fn new() -> Self {
// eframe::WebLogger::init(LevelFilter::Debug).ok();
tracing_wasm::set_as_global_default();
Self {
runner: WebRunner::new(),
}
}
Self {
runner: WebRunner::new(),
}
}
/// Call this once from JavaScript to start your app.
#[wasm_bindgen]
pub async fn start(&self, canvas_id: &str) -> Result<(), wasm_bindgen::JsValue> {
self.runner
.start(
canvas_id,
eframe::WebOptions::default(),
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
)
.await
}
}
/// Call this once from JavaScript to start your app.
#[wasm_bindgen]
pub async fn start(&self, canvas_id: &str) -> Result<(), wasm_bindgen::JsValue> {
self.runner
.start(
canvas_id,
eframe::WebOptions::default(),
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
)
.await
}
}
#[wasm_bindgen(start)]
pub async fn start() {
tracing::info!("Starting...");
#[wasm_bindgen(start)]
pub async fn start() {
tracing::info!("Starting...");
let web_handle = WebHandle::new();
web_handle.start("canvas").await.unwrap()
}
}
let web_handle = WebHandle::new();
web_handle.start("canvas").await.unwrap()
}
}
}

18
src/main.rs
View File

@@ -12,15 +12,15 @@ mod widgets;
// For running the program natively! (Because why not?)
#[cfg(not(target_arch = "wasm32"))]
fn main() -> eframe::Result<()> {
let subscriber = tracing_subscriber::FmtSubscriber::builder()
.with_max_level(tracing::Level::INFO)
.finish();
let subscriber = tracing_subscriber::FmtSubscriber::builder()
.with_max_level(tracing::Level::INFO)
.finish();
tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
eframe::run_native(
"(Yet-to-be-named) Graphing Software",
eframe::NativeOptions::default(),
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
)
eframe::run_native(
"(Yet-to-be-named) Graphing Software",
eframe::NativeOptions::default(),
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
)
}

929
src/math_app.rs
View File

File diff suppressed because it is too large Load Diff

230
src/misc.rs
View File

@@ -1,4 +1,4 @@
use base64::{engine::general_purpose, Engine as _};
use base64::{Engine as _, engine::general_purpose};
use egui_plot::{Line, PlotPoint, PlotPoints, Points};
use emath::Pos2;
use getrandom::getrandom;
@@ -7,69 +7,69 @@ use parsing::FlatExWrapper;
/// Implements traits that are useful when dealing with Vectors of egui's `Value`
pub trait EguiHelper {
/// Converts to `egui::plot::Values`
fn to_values(self) -> PlotPoints;
/// Converts to `egui::plot::Values`
fn to_values(self) -> PlotPoints;
/// Converts to `egui::plot::Line`
fn to_line(self) -> Line;
/// Converts to `egui::plot::Line`
fn to_line(self) -> Line;
/// Converts to `egui::plot::Points`
fn to_points(self) -> Points;
/// Converts to `egui::plot::Points`
fn to_points(self) -> Points;
/// Converts Vector of Values into vector of tuples
fn to_tuple(self) -> Vec<(f64, f64)>;
/// Converts Vector of Values into vector of tuples
fn to_tuple(self) -> Vec<(f64, f64)>;
}
impl EguiHelper for Vec<PlotPoint> {
#[inline(always)]
fn to_values(self) -> PlotPoints {
PlotPoints::from(unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<[f64; 2]>>(self) })
}
#[inline(always)]
fn to_values(self) -> PlotPoints {
PlotPoints::from(unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<[f64; 2]>>(self) })
}
#[inline(always)]
fn to_line(self) -> Line {
Line::new(self.to_values())
}
#[inline(always)]
fn to_line(self) -> Line {
Line::new(self.to_values())
}
#[inline(always)]
fn to_points(self) -> Points {
Points::new(self.to_values())
}
#[inline(always)]
fn to_points(self) -> Points {
Points::new(self.to_values())
}
#[inline(always)]
fn to_tuple(self) -> Vec<(f64, f64)> {
unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<(f64, f64)>>(self) }
}
#[inline(always)]
fn to_tuple(self) -> Vec<(f64, f64)> {
unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<(f64, f64)>>(self) }
}
}
pub trait Offset {
fn offset_y(self, y_offset: f32) -> Pos2;
fn offset_x(self, x_offset: f32) -> Pos2;
fn offset_y(self, y_offset: f32) -> Pos2;
fn offset_x(self, x_offset: f32) -> Pos2;
}
impl Offset for Pos2 {
fn offset_y(self, y_offset: f32) -> Pos2 {
Pos2 {
x: self.x,
y: self.y + y_offset,
}
}
fn offset_y(self, y_offset: f32) -> Pos2 {
Pos2 {
x: self.x,
y: self.y + y_offset,
}
}
fn offset_x(self, x_offset: f32) -> Pos2 {
Pos2 {
x: self.x + x_offset,
y: self.y,
}
}
fn offset_x(self, x_offset: f32) -> Pos2 {
Pos2 {
x: self.x + x_offset,
y: self.y,
}
}
}
/*
/// Rounds f64 to `n` decimal places
pub fn decimal_round(x: f64, n: usize) -> f64 {
let large_number: f64 = 10.0_f64.powf(n as f64); // 10^n
let large_number: f64 = 10.0_f64.powf(n as f64); // 10^n
// round and devide in order to cutoff after the `n`th decimal place
(x * large_number).round() / large_number
// round and devide in order to cutoff after the `n`th decimal place
(x * large_number).round() / large_number
}
*/
@@ -80,18 +80,21 @@ pub fn decimal_round(x: f64, n: usize) -> f64 {
/// `f_1` is f'(x) aka the derivative of f(x)
/// The function returns a Vector of `x` values where roots occur
pub fn newtons_method_helper(
threshold: f64, range: &std::ops::Range<f64>, data: &[PlotPoint], f: &FlatExWrapper,
f_1: &FlatExWrapper,
threshold: f64,
range: &std::ops::Range<f64>,
data: &[PlotPoint],
f: &FlatExWrapper,
f_1: &FlatExWrapper,
) -> Vec<f64> {
data.iter()
.tuple_windows()
.filter(|(prev, curr)| prev.y.is_finite() && curr.y.is_finite())
.filter(|(prev, curr)| prev.y.signum() != curr.y.signum())
.map(|(start, _)| start.x)
.map(|x| newtons_method(f, f_1, x, range, threshold))
.filter(|x| x.is_some())
.map(|x| unsafe { x.unwrap_unchecked() })
.collect()
data.iter()
.tuple_windows()
.filter(|(prev, curr)| prev.y.is_finite() && curr.y.is_finite())
.filter(|(prev, curr)| prev.y.signum() != curr.y.signum())
.map(|(start, _)| start.x)
.map(|x| newtons_method(f, f_1, x, range, threshold))
.filter(|x| x.is_some())
.map(|x| unsafe { x.unwrap_unchecked() })
.collect()
}
/// `range` is the range of valid x values (used to stop calculation when
@@ -99,64 +102,67 @@ pub fn newtons_method_helper(
/// `f_1` is f'(x) aka the derivative of f(x)
/// The function returns an `Option<f64>` of the x value at which a root occurs
pub fn newtons_method(
f: &FlatExWrapper, f_1: &FlatExWrapper, start_x: f64, range: &std::ops::Range<f64>,
threshold: f64,
f: &FlatExWrapper,
f_1: &FlatExWrapper,
start_x: f64,
range: &std::ops::Range<f64>,
threshold: f64,
) -> Option<f64> {
let mut x1: f64 = start_x;
let mut x2: f64;
let mut derivative: f64;
loop {
derivative = f_1.eval(&[x1]);
if !derivative.is_finite() {
return None;
}
let mut x1: f64 = start_x;
let mut x2: f64;
let mut derivative: f64;
loop {
derivative = f_1.eval(&[x1]);
if !derivative.is_finite() {
return None;
}
x2 = x1 - (f.eval(&[x1]) / derivative);
if !x2.is_finite() | !range.contains(&x2) {
return None;
}
x2 = x1 - (f.eval(&[x1]) / derivative);
if !x2.is_finite() | !range.contains(&x2) {
return None;
}
// If below threshold, break
if (x2 - x1).abs() < threshold {
return Some(x2);
}
// If below threshold, break
if (x2 - x1).abs() < threshold {
return Some(x2);
}
x1 = x2;
}
x1 = x2;
}
}
/// Inputs `Vec<Option<T>>` and outputs a `String` containing a pretty representation of the Vector
pub fn option_vec_printer<T: ToString>(data: &[Option<T>]) -> String {
let formatted: String = data
.iter()
.map(|item| match item {
Some(x) => x.to_string(),
None => "None".to_owned(),
})
.join(", ");
let formatted: String = data
.iter()
.map(|item| match item {
Some(x) => x.to_string(),
None => "None".to_owned(),
})
.join(", ");
format!("[{}]", formatted)
format!("[{}]", formatted)
}
/// Returns a vector of length `max_i` starting at value `min_x` with step of `step`
pub fn step_helper(max_i: usize, min_x: f64, step: f64) -> Vec<f64> {
(0..max_i)
.map(move |x: usize| (x as f64 * step) + min_x)
.collect()
(0..max_i)
.map(move |x: usize| (x as f64 * step) + min_x)
.collect()
}
// TODO: use in hovering over points
/// Attempts to see what variable `x` is almost
#[allow(dead_code)]
pub fn almost_variable(x: f64) -> Option<char> {
const EPSILON: f32 = f32::EPSILON * 2.0;
if emath::almost_equal(x as f32, std::f32::consts::E, EPSILON) {
Some('e')
} else if emath::almost_equal(x as f32, std::f32::consts::PI, EPSILON) {
Some('π')
} else {
None
}
const EPSILON: f32 = f32::EPSILON * 2.0;
if emath::almost_equal(x as f32, std::f32::consts::E, EPSILON) {
Some('e')
} else if emath::almost_equal(x as f32, std::f32::consts::PI, EPSILON) {
Some('π')
} else {
None
}
}
pub const HASH_LENGTH: usize = 8;
@@ -166,41 +172,41 @@ pub type HashBytes = [u8; HASH_LENGTH];
#[allow(dead_code)]
pub fn hashed_storage_create(hashbytes: HashBytes, data: &[u8]) -> String {
let combined_data = [hashbytes.to_vec(), data.to_vec()].concat();
general_purpose::STANDARD.encode(combined_data)
let combined_data = [hashbytes.to_vec(), data.to_vec()].concat();
general_purpose::STANDARD.encode(combined_data)
}
#[allow(dead_code)]
pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, Vec<u8>)> {
// Decode base64 data
let decoded_bytes = general_purpose::STANDARD.decode(data).ok()?;
// Decode base64 data
let decoded_bytes = general_purpose::STANDARD.decode(data).ok()?;
// Make sure data is long enough to decode
if HASH_LENGTH > decoded_bytes.len() {
return None;
}
// Make sure data is long enough to decode
if HASH_LENGTH > decoded_bytes.len() {
return None;
}
// Split hash and data
let (hash_bytes, data_bytes) = decoded_bytes.split_at(HASH_LENGTH);
// Split hash and data
let (hash_bytes, data_bytes) = decoded_bytes.split_at(HASH_LENGTH);
// Convert hash bytes to HashBytes
let hash: HashBytes = hash_bytes.try_into().ok()?;
// Convert hash bytes to HashBytes
let hash: HashBytes = hash_bytes.try_into().ok()?;
Some((hash, data_bytes.to_vec()))
Some((hash, data_bytes.to_vec()))
}
/// Creates and returns random u64
pub fn random_u64() -> Result<u64, getrandom::Error> {
// Buffer of 8 `u8`s that are later merged into one u64
let mut buf = [0u8; 8];
// Populate buffer with random values
getrandom(&mut buf)?;
// Merge buffer into u64
Ok(u64::from_be_bytes(buf))
// Buffer of 8 `u8`s that are later merged into one u64
let mut buf = [0u8; 8];
// Populate buffer with random values
getrandom(&mut buf)?;
// Merge buffer into u64
Ok(u64::from_be_bytes(buf))
}
include!(concat!(env!("OUT_DIR"), "/valid_chars.rs"));
pub fn is_valid_char(c: char) -> bool {
c.is_alphanumeric() | VALID_EXTRA_CHARS.contains(&c)
c.is_alphanumeric() | VALID_EXTRA_CHARS.contains(&c)
}

22
src/unicode_helper.rs
View File

@@ -2,19 +2,19 @@ use itertools::Itertools;
#[allow(dead_code)]
pub fn to_unicode_hash(c: char) -> String {
c.escape_unicode()
.to_string()
.replace(r"\\u{", "")
.replace(['{', '}'], "")
.to_uppercase()
c.escape_unicode()
.to_string()
.replace(r"\\u{", "")
.replace(['{', '}'], "")
.to_uppercase()
}
#[allow(dead_code)]
pub fn to_chars_array(chars: Vec<char>) -> String {
"[".to_string()
+ &chars
.iter()
.map(|c| format!("'{}'", c.escape_unicode()))
.join(", ")
+ "]"
"[".to_string()
+ &chars
.iter()
.map(|c| format!("'{}'", c.escape_unicode()))
.join(", ")
+ "]"
}

15
src/widgets.rs
View File

@@ -3,12 +3,15 @@ use egui::{Id, InnerResponse};
/// Creates an area ontop of a widget with an y offset
pub fn widgets_ontop<R>(
ui: &egui::Ui, id: Id, re: &egui::Response, y_offset: f32,
add_contents: impl FnOnce(&mut egui::Ui) -> R,
ui: &egui::Ui,
id: Id,
re: &egui::Response,
y_offset: f32,
add_contents: impl FnOnce(&mut egui::Ui) -> R,
) -> InnerResponse<R> {
let area = egui::Area::new(id)
.fixed_pos(re.rect.min.offset_y(y_offset))
.order(egui::Order::Foreground);
let area = egui::Area::new(id)
.fixed_pos(re.rect.min.offset_y(y_offset))
.order(egui::Order::Foreground);
area.show(ui.ctx(), |ui| add_contents(ui))
area.show(ui.ctx(), |ui| add_contents(ui))
}