cargo clippy + fmt
This commit is contained in:
parent
5a92020dae
commit
aa07631296
GPG Key ID:
9AB28AC10ECE533D
@ -1,4 +0,0 @@
|
|||||||
edition = "2021"
|
|
||||||
fn_params_layout = "Compressed"
|
|
||||||
fn_single_line = true
|
|
||||||
hard_tabs = true
|
|
||||||
270
build.rs
270
build.rs
@ -1,171 +1,171 @@
|
|||||||
use std::{
|
use std::{
|
||||||
collections::BTreeMap,
|
collections::BTreeMap,
|
||||||
env,
|
env,
|
||||||
fs::File,
|
fs::File,
|
||||||
io::{BufWriter, Write},
|
io::{BufWriter, Write},
|
||||||
path::Path,
|
path::Path,
|
||||||
};
|
};
|
||||||
|
|
||||||
use epaint::{
|
use epaint::{
|
||||||
text::{FontData, FontDefinitions, FontTweak},
|
FontFamily,
|
||||||
FontFamily,
|
text::{FontData, FontDefinitions, FontTweak},
|
||||||
};
|
};
|
||||||
|
|
||||||
use run_script::ScriptOptions;
|
use run_script::ScriptOptions;
|
||||||
|
|
||||||
include!(concat!(
|
include!(concat!(
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
env!("CARGO_MANIFEST_DIR"),
|
||||||
"/src/unicode_helper.rs"
|
"/src/unicode_helper.rs"
|
||||||
));
|
));
|
||||||
|
|
||||||
fn font_stripper(from: &str, out: &str, unicodes: Vec<char>) -> Result<Vec<u8>, String> {
|
fn font_stripper(from: &str, out: &str, unicodes: Vec<char>) -> Result<Vec<u8>, String> {
|
||||||
let unicodes: Vec<String> = unicodes.iter().map(|c| to_unicode_hash(*c)).collect();
|
let unicodes: Vec<String> = unicodes.iter().map(|c| to_unicode_hash(*c)).collect();
|
||||||
|
|
||||||
let new_path = [&env::var("OUT_DIR").unwrap(), out].concat();
|
let new_path = [&env::var("OUT_DIR").unwrap(), out].concat();
|
||||||
let unicodes_formatted = unicodes
|
let unicodes_formatted = unicodes
|
||||||
.iter()
|
.iter()
|
||||||
.map(|u| format!("U+{}", u))
|
.map(|u| format!("U+{}", u))
|
||||||
.collect::<Vec<String>>()
|
.collect::<Vec<String>>()
|
||||||
.join(",");
|
.join(",");
|
||||||
|
|
||||||
// Test to see if pyftsubset is found
|
// Test to see if pyftsubset is found
|
||||||
let pyftsubset_detect = run_script::run("whereis pyftsubset", &(vec![]), &ScriptOptions::new());
|
let pyftsubset_detect = run_script::run("whereis pyftsubset", &(vec![]), &ScriptOptions::new());
|
||||||
match pyftsubset_detect {
|
match pyftsubset_detect {
|
||||||
Ok((_i, s1, _s2)) => {
|
Ok((_i, s1, _s2)) => {
|
||||||
if s1 == "pyftsubset: " {
|
if s1 == "pyftsubset: " {
|
||||||
return Err(String::from("pyftsubset not found"));
|
return Err(String::from("pyftsubset not found"));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// It was not, return an error and abort
|
// It was not, return an error and abort
|
||||||
Err(x) => return Err(x.to_string()),
|
Err(x) => return Err(x.to_string()),
|
||||||
}
|
}
|
||||||
|
|
||||||
let script_result = run_script::run(
|
let script_result = run_script::run(
|
||||||
&format!(
|
&format!(
|
||||||
"pyftsubset {}/assets/{} --unicodes={}
|
"pyftsubset {}/assets/{} --unicodes={}
|
||||||
mv {}/assets/{} {}",
|
mv {}/assets/{} {}",
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
env!("CARGO_MANIFEST_DIR"),
|
||||||
from,
|
from,
|
||||||
unicodes_formatted,
|
unicodes_formatted,
|
||||||
env!("CARGO_MANIFEST_DIR"),
|
env!("CARGO_MANIFEST_DIR"),
|
||||||
from.replace(".ttf", ".subset.ttf"),
|
from.replace(".ttf", ".subset.ttf"),
|
||||||
new_path
|
new_path
|
||||||
),
|
),
|
||||||
&(vec![]),
|
&(vec![]),
|
||||||
&ScriptOptions::new(),
|
&ScriptOptions::new(),
|
||||||
);
|
);
|
||||||
|
|
||||||
if let Ok((_, _, error)) = script_result {
|
if let Ok((_, _, error)) = script_result {
|
||||||
if error.is_empty() {
|
if error.is_empty() {
|
||||||
return Ok(std::fs::read(new_path).unwrap());
|
return Ok(std::fs::read(new_path).unwrap());
|
||||||
} else {
|
} else {
|
||||||
return Err(error);
|
return Err(error);
|
||||||
}
|
}
|
||||||
} else if let Err(error) = script_result {
|
} else if let Err(error) = script_result {
|
||||||
return Err(error.to_string());
|
return Err(error.to_string());
|
||||||
}
|
}
|
||||||
unreachable!()
|
unreachable!()
|
||||||
}
|
}
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
// rebuild if new commit or contents of `assets` folder changed
|
// rebuild if new commit or contents of `assets` folder changed
|
||||||
println!("cargo:rerun-if-changed=.git/logs/HEAD");
|
println!("cargo:rerun-if-changed=.git/logs/HEAD");
|
||||||
println!("cargo:rerun-if-changed=assets/*");
|
println!("cargo:rerun-if-changed=assets/*");
|
||||||
|
|
||||||
shadow_rs::new().expect("Could not initialize shadow_rs");
|
shadow_rs::new().expect("Could not initialize shadow_rs");
|
||||||
|
|
||||||
let mut main_chars: Vec<char> =
|
let mut main_chars: Vec<char> =
|
||||||
b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzsu0123456789?.,!(){}[]-_=+-/<>'\\ :^*`@#$%&|~;"
|
b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzsu0123456789?.,!(){}[]-_=+-/<>'\\ :^*`@#$%&|~;"
|
||||||
.iter()
|
.iter()
|
||||||
.map(|c| *c as char)
|
.map(|c| *c as char)
|
||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
main_chars.append(&mut vec!['π', '"']);
|
main_chars.append(&mut vec!['π', '"']);
|
||||||
|
|
||||||
{
|
{
|
||||||
let filtered_chars: Vec<char> = main_chars
|
let filtered_chars: Vec<char> = main_chars
|
||||||
.iter()
|
.iter()
|
||||||
.filter(|c| !c.is_alphanumeric())
|
.filter(|c| !c.is_alphanumeric())
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect();
|
.collect();
|
||||||
|
|
||||||
let chars_array = format!(
|
let chars_array = format!(
|
||||||
"const VALID_EXTRA_CHARS: [char; {}] = {};",
|
"const VALID_EXTRA_CHARS: [char; {}] = {};",
|
||||||
filtered_chars.len(),
|
filtered_chars.len(),
|
||||||
to_chars_array(filtered_chars),
|
to_chars_array(filtered_chars),
|
||||||
);
|
);
|
||||||
let path = Path::new(&env::var("OUT_DIR").unwrap()).join("valid_chars.rs");
|
let path = Path::new(&env::var("OUT_DIR").unwrap()).join("valid_chars.rs");
|
||||||
let mut file = BufWriter::new(File::create(path).expect("Could not save compressed_data"));
|
let mut file = BufWriter::new(File::create(path).expect("Could not save compressed_data"));
|
||||||
|
|
||||||
write!(&mut file, "{}", chars_array).expect("unable to write chars_array");
|
write!(&mut file, "{}", chars_array).expect("unable to write chars_array");
|
||||||
}
|
}
|
||||||
|
|
||||||
let fonts = FontDefinitions {
|
let fonts = FontDefinitions {
|
||||||
font_data: BTreeMap::from([
|
font_data: BTreeMap::from([
|
||||||
(
|
(
|
||||||
"Ubuntu-Light".to_owned(),
|
"Ubuntu-Light".to_owned(),
|
||||||
FontData::from_owned(
|
FontData::from_owned(
|
||||||
font_stripper(
|
font_stripper(
|
||||||
"Ubuntu-Light.ttf",
|
"Ubuntu-Light.ttf",
|
||||||
"ubuntu-light.ttf",
|
"ubuntu-light.ttf",
|
||||||
[main_chars, vec!['∫']].concat(),
|
[main_chars, vec!['∫']].concat(),
|
||||||
)
|
)
|
||||||
.unwrap(),
|
.unwrap(),
|
||||||
),
|
),
|
||||||
),
|
),
|
||||||
(
|
(
|
||||||
"NotoEmoji-Regular".to_owned(),
|
"NotoEmoji-Regular".to_owned(),
|
||||||
FontData::from_owned(
|
FontData::from_owned(
|
||||||
font_stripper(
|
font_stripper(
|
||||||
"NotoEmoji-Regular.ttf",
|
"NotoEmoji-Regular.ttf",
|
||||||
"noto-emoji.ttf",
|
"noto-emoji.ttf",
|
||||||
vec!['🌞', '🌙', '✖'],
|
vec!['🌞', '🌙', '✖'],
|
||||||
)
|
)
|
||||||
.unwrap(),
|
.unwrap(),
|
||||||
),
|
),
|
||||||
),
|
),
|
||||||
(
|
(
|
||||||
"emoji-icon-font".to_owned(),
|
"emoji-icon-font".to_owned(),
|
||||||
FontData::from_owned(
|
FontData::from_owned(
|
||||||
font_stripper("emoji-icon-font.ttf", "emoji-icon.ttf", vec!['⚙']).unwrap(),
|
font_stripper("emoji-icon-font.ttf", "emoji-icon.ttf", vec!['⚙']).unwrap(),
|
||||||
)
|
)
|
||||||
.tweak(FontTweak {
|
.tweak(FontTweak {
|
||||||
scale: 0.8,
|
scale: 0.8,
|
||||||
y_offset_factor: 0.07,
|
y_offset_factor: 0.07,
|
||||||
y_offset: 0.0,
|
y_offset: 0.0,
|
||||||
baseline_offset_factor: -0.0333,
|
baseline_offset_factor: -0.0333,
|
||||||
}),
|
}),
|
||||||
),
|
),
|
||||||
]),
|
]),
|
||||||
families: BTreeMap::from([
|
families: BTreeMap::from([
|
||||||
(
|
(
|
||||||
FontFamily::Monospace,
|
FontFamily::Monospace,
|
||||||
vec![
|
vec![
|
||||||
"Ubuntu-Light".to_owned(),
|
"Ubuntu-Light".to_owned(),
|
||||||
"NotoEmoji-Regular".to_owned(),
|
"NotoEmoji-Regular".to_owned(),
|
||||||
"emoji-icon-font".to_owned(),
|
"emoji-icon-font".to_owned(),
|
||||||
],
|
],
|
||||||
),
|
),
|
||||||
(
|
(
|
||||||
FontFamily::Proportional,
|
FontFamily::Proportional,
|
||||||
vec![
|
vec![
|
||||||
"Ubuntu-Light".to_owned(),
|
"Ubuntu-Light".to_owned(),
|
||||||
"NotoEmoji-Regular".to_owned(),
|
"NotoEmoji-Regular".to_owned(),
|
||||||
"emoji-icon-font".to_owned(),
|
"emoji-icon-font".to_owned(),
|
||||||
],
|
],
|
||||||
),
|
),
|
||||||
]),
|
]),
|
||||||
};
|
};
|
||||||
|
|
||||||
let data = bincode::serialize(&fonts).unwrap();
|
let data = bincode::serialize(&fonts).unwrap();
|
||||||
|
|
||||||
let zstd_levels = zstd::compression_level_range();
|
let zstd_levels = zstd::compression_level_range();
|
||||||
let data_compressed =
|
let data_compressed =
|
||||||
zstd::encode_all(data.as_slice(), *zstd_levels.end()).expect("Could not compress data");
|
zstd::encode_all(data.as_slice(), *zstd_levels.end()).expect("Could not compress data");
|
||||||
|
|
||||||
let path = Path::new(&env::var("OUT_DIR").unwrap()).join("compressed_data");
|
let path = Path::new(&env::var("OUT_DIR").unwrap()).join("compressed_data");
|
||||||
let mut file = BufWriter::new(File::create(path).expect("Could not save compressed_data"));
|
let mut file = BufWriter::new(File::create(path).expect("Could not save compressed_data"));
|
||||||
|
|
||||||
file.write_all(data_compressed.as_slice())
|
file.write_all(data_compressed.as_slice())
|
||||||
.expect("Failed to save compressed data");
|
.expect("Failed to save compressed data");
|
||||||
}
|
}
|
||||||
|
|||||||
@ -5,13 +5,13 @@ shadow!(build);
|
|||||||
|
|
||||||
/// Constant string that has a string containing information about the build.
|
/// Constant string that has a string containing information about the build.
|
||||||
pub const BUILD_INFO: &str = formatc!(
|
pub const BUILD_INFO: &str = formatc!(
|
||||||
"Commit: {} ({})\nBuild Date: {}\nPackage Version: {}\nRust Channel: {}\nRust Version: {}",
|
"Commit: {} ({})\nBuild Date: {}\nPackage Version: {}\nRust Channel: {}\nRust Version: {}",
|
||||||
&build::SHORT_COMMIT,
|
&build::SHORT_COMMIT,
|
||||||
&build::BRANCH,
|
&build::BRANCH,
|
||||||
&build::BUILD_TIME,
|
&build::BUILD_TIME,
|
||||||
&build::PKG_VERSION,
|
&build::PKG_VERSION,
|
||||||
&build::RUST_CHANNEL,
|
&build::RUST_CHANNEL,
|
||||||
&build::RUST_VERSION,
|
&build::RUST_VERSION,
|
||||||
);
|
);
|
||||||
|
|
||||||
pub const FONT_SIZE: f32 = 14.0;
|
pub const FONT_SIZE: f32 = 14.0;
|
||||||
@ -31,24 +31,24 @@ pub const DEFAULT_INTEGRAL_NUM: usize = 100;
|
|||||||
/// Colors used for plotting
|
/// Colors used for plotting
|
||||||
// Colors commented out are used elsewhere and are not included here for better user experience
|
// Colors commented out are used elsewhere and are not included here for better user experience
|
||||||
pub const COLORS: [Color32; 13] = [
|
pub const COLORS: [Color32; 13] = [
|
||||||
Color32::RED,
|
Color32::RED,
|
||||||
// Color32::GREEN,
|
// Color32::GREEN,
|
||||||
// Color32::YELLOW,
|
// Color32::YELLOW,
|
||||||
// Color32::BLUE,
|
// Color32::BLUE,
|
||||||
Color32::BROWN,
|
Color32::BROWN,
|
||||||
Color32::GOLD,
|
Color32::GOLD,
|
||||||
Color32::GRAY,
|
Color32::GRAY,
|
||||||
Color32::WHITE,
|
Color32::WHITE,
|
||||||
Color32::LIGHT_YELLOW,
|
Color32::LIGHT_YELLOW,
|
||||||
Color32::LIGHT_GREEN,
|
Color32::LIGHT_GREEN,
|
||||||
// Color32::LIGHT_BLUE,
|
// Color32::LIGHT_BLUE,
|
||||||
Color32::LIGHT_GRAY,
|
Color32::LIGHT_GRAY,
|
||||||
Color32::LIGHT_RED,
|
Color32::LIGHT_RED,
|
||||||
Color32::DARK_GRAY,
|
Color32::DARK_GRAY,
|
||||||
// Color32::DARK_RED,
|
// Color32::DARK_RED,
|
||||||
Color32::KHAKI,
|
Color32::KHAKI,
|
||||||
Color32::DARK_GREEN,
|
Color32::DARK_GREEN,
|
||||||
Color32::DARK_BLUE,
|
Color32::DARK_BLUE,
|
||||||
];
|
];
|
||||||
|
|
||||||
const_assert!(!COLORS.is_empty());
|
const_assert!(!COLORS.is_empty());
|
||||||
|
|||||||
@ -1,479 +1,510 @@
|
|||||||
use crate::math_app::AppSettings;
|
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::{Checkbox, Context};
|
||||||
use egui_plot::{Bar, BarChart, PlotPoint, PlotUi};
|
use egui_plot::{Bar, BarChart, PlotPoint, PlotUi};
|
||||||
|
|
||||||
use epaint::Color32;
|
use epaint::Color32;
|
||||||
use parsing::{generate_hint, AutoComplete};
|
use parsing::{AutoComplete, generate_hint};
|
||||||
use parsing::{process_func_str, BackingFunction};
|
use parsing::{BackingFunction, process_func_str};
|
||||||
use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
|
use serde::{Deserialize, Deserializer, Serialize, Serializer, ser::SerializeStruct};
|
||||||
use std::{
|
use std::{
|
||||||
fmt::{self, Debug},
|
fmt::{self, Debug},
|
||||||
hash::{Hash, Hasher},
|
hash::{Hash, Hasher},
|
||||||
};
|
};
|
||||||
|
|
||||||
/// Represents the possible variations of Riemann Sums
|
/// Represents the possible variations of Riemann Sums
|
||||||
#[derive(PartialEq, Eq, Debug, Copy, Clone, Default)]
|
#[derive(PartialEq, Eq, Debug, Copy, Clone, Default)]
|
||||||
pub enum Riemann {
|
pub enum Riemann {
|
||||||
#[default]
|
#[default]
|
||||||
Left,
|
Left,
|
||||||
|
|
||||||
Middle,
|
Middle,
|
||||||
Right,
|
Right,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl fmt::Display for Riemann {
|
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
|
/// `FunctionEntry` is a function that can calculate values, integrals, derivatives, etc etc
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct FunctionEntry {
|
pub struct FunctionEntry {
|
||||||
/// The `BackingFunction` instance that is used to generate `f(x)`, `f'(x)`, and `f''(x)`
|
/// The `BackingFunction` instance that is used to generate `f(x)`, `f'(x)`, and `f''(x)`
|
||||||
function: BackingFunction,
|
function: BackingFunction,
|
||||||
|
|
||||||
/// Stores a function string (that hasn't been processed via `process_func_str`) to display to the user
|
/// Stores a function string (that hasn't been processed via `process_func_str`) to display to the user
|
||||||
pub raw_func_str: String,
|
pub raw_func_str: String,
|
||||||
|
|
||||||
/// If calculating/displayingintegrals are enabled
|
/// If calculating/displayingintegrals are enabled
|
||||||
pub integral: bool,
|
pub integral: bool,
|
||||||
|
|
||||||
/// If displaying derivatives are enabled (note, they are still calculated for other purposes)
|
/// If displaying derivatives are enabled (note, they are still calculated for other purposes)
|
||||||
pub derivative: bool,
|
pub derivative: bool,
|
||||||
|
|
||||||
pub nth_derviative: bool,
|
pub nth_derviative: bool,
|
||||||
|
|
||||||
pub back_data: Vec<PlotPoint>,
|
pub back_data: Vec<PlotPoint>,
|
||||||
pub integral_data: Option<(Vec<Bar>, f64)>,
|
pub integral_data: Option<(Vec<Bar>, f64)>,
|
||||||
pub derivative_data: Vec<PlotPoint>,
|
pub derivative_data: Vec<PlotPoint>,
|
||||||
pub extrema_data: Vec<PlotPoint>,
|
pub extrema_data: Vec<PlotPoint>,
|
||||||
pub root_data: Vec<PlotPoint>,
|
pub root_data: Vec<PlotPoint>,
|
||||||
nth_derivative_data: Option<Vec<PlotPoint>>,
|
nth_derivative_data: Option<Vec<PlotPoint>>,
|
||||||
|
|
||||||
pub autocomplete: AutoComplete<'static>,
|
pub autocomplete: AutoComplete<'static>,
|
||||||
|
|
||||||
test_result: Option<String>,
|
test_result: Option<String>,
|
||||||
curr_nth: usize,
|
curr_nth: usize,
|
||||||
|
|
||||||
pub settings_opened: bool,
|
pub settings_opened: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Hash for FunctionEntry {
|
impl Hash for FunctionEntry {
|
||||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||||
self.raw_func_str.hash(state);
|
self.raw_func_str.hash(state);
|
||||||
self.integral.hash(state);
|
self.integral.hash(state);
|
||||||
self.nth_derviative.hash(state);
|
self.nth_derviative.hash(state);
|
||||||
self.curr_nth.hash(state);
|
self.curr_nth.hash(state);
|
||||||
self.settings_opened.hash(state);
|
self.settings_opened.hash(state);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Serialize for FunctionEntry {
|
impl Serialize for FunctionEntry {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||||
where
|
where
|
||||||
S: Serializer,
|
S: Serializer,
|
||||||
{
|
{
|
||||||
let mut s = serializer.serialize_struct("FunctionEntry", 4)?;
|
let mut s = serializer.serialize_struct("FunctionEntry", 4)?;
|
||||||
s.serialize_field("raw_func_str", &self.raw_func_str)?;
|
s.serialize_field("raw_func_str", &self.raw_func_str)?;
|
||||||
s.serialize_field("integral", &self.integral)?;
|
s.serialize_field("integral", &self.integral)?;
|
||||||
s.serialize_field("derivative", &self.derivative)?;
|
s.serialize_field("derivative", &self.derivative)?;
|
||||||
s.serialize_field("curr_nth", &self.curr_nth)?;
|
s.serialize_field("curr_nth", &self.curr_nth)?;
|
||||||
|
|
||||||
s.end()
|
s.end()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'de> Deserialize<'de> for FunctionEntry {
|
impl<'de> Deserialize<'de> for FunctionEntry {
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
||||||
where
|
where
|
||||||
D: Deserializer<'de>,
|
D: Deserializer<'de>,
|
||||||
{
|
{
|
||||||
#[derive(Deserialize)]
|
#[derive(Deserialize)]
|
||||||
struct Helper {
|
struct Helper {
|
||||||
raw_func_str: String,
|
raw_func_str: String,
|
||||||
integral: bool,
|
integral: bool,
|
||||||
derivative: bool,
|
derivative: bool,
|
||||||
curr_nth: usize,
|
curr_nth: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
let helper = Helper::deserialize(deserializer)?;
|
let helper = Helper::deserialize(deserializer)?;
|
||||||
let mut new_func_entry = FunctionEntry::default();
|
let mut new_func_entry = FunctionEntry::default();
|
||||||
let gen_func = BackingFunction::new(&helper.raw_func_str);
|
let gen_func = BackingFunction::new(&helper.raw_func_str);
|
||||||
match gen_func {
|
match gen_func {
|
||||||
Ok(func) => new_func_entry.function = func,
|
Ok(func) => new_func_entry.function = func,
|
||||||
Err(x) => new_func_entry.test_result = Some(x),
|
Err(x) => new_func_entry.test_result = Some(x),
|
||||||
}
|
}
|
||||||
|
|
||||||
new_func_entry.autocomplete = AutoComplete {
|
new_func_entry.autocomplete = AutoComplete {
|
||||||
i: 0,
|
i: 0,
|
||||||
hint: generate_hint(&helper.raw_func_str),
|
hint: generate_hint(&helper.raw_func_str),
|
||||||
string: helper.raw_func_str,
|
string: helper.raw_func_str,
|
||||||
};
|
};
|
||||||
|
|
||||||
new_func_entry.integral = helper.integral;
|
new_func_entry.integral = helper.integral;
|
||||||
new_func_entry.derivative = helper.derivative;
|
new_func_entry.derivative = helper.derivative;
|
||||||
new_func_entry.curr_nth = helper.curr_nth;
|
new_func_entry.curr_nth = helper.curr_nth;
|
||||||
|
|
||||||
Ok(new_func_entry)
|
Ok(new_func_entry)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Default for FunctionEntry {
|
impl Default for FunctionEntry {
|
||||||
/// Creates default FunctionEntry instance (which is empty)
|
/// Creates default FunctionEntry instance (which is empty)
|
||||||
fn default() -> FunctionEntry {
|
fn default() -> FunctionEntry {
|
||||||
FunctionEntry {
|
FunctionEntry {
|
||||||
function: BackingFunction::default(),
|
function: BackingFunction::default(),
|
||||||
raw_func_str: String::new(),
|
raw_func_str: String::new(),
|
||||||
integral: false,
|
integral: false,
|
||||||
derivative: false,
|
derivative: false,
|
||||||
nth_derviative: false,
|
nth_derviative: false,
|
||||||
back_data: Vec::new(),
|
back_data: Vec::new(),
|
||||||
integral_data: None,
|
integral_data: None,
|
||||||
derivative_data: Vec::new(),
|
derivative_data: Vec::new(),
|
||||||
extrema_data: Vec::new(),
|
extrema_data: Vec::new(),
|
||||||
root_data: Vec::new(),
|
root_data: Vec::new(),
|
||||||
nth_derivative_data: None,
|
nth_derivative_data: None,
|
||||||
autocomplete: AutoComplete::EMPTY,
|
autocomplete: AutoComplete::EMPTY,
|
||||||
test_result: None,
|
test_result: None,
|
||||||
curr_nth: 3,
|
curr_nth: 3,
|
||||||
settings_opened: false,
|
settings_opened: false,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl FunctionEntry {
|
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) {
|
pub fn settings_window(&mut self, ctx: &Context) {
|
||||||
let mut invalidate_nth = false;
|
let mut invalidate_nth = false;
|
||||||
egui::Window::new(format!("Settings: {}", self.raw_func_str))
|
egui::Window::new(format!("Settings: {}", self.raw_func_str))
|
||||||
.open(&mut self.settings_opened)
|
.open(&mut self.settings_opened)
|
||||||
.default_pos([200.0, 200.0])
|
.default_pos([200.0, 200.0])
|
||||||
.resizable(false)
|
.resizable(false)
|
||||||
.collapsible(false)
|
.collapsible(false)
|
||||||
.show(ctx, |ui| {
|
.show(ctx, |ui| {
|
||||||
ui.add(Checkbox::new(
|
ui.add(Checkbox::new(
|
||||||
&mut self.nth_derviative,
|
&mut self.nth_derviative,
|
||||||
"Display Nth Derivative",
|
"Display Nth Derivative",
|
||||||
));
|
));
|
||||||
|
|
||||||
if ui
|
if ui
|
||||||
.add(egui::Slider::new(&mut self.curr_nth, 3..=5).text("Nth Derivative"))
|
.add(egui::Slider::new(&mut self.curr_nth, 3..=5).text("Nth Derivative"))
|
||||||
.changed()
|
.changed()
|
||||||
{
|
{
|
||||||
invalidate_nth = true;
|
invalidate_nth = true;
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
if invalidate_nth {
|
if invalidate_nth {
|
||||||
self.function.generate_derivative(self.curr_nth);
|
self.function.generate_derivative(self.curr_nth);
|
||||||
self.clear_nth();
|
self.clear_nth();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Get function's cached test result
|
/// Get function's cached test result
|
||||||
pub fn get_test_result(&self) -> &Option<String> { &self.test_result }
|
pub fn get_test_result(&self) -> &Option<String> {
|
||||||
|
&self.test_result
|
||||||
|
}
|
||||||
|
|
||||||
/// Update function string and test it
|
/// Update function string and test it
|
||||||
pub fn update_string(&mut self, raw_func_str: &str) {
|
pub fn update_string(&mut self, raw_func_str: &str) {
|
||||||
if raw_func_str == self.raw_func_str {
|
if raw_func_str == self.raw_func_str {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
self.raw_func_str = raw_func_str.to_owned();
|
self.raw_func_str = raw_func_str.to_owned();
|
||||||
let processed_func = process_func_str(raw_func_str);
|
let processed_func = process_func_str(raw_func_str);
|
||||||
let new_func_result = BackingFunction::new(&processed_func);
|
let new_func_result = BackingFunction::new(&processed_func);
|
||||||
|
|
||||||
match new_func_result {
|
match new_func_result {
|
||||||
Ok(new_function) => {
|
Ok(new_function) => {
|
||||||
self.test_result = None;
|
self.test_result = None;
|
||||||
self.function = new_function;
|
self.function = new_function;
|
||||||
self.invalidate_whole();
|
self.invalidate_whole();
|
||||||
}
|
}
|
||||||
Err(error) => {
|
Err(error) => {
|
||||||
self.test_result = Some(error);
|
self.test_result = Some(error);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Creates and does the math for creating all the rectangles under the graph
|
/// Creates and does the math for creating all the rectangles under the graph
|
||||||
fn integral_rectangles(
|
fn integral_rectangles(
|
||||||
&mut self, integral_min_x: f64, integral_max_x: f64, sum: Riemann, integral_num: usize,
|
&mut self,
|
||||||
) -> (Vec<(f64, f64)>, f64) {
|
integral_min_x: f64,
|
||||||
let step = (integral_max_x - integral_min_x) / (integral_num as 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)
|
let data2: Vec<(f64, f64)> = step_helper(integral_num, integral_min_x, step)
|
||||||
.into_iter()
|
.into_iter()
|
||||||
.map(|x| {
|
.map(|x| {
|
||||||
let step_offset = step.copysign(x); // store the offset here so it doesn't have to be calculated multiple times
|
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 x2: f64 = x + step_offset;
|
||||||
|
|
||||||
let (left_x, right_x) = match x.is_sign_positive() {
|
let (left_x, right_x) = match x.is_sign_positive() {
|
||||||
true => (x, x2),
|
true => (x, x2),
|
||||||
false => (x2, x),
|
false => (x2, x),
|
||||||
};
|
};
|
||||||
|
|
||||||
let y = match sum {
|
let y = match sum {
|
||||||
Riemann::Left => self.function.get(0, left_x),
|
Riemann::Left => self.function.get(0, left_x),
|
||||||
Riemann::Right => self.function.get(0, right_x),
|
Riemann::Right => self.function.get(0, right_x),
|
||||||
Riemann::Middle => {
|
Riemann::Middle => {
|
||||||
(self.function.get(0, left_x) + self.function.get(0, right_x)) / 2.0
|
(self.function.get(0, left_x) + self.function.get(0, right_x)) / 2.0
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
(x + (step_offset / 2.0), y)
|
(x + (step_offset / 2.0), y)
|
||||||
})
|
})
|
||||||
.filter(|(_, y)| y.is_finite())
|
.filter(|(_, y)| y.is_finite())
|
||||||
.collect();
|
.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
|
/// Helps with processing newton's method depending on level of derivative
|
||||||
fn newtons_method_helper(
|
fn newtons_method_helper(
|
||||||
&mut self, threshold: f64, derivative_level: usize, range: &std::ops::Range<f64>,
|
&mut self,
|
||||||
) -> Vec<PlotPoint> {
|
threshold: f64,
|
||||||
self.function.generate_derivative(derivative_level);
|
derivative_level: usize,
|
||||||
self.function.generate_derivative(derivative_level + 1);
|
range: &std::ops::Range<f64>,
|
||||||
let newtons_method_output: Vec<f64> = match derivative_level {
|
) -> Vec<PlotPoint> {
|
||||||
0 => newtons_method_helper(
|
self.function.generate_derivative(derivative_level);
|
||||||
threshold,
|
self.function.generate_derivative(derivative_level + 1);
|
||||||
range,
|
let newtons_method_output: Vec<f64> = match derivative_level {
|
||||||
self.back_data.as_slice(),
|
0 => newtons_method_helper(
|
||||||
&self.function.get_function_derivative(0),
|
threshold,
|
||||||
&self.function.get_function_derivative(1),
|
range,
|
||||||
),
|
self.back_data.as_slice(),
|
||||||
1 => newtons_method_helper(
|
self.function.get_function_derivative(0),
|
||||||
threshold,
|
self.function.get_function_derivative(1),
|
||||||
range,
|
),
|
||||||
self.derivative_data.as_slice(),
|
1 => newtons_method_helper(
|
||||||
&self.function.get_function_derivative(1),
|
threshold,
|
||||||
&self.function.get_function_derivative(2),
|
range,
|
||||||
),
|
self.derivative_data.as_slice(),
|
||||||
_ => unreachable!(),
|
self.function.get_function_derivative(1),
|
||||||
};
|
self.function.get_function_derivative(2),
|
||||||
|
),
|
||||||
|
_ => unreachable!(),
|
||||||
|
};
|
||||||
|
|
||||||
newtons_method_output
|
newtons_method_output
|
||||||
.into_iter()
|
.into_iter()
|
||||||
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
|
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
|
||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Does the calculations and stores results in `self`
|
/// Does the calculations and stores results in `self`
|
||||||
pub fn calculate(
|
pub fn calculate(
|
||||||
&mut self, width_changed: bool, min_max_changed: bool, did_zoom: bool,
|
&mut self,
|
||||||
settings: AppSettings,
|
width_changed: bool,
|
||||||
) {
|
min_max_changed: bool,
|
||||||
if self.test_result.is_some() | self.function.is_none() {
|
did_zoom: bool,
|
||||||
return;
|
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);
|
let resolution = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
|
||||||
debug_assert!(resolution > 0.0);
|
debug_assert!(resolution > 0.0);
|
||||||
let resolution_iter = step_helper(settings.plot_width + 1, settings.min_x, resolution);
|
let resolution_iter = step_helper(settings.plot_width + 1, settings.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 {
|
||||||
self.clear_integral();
|
self.clear_integral();
|
||||||
}
|
}
|
||||||
|
|
||||||
if width_changed | min_max_changed | did_zoom {
|
if width_changed | min_max_changed | did_zoom {
|
||||||
self.clear_back();
|
self.clear_back();
|
||||||
self.clear_derivative();
|
self.clear_derivative();
|
||||||
self.clear_nth();
|
self.clear_nth();
|
||||||
}
|
}
|
||||||
|
|
||||||
if self.back_data.is_empty() {
|
if self.back_data.is_empty() {
|
||||||
let data: Vec<PlotPoint> = resolution_iter
|
let data: Vec<PlotPoint> = resolution_iter
|
||||||
.clone()
|
.clone()
|
||||||
.into_iter()
|
.into_iter()
|
||||||
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
|
.map(|x| PlotPoint::new(x, self.function.get(0, x)))
|
||||||
.collect();
|
.collect();
|
||||||
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
||||||
|
|
||||||
self.back_data = data;
|
self.back_data = data;
|
||||||
}
|
}
|
||||||
|
|
||||||
if self.derivative_data.is_empty() {
|
if self.derivative_data.is_empty() {
|
||||||
self.function.generate_derivative(1);
|
self.function.generate_derivative(1);
|
||||||
let data: Vec<PlotPoint> = resolution_iter
|
let data: Vec<PlotPoint> = resolution_iter
|
||||||
.clone()
|
.clone()
|
||||||
.into_iter()
|
.into_iter()
|
||||||
.map(|x| PlotPoint::new(x, self.function.get(1, x)))
|
.map(|x| PlotPoint::new(x, self.function.get(1, x)))
|
||||||
.collect();
|
.collect();
|
||||||
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
||||||
self.derivative_data = data;
|
self.derivative_data = data;
|
||||||
}
|
}
|
||||||
|
|
||||||
if self.nth_derviative && self.nth_derivative_data.is_none() {
|
if self.nth_derviative && self.nth_derivative_data.is_none() {
|
||||||
let data: Vec<PlotPoint> = resolution_iter
|
let data: Vec<PlotPoint> = resolution_iter
|
||||||
.into_iter()
|
.into_iter()
|
||||||
.map(|x| PlotPoint::new(x, self.function.get(self.curr_nth, x)))
|
.map(|x| PlotPoint::new(x, self.function.get(self.curr_nth, x)))
|
||||||
.collect();
|
.collect();
|
||||||
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
||||||
self.nth_derivative_data = Some(data);
|
self.nth_derivative_data = Some(data);
|
||||||
}
|
}
|
||||||
|
|
||||||
if self.integral {
|
if self.integral {
|
||||||
if self.integral_data.is_none() {
|
if self.integral_data.is_none() {
|
||||||
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.riemann_sum,
|
settings.riemann_sum,
|
||||||
settings.integral_num,
|
settings.integral_num,
|
||||||
);
|
);
|
||||||
|
|
||||||
self.integral_data = Some((
|
self.integral_data = Some((
|
||||||
data.into_iter().map(|(x, y)| Bar::new(x, y)).collect(),
|
data.into_iter().map(|(x, y)| Bar::new(x, y)).collect(),
|
||||||
area,
|
area,
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
self.clear_integral();
|
self.clear_integral();
|
||||||
}
|
}
|
||||||
|
|
||||||
let threshold: f64 = resolution / 2.0;
|
let threshold: f64 = resolution / 2.0;
|
||||||
let x_range = settings.min_x..settings.max_x;
|
let x_range = settings.min_x..settings.max_x;
|
||||||
|
|
||||||
// Calculates extrema
|
// Calculates extrema
|
||||||
if settings.do_extrema && (min_max_changed | self.extrema_data.is_empty()) {
|
if settings.do_extrema && (min_max_changed | self.extrema_data.is_empty()) {
|
||||||
self.extrema_data = self.newtons_method_helper(threshold, 1, &x_range);
|
self.extrema_data = self.newtons_method_helper(threshold, 1, &x_range);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Calculates roots
|
// Calculates roots
|
||||||
if settings.do_roots && (min_max_changed | self.root_data.is_empty()) {
|
if settings.do_roots && (min_max_changed | self.root_data.is_empty()) {
|
||||||
self.root_data = self.newtons_method_helper(threshold, 0, &x_range);
|
self.root_data = self.newtons_method_helper(threshold, 0, &x_range);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Displays the function's output on PlotUI `plot_ui` with settings `settings`.
|
/// Displays the function's output on PlotUI `plot_ui` with settings `settings`.
|
||||||
/// Returns an `Option<f64>` of the calculated integral.
|
/// Returns an `Option<f64>` of the calculated integral.
|
||||||
pub fn display(
|
pub fn display(
|
||||||
&self, plot_ui: &mut PlotUi, settings: &AppSettings, main_plot_color: Color32,
|
&self,
|
||||||
) -> Option<f64> {
|
plot_ui: &mut PlotUi,
|
||||||
if self.test_result.is_some() | self.function.is_none() {
|
settings: &AppSettings,
|
||||||
return None;
|
main_plot_color: Color32,
|
||||||
}
|
) -> Option<f64> {
|
||||||
|
if self.test_result.is_some() | self.function.is_none() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
|
||||||
let integral_step =
|
let integral_step =
|
||||||
(settings.integral_max_x - settings.integral_min_x) / (settings.integral_num as f64);
|
(settings.integral_max_x - settings.integral_min_x) / (settings.integral_num as f64);
|
||||||
debug_assert!(integral_step > 0.0);
|
debug_assert!(integral_step > 0.0);
|
||||||
|
|
||||||
let step = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
|
let step = (settings.max_x - settings.min_x) / (settings.plot_width as f64);
|
||||||
debug_assert!(step > 0.0);
|
debug_assert!(step > 0.0);
|
||||||
|
|
||||||
// Plot back data
|
// Plot back data
|
||||||
if !self.back_data.is_empty() {
|
if !self.back_data.is_empty() {
|
||||||
if self.integral && (step >= integral_step) {
|
if self.integral && (step >= integral_step) {
|
||||||
plot_ui.line(
|
plot_ui.line(
|
||||||
self.back_data
|
self.back_data
|
||||||
.iter()
|
.iter()
|
||||||
.filter(|value| {
|
.filter(|value| {
|
||||||
(value.x > settings.integral_min_x)
|
(value.x > settings.integral_min_x)
|
||||||
&& (settings.integral_max_x > value.x)
|
&& (settings.integral_max_x > value.x)
|
||||||
})
|
})
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<PlotPoint>>()
|
.collect::<Vec<PlotPoint>>()
|
||||||
.to_line()
|
.to_line()
|
||||||
.stroke(epaint::Stroke::NONE)
|
.stroke(epaint::Stroke::NONE)
|
||||||
.color(Color32::from_rgb(4, 4, 255))
|
.color(Color32::from_rgb(4, 4, 255))
|
||||||
.fill(0.0),
|
.fill(0.0),
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
plot_ui.line(
|
plot_ui.line(
|
||||||
self.back_data
|
self.back_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_line()
|
.to_line()
|
||||||
.stroke(egui::Stroke::new(4.0, main_plot_color)),
|
.stroke(egui::Stroke::new(4.0, main_plot_color)),
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Plot derivative data
|
// Plot derivative data
|
||||||
if self.derivative && !self.derivative_data.is_empty() {
|
if self.derivative && !self.derivative_data.is_empty() {
|
||||||
plot_ui.line(self.derivative_data.clone().to_line().color(Color32::GREEN));
|
plot_ui.line(self.derivative_data.clone().to_line().color(Color32::GREEN));
|
||||||
}
|
}
|
||||||
|
|
||||||
// Plot extrema points
|
// Plot extrema points
|
||||||
if settings.do_extrema && !self.extrema_data.is_empty() {
|
if settings.do_extrema && !self.extrema_data.is_empty() {
|
||||||
plot_ui.points(
|
plot_ui.points(
|
||||||
self.extrema_data
|
self.extrema_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_points()
|
.to_points()
|
||||||
.color(Color32::YELLOW)
|
.color(Color32::YELLOW)
|
||||||
.radius(5.0), // Radius of points of Extrema
|
.radius(5.0), // Radius of points of Extrema
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Plot roots points
|
// Plot roots points
|
||||||
if settings.do_roots && !self.root_data.is_empty() {
|
if settings.do_roots && !self.root_data.is_empty() {
|
||||||
plot_ui.points(
|
plot_ui.points(
|
||||||
self.root_data
|
self.root_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_points()
|
.to_points()
|
||||||
.color(Color32::LIGHT_BLUE)
|
.color(Color32::LIGHT_BLUE)
|
||||||
.radius(5.0), // Radius of points of Roots
|
.radius(5.0), // Radius of points of Roots
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
if self.nth_derviative
|
if self.nth_derviative
|
||||||
&& let Some(ref nth_derviative) = self.nth_derivative_data
|
&& let Some(ref nth_derviative) = self.nth_derivative_data
|
||||||
{
|
{
|
||||||
plot_ui.line(nth_derviative.clone().to_line().color(Color32::DARK_RED));
|
plot_ui.line(nth_derviative.clone().to_line().color(Color32::DARK_RED));
|
||||||
}
|
}
|
||||||
|
|
||||||
// Plot integral data
|
// Plot integral data
|
||||||
match &self.integral_data {
|
match &self.integral_data {
|
||||||
Some(integral_data) => {
|
Some(integral_data) => {
|
||||||
if integral_step > step {
|
if integral_step > step {
|
||||||
plot_ui.bar_chart(
|
plot_ui.bar_chart(
|
||||||
BarChart::new(integral_data.0.clone())
|
BarChart::new(integral_data.0.clone())
|
||||||
.color(Color32::BLUE)
|
.color(Color32::BLUE)
|
||||||
.width(integral_step),
|
.width(integral_step),
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
// return value rounded to 8 decimal places
|
// return value rounded to 8 decimal places
|
||||||
Some(emath::round_to_decimals(integral_data.1, 8))
|
Some(emath::round_to_decimals(integral_data.1, 8))
|
||||||
}
|
}
|
||||||
None => None,
|
None => None,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Invalidate entire cache
|
/// Invalidate entire cache
|
||||||
fn invalidate_whole(&mut self) {
|
fn invalidate_whole(&mut self) {
|
||||||
self.clear_back();
|
self.clear_back();
|
||||||
self.clear_integral();
|
self.clear_integral();
|
||||||
self.clear_derivative();
|
self.clear_derivative();
|
||||||
self.clear_nth();
|
self.clear_nth();
|
||||||
self.clear_extrema();
|
self.clear_extrema();
|
||||||
self.clear_roots();
|
self.clear_roots();
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Invalidate `back` data
|
/// Invalidate `back` data
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clear_back(&mut self) { self.back_data.clear(); }
|
fn clear_back(&mut self) {
|
||||||
|
self.back_data.clear();
|
||||||
|
}
|
||||||
|
|
||||||
/// Invalidate Integral data
|
/// Invalidate Integral data
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clear_integral(&mut self) { self.integral_data = None; }
|
fn clear_integral(&mut self) {
|
||||||
|
self.integral_data = None;
|
||||||
|
}
|
||||||
|
|
||||||
/// Invalidate Derivative data
|
/// Invalidate Derivative data
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clear_derivative(&mut self) { self.derivative_data.clear(); }
|
fn clear_derivative(&mut self) {
|
||||||
|
self.derivative_data.clear();
|
||||||
|
}
|
||||||
|
|
||||||
/// Invalidates `n`th derivative data
|
/// Invalidates `n`th derivative data
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clear_nth(&mut self) { self.nth_derivative_data = None }
|
fn clear_nth(&mut self) {
|
||||||
|
self.nth_derivative_data = None
|
||||||
|
}
|
||||||
|
|
||||||
/// Invalidate extrema data
|
/// Invalidate extrema data
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clear_extrema(&mut self) { self.extrema_data.clear() }
|
fn clear_extrema(&mut self) {
|
||||||
|
self.extrema_data.clear()
|
||||||
|
}
|
||||||
|
|
||||||
/// Invalidate root data
|
/// Invalidate root data
|
||||||
#[inline]
|
#[inline]
|
||||||
fn clear_roots(&mut self) { self.root_data.clear() }
|
fn clear_roots(&mut self) {
|
||||||
|
self.root_data.clear()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@ -1,8 +1,5 @@
|
|||||||
use crate::{
|
use crate::{
|
||||||
consts::COLORS,
|
consts::COLORS, function_entry::FunctionEntry, misc::random_u64, widgets::widgets_ontop,
|
||||||
function_entry::FunctionEntry,
|
|
||||||
misc::{random_u64},
|
|
||||||
widgets::widgets_ontop,
|
|
||||||
};
|
};
|
||||||
use egui::{Button, Id, Key, Modifiers, TextEdit, WidgetText};
|
use egui::{Button, Id, Key, Modifiers, TextEdit, WidgetText};
|
||||||
use emath::vec2;
|
use emath::vec2;
|
||||||
@ -15,21 +12,20 @@ use std::ops::BitXorAssign;
|
|||||||
|
|
||||||
type Functions = Vec<(Id, FunctionEntry)>;
|
type Functions = Vec<(Id, FunctionEntry)>;
|
||||||
pub struct FunctionManager {
|
pub struct FunctionManager {
|
||||||
functions: Functions,
|
functions: Functions,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Default for FunctionManager {
|
impl Default for FunctionManager {
|
||||||
fn default() -> Self {
|
fn default() -> Self {
|
||||||
let mut vec: Functions = Vec::with_capacity(COLORS.len());
|
let mut vec: Functions = Vec::with_capacity(COLORS.len());
|
||||||
vec.push((
|
vec.push((
|
||||||
Id::new(11414819524356497634 as u64), // Random number here to avoid call to crate::misc::random_u64()
|
Id::new(11414819524356497634_u64), // Random number here to avoid call to crate::misc::random_u64()
|
||||||
FunctionEntry::default(),
|
FunctionEntry::default(),
|
||||||
));
|
));
|
||||||
Self { functions: vec }
|
Self { functions: vec }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
impl Serialize for FunctionManager {
|
impl Serialize for FunctionManager {
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
||||||
where
|
where
|
||||||
@ -56,7 +52,7 @@ impl<'de> Deserialize<'de> for FunctionManager {
|
|||||||
#[derive(Deserialize)]
|
#[derive(Deserialize)]
|
||||||
struct Helper(Vec<(Id, FunctionEntry)>);
|
struct Helper(Vec<(Id, FunctionEntry)>);
|
||||||
|
|
||||||
let helper = Helper::deserialize(deserializer)?;
|
let helper = Helper::deserialize(deserializer)?;
|
||||||
|
|
||||||
Ok(FunctionManager {
|
Ok(FunctionManager {
|
||||||
functions: helper.0.to_vec(),
|
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`
|
/// Function that creates button that's used with the `button_area`
|
||||||
fn button_area_button<'a>(text: impl Into<WidgetText>) -> Button<'a> {
|
fn button_area_button<'a>(text: impl Into<WidgetText>) -> Button<'a> {
|
||||||
Button::new(text).frame(false)
|
Button::new(text).frame(false)
|
||||||
}
|
}
|
||||||
|
|
||||||
impl FunctionManager {
|
impl FunctionManager {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn get_hash(&self) -> u64 {
|
fn get_hash(&self) -> u64 {
|
||||||
let mut hasher = DefaultHasher::new();
|
let mut hasher = DefaultHasher::new();
|
||||||
self.functions.hash(&mut hasher);
|
self.functions.hash(&mut hasher);
|
||||||
hasher.finish()
|
hasher.finish()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Displays function entries alongside returning whether or not functions have been modified
|
/// Displays function entries alongside returning whether or not functions have been modified
|
||||||
pub fn display_entries(&mut self, ui: &mut egui::Ui) -> bool {
|
pub fn display_entries(&mut self, ui: &mut egui::Ui) -> bool {
|
||||||
let initial_hash = self.get_hash();
|
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 available_width = ui.available_width();
|
||||||
let mut remove_i: Option<usize> = None;
|
let mut remove_i: Option<usize> = None;
|
||||||
let target_size = vec2(available_width, crate::consts::FONT_SIZE);
|
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() {
|
for (i, (te_id, function)) in self.functions.iter_mut().map(|(a, b)| (*a, b)).enumerate() {
|
||||||
let mut new_string = function.autocomplete.string.clone();
|
let mut new_string = function.autocomplete.string.clone();
|
||||||
function.update_string(&new_string);
|
function.update_string(&new_string);
|
||||||
|
|
||||||
let mut movement: Movement = Movement::default();
|
let mut movement: Movement = Movement::default();
|
||||||
|
|
||||||
let size_multiplier = vec2(1.0, {
|
let size_multiplier = vec2(1.0, {
|
||||||
let had_focus = ui.memory(|x| x.has_focus(te_id));
|
let had_focus = ui.memory(|x| x.has_focus(te_id));
|
||||||
(ui.ctx().animate_bool(te_id, had_focus) * 1.5) + 1.0
|
(ui.ctx().animate_bool(te_id, had_focus) * 1.5) + 1.0
|
||||||
});
|
});
|
||||||
|
|
||||||
let re = ui.add_sized(
|
let re = ui.add_sized(
|
||||||
target_size * size_multiplier,
|
target_size * size_multiplier,
|
||||||
egui::TextEdit::singleline(&mut new_string)
|
egui::TextEdit::singleline(&mut new_string)
|
||||||
.hint_forward(true) // Make the hint appear after the last text in the textbox
|
.hint_forward(true) // Make the hint appear after the last text in the textbox
|
||||||
.lock_focus(true)
|
.lock_focus(true)
|
||||||
.id(te_id) // Set widget's id to `te_id`
|
.id(te_id) // Set widget's id to `te_id`
|
||||||
.hint_text(
|
.hint_text(
|
||||||
// If there's a single hint, go ahead and apply the hint here, if not, set the hint to an empty string
|
// 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(""),
|
function.autocomplete.hint.single().unwrap_or(""),
|
||||||
),
|
),
|
||||||
);
|
);
|
||||||
|
|
||||||
// Only keep valid chars
|
// Only keep valid chars
|
||||||
new_string.retain(crate::misc::is_valid_char);
|
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
|
// 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());
|
let animate_bool = ui.ctx().animate_bool(te_id, re.has_focus());
|
||||||
if animate_bool == 1.0 {
|
if animate_bool == 1.0 {
|
||||||
function.autocomplete.update_string(&new_string);
|
function.autocomplete.update_string(&new_string);
|
||||||
|
|
||||||
if function.autocomplete.hint.is_some() {
|
if function.autocomplete.hint.is_some() {
|
||||||
// only register up and down arrow movements if hint is type `Hint::Many`
|
// only register up and down arrow movements if hint is type `Hint::Many`
|
||||||
if !function.autocomplete.hint.is_single() {
|
if !function.autocomplete.hint.is_single() {
|
||||||
let (arrow_down, arrow_up) = ui.input(|x| {
|
let (arrow_down, arrow_up) = ui.input(|x| {
|
||||||
(x.key_pressed(Key::ArrowDown), x.key_pressed(Key::ArrowUp))
|
(x.key_pressed(Key::ArrowDown), x.key_pressed(Key::ArrowUp))
|
||||||
});
|
});
|
||||||
if arrow_down {
|
if arrow_down {
|
||||||
movement = Movement::Down;
|
movement = Movement::Down;
|
||||||
} else if arrow_up {
|
} else if arrow_up {
|
||||||
movement = Movement::Up;
|
movement = Movement::Up;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Put here so these key presses don't interact with other elements
|
// Put here so these key presses don't interact with other elements
|
||||||
let movement_complete_action = ui.input_mut(|x| {
|
let movement_complete_action = ui.input_mut(|x| {
|
||||||
x.consume_key(Modifiers::NONE, Key::Enter)
|
x.consume_key(Modifiers::NONE, Key::Enter)
|
||||||
| x.consume_key(Modifiers::NONE, Key::Tab)
|
| x.consume_key(Modifiers::NONE, Key::Tab)
|
||||||
| x.key_pressed(Key::ArrowRight)
|
| x.key_pressed(Key::ArrowRight)
|
||||||
});
|
});
|
||||||
|
|
||||||
if movement_complete_action {
|
if movement_complete_action {
|
||||||
movement = Movement::Complete;
|
movement = Movement::Complete;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Register movement and apply proper changes
|
// Register movement and apply proper changes
|
||||||
function.autocomplete.register_movement(&movement);
|
function.autocomplete.register_movement(&movement);
|
||||||
|
|
||||||
if movement != Movement::Complete
|
if movement != Movement::Complete
|
||||||
&& let Some(hints) = function.autocomplete.hint.many()
|
&& let Some(hints) = function.autocomplete.hint.many()
|
||||||
{
|
{
|
||||||
let mut clicked = false;
|
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| {
|
egui::popup_below_widget(ui, autocomplete_popup_id, &re, |ui| {
|
||||||
hints.iter().enumerate().for_each(|(i, candidate)| {
|
hints.iter().enumerate().for_each(|(i, candidate)| {
|
||||||
if ui
|
if ui
|
||||||
.selectable_label(i == function.autocomplete.i, *candidate)
|
.selectable_label(i == function.autocomplete.i, *candidate)
|
||||||
.clicked()
|
.clicked()
|
||||||
{
|
{
|
||||||
clicked = true;
|
clicked = true;
|
||||||
function.autocomplete.i = i;
|
function.autocomplete.i = i;
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
});
|
});
|
||||||
|
|
||||||
if clicked {
|
if clicked {
|
||||||
function
|
function
|
||||||
.autocomplete
|
.autocomplete
|
||||||
.apply_hint(hints[function.autocomplete.i]);
|
.apply_hint(hints[function.autocomplete.i]);
|
||||||
|
|
||||||
movement = Movement::Complete;
|
movement = Movement::Complete;
|
||||||
} else {
|
} else {
|
||||||
ui.memory_mut(|x| x.open_popup(autocomplete_popup_id.clone()));
|
ui.memory_mut(|x| x.open_popup(autocomplete_popup_id));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// Push cursor to end if needed
|
// Push cursor to end if needed
|
||||||
if movement == Movement::Complete {
|
if movement == Movement::Complete {
|
||||||
let mut state =
|
let mut state =
|
||||||
unsafe { TextEdit::load_state(ui.ctx(), te_id).unwrap_unchecked() };
|
unsafe { TextEdit::load_state(ui.ctx(), te_id).unwrap_unchecked() };
|
||||||
let ccursor = egui::text::CCursor::new(function.autocomplete.string.len());
|
let ccursor = egui::text::CCursor::new(function.autocomplete.string.len());
|
||||||
state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
|
state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
|
||||||
TextEdit::store_state(ui.ctx(), te_id, state);
|
TextEdit::store_state(ui.ctx(), te_id, state);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// The y offset multiplier of the `buttons_area` area
|
/// The y offset multiplier of the `buttons_area` area
|
||||||
const BUTTONS_Y_OFFSET: f32 = 1.32;
|
const BUTTONS_Y_OFFSET: f32 = 1.32;
|
||||||
const Y_OFFSET: f32 = crate::consts::FONT_SIZE * BUTTONS_Y_OFFSET;
|
const Y_OFFSET: f32 = crate::consts::FONT_SIZE * BUTTONS_Y_OFFSET;
|
||||||
|
|
||||||
widgets_ontop(ui, Id::new(i), &re, Y_OFFSET, |ui| {
|
widgets_ontop(ui, Id::new(i), &re, Y_OFFSET, |ui| {
|
||||||
ui.horizontal(|ui| {
|
ui.horizontal(|ui| {
|
||||||
// There's more than 1 function! Functions can now be deleted
|
// There's more than 1 function! Functions can now be deleted
|
||||||
if ui
|
if ui
|
||||||
.add_enabled(can_remove, button_area_button("✖"))
|
.add_enabled(can_remove, button_area_button("✖"))
|
||||||
.on_hover_text("Delete Function")
|
.on_hover_text("Delete Function")
|
||||||
.clicked()
|
.clicked()
|
||||||
{
|
{
|
||||||
remove_i = Some(i);
|
remove_i = Some(i);
|
||||||
}
|
}
|
||||||
|
|
||||||
ui.add_enabled_ui(function.is_some(), |ui| {
|
ui.add_enabled_ui(function.is_some(), |ui| {
|
||||||
// Toggle integral being enabled or not
|
// Toggle integral being enabled or not
|
||||||
function.integral.bitxor_assign(
|
function.integral.bitxor_assign(
|
||||||
ui.add(button_area_button("∫"))
|
ui.add(button_area_button("∫"))
|
||||||
.on_hover_text(match function.integral {
|
.on_hover_text(match function.integral {
|
||||||
true => "Don't integrate",
|
true => "Don't integrate",
|
||||||
false => "Integrate",
|
false => "Integrate",
|
||||||
})
|
})
|
||||||
.clicked(),
|
.clicked(),
|
||||||
);
|
);
|
||||||
|
|
||||||
// Toggle showing the derivative (even though it's already calculated this option just toggles if it's displayed or not)
|
// Toggle showing the derivative (even though it's already calculated this option just toggles if it's displayed or not)
|
||||||
function.derivative.bitxor_assign(
|
function.derivative.bitxor_assign(
|
||||||
ui.add(button_area_button("d/dx"))
|
ui.add(button_area_button("d/dx"))
|
||||||
.on_hover_text(match function.derivative {
|
.on_hover_text(match function.derivative {
|
||||||
true => "Don't Differentiate",
|
true => "Don't Differentiate",
|
||||||
false => "Differentiate",
|
false => "Differentiate",
|
||||||
})
|
})
|
||||||
.clicked(),
|
.clicked(),
|
||||||
);
|
);
|
||||||
|
|
||||||
// Toggle showing the settings window
|
// Toggle showing the settings window
|
||||||
function.settings_opened.bitxor_assign(
|
function.settings_opened.bitxor_assign(
|
||||||
ui.add(button_area_button("⚙"))
|
ui.add(button_area_button("⚙"))
|
||||||
.on_hover_text(match function.settings_opened {
|
.on_hover_text(match function.settings_opened {
|
||||||
true => "Close Settings",
|
true => "Close Settings",
|
||||||
false => "Open Settings",
|
false => "Open Settings",
|
||||||
})
|
})
|
||||||
.clicked(),
|
.clicked(),
|
||||||
);
|
);
|
||||||
});
|
});
|
||||||
});
|
});
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
function.settings_window(ui.ctx());
|
function.settings_window(ui.ctx());
|
||||||
}
|
}
|
||||||
|
|
||||||
// Remove function if the user requests it
|
// Remove function if the user requests it
|
||||||
if let Some(remove_i_unwrap) = remove_i {
|
if let Some(remove_i_unwrap) = remove_i {
|
||||||
self.functions.remove(remove_i_unwrap);
|
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
|
/// Create and push new empty function entry
|
||||||
pub fn push_empty(&mut self) {
|
pub fn push_empty(&mut self) {
|
||||||
self.functions.push((
|
self.functions.push((
|
||||||
Id::new(random_u64().expect("unable to generate random id")),
|
Id::new(random_u64().expect("unable to generate random id")),
|
||||||
FunctionEntry::default(),
|
FunctionEntry::default(),
|
||||||
));
|
));
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Detect if any functions are using integrals
|
/// Detect if any functions are using integrals
|
||||||
pub fn any_using_integral(&self) -> bool {
|
pub fn any_using_integral(&self) -> bool {
|
||||||
self.functions.iter().any(|(_, func)| func.integral)
|
self.functions.iter().any(|(_, func)| func.integral)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn len(&self) -> usize { self.functions.len() }
|
pub fn len(&self) -> usize {
|
||||||
|
self.functions.len()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn get_entries_mut(&mut self) -> &mut Functions {
|
||||||
|
&mut self.functions
|
||||||
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn get_entries_mut(&mut self) -> &mut Functions { &mut self.functions }
|
pub fn get_entries(&self) -> &Functions {
|
||||||
|
&self.functions
|
||||||
#[inline]
|
}
|
||||||
pub fn get_entries(&self) -> &Functions { &self.functions }
|
|
||||||
}
|
}
|
||||||
|
|||||||
100
src/lib.rs
100
src/lib.rs
@ -10,65 +10,65 @@ mod unicode_helper;
|
|||||||
mod widgets;
|
mod widgets;
|
||||||
|
|
||||||
pub use crate::{
|
pub use crate::{
|
||||||
function_entry::{FunctionEntry, Riemann},
|
function_entry::{FunctionEntry, Riemann},
|
||||||
math_app::AppSettings,
|
math_app::AppSettings,
|
||||||
misc::{
|
misc::{
|
||||||
hashed_storage_create, hashed_storage_read, newtons_method, option_vec_printer,
|
EguiHelper, HashBytes, hashed_storage_create, hashed_storage_read, newtons_method,
|
||||||
step_helper, EguiHelper, HashBytes,
|
option_vec_printer, step_helper,
|
||||||
},
|
},
|
||||||
unicode_helper::{to_chars_array, to_unicode_hash},
|
unicode_helper::{to_chars_array, to_unicode_hash},
|
||||||
};
|
};
|
||||||
|
|
||||||
cfg_if::cfg_if! {
|
cfg_if::cfg_if! {
|
||||||
if #[cfg(target_arch = "wasm32")] {
|
if #[cfg(target_arch = "wasm32")] {
|
||||||
use wasm_bindgen::prelude::*;
|
use wasm_bindgen::prelude::*;
|
||||||
|
|
||||||
use lol_alloc::{FreeListAllocator, LockedAllocator};
|
use lol_alloc::{FreeListAllocator, LockedAllocator};
|
||||||
#[global_allocator]
|
#[global_allocator]
|
||||||
static ALLOCATOR: LockedAllocator<FreeListAllocator> = LockedAllocator::new(FreeListAllocator::new());
|
static ALLOCATOR: LockedAllocator<FreeListAllocator> = LockedAllocator::new(FreeListAllocator::new());
|
||||||
|
|
||||||
use eframe::WebRunner;
|
use eframe::WebRunner;
|
||||||
// use tracing::metadata::LevelFilter;
|
// use tracing::metadata::LevelFilter;
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
#[wasm_bindgen]
|
#[wasm_bindgen]
|
||||||
pub struct WebHandle {
|
pub struct WebHandle {
|
||||||
runner: WebRunner,
|
runner: WebRunner,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[wasm_bindgen]
|
#[wasm_bindgen]
|
||||||
impl WebHandle {
|
impl WebHandle {
|
||||||
/// Installs a panic hook, then returns.
|
/// Installs a panic hook, then returns.
|
||||||
#[allow(clippy::new_without_default)]
|
#[allow(clippy::new_without_default)]
|
||||||
#[wasm_bindgen(constructor)]
|
#[wasm_bindgen(constructor)]
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
// eframe::WebLogger::init(LevelFilter::Debug).ok();
|
// eframe::WebLogger::init(LevelFilter::Debug).ok();
|
||||||
tracing_wasm::set_as_global_default();
|
tracing_wasm::set_as_global_default();
|
||||||
|
|
||||||
Self {
|
Self {
|
||||||
runner: WebRunner::new(),
|
runner: WebRunner::new(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Call this once from JavaScript to start your app.
|
/// Call this once from JavaScript to start your app.
|
||||||
#[wasm_bindgen]
|
#[wasm_bindgen]
|
||||||
pub async fn start(&self, canvas_id: &str) -> Result<(), wasm_bindgen::JsValue> {
|
pub async fn start(&self, canvas_id: &str) -> Result<(), wasm_bindgen::JsValue> {
|
||||||
self.runner
|
self.runner
|
||||||
.start(
|
.start(
|
||||||
canvas_id,
|
canvas_id,
|
||||||
eframe::WebOptions::default(),
|
eframe::WebOptions::default(),
|
||||||
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
|
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
|
||||||
)
|
)
|
||||||
.await
|
.await
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[wasm_bindgen(start)]
|
#[wasm_bindgen(start)]
|
||||||
pub async fn start() {
|
pub async fn start() {
|
||||||
tracing::info!("Starting...");
|
tracing::info!("Starting...");
|
||||||
|
|
||||||
|
|
||||||
let web_handle = WebHandle::new();
|
let web_handle = WebHandle::new();
|
||||||
web_handle.start("canvas").await.unwrap()
|
web_handle.start("canvas").await.unwrap()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
18
src/main.rs
18
src/main.rs
@ -12,15 +12,15 @@ mod widgets;
|
|||||||
// For running the program natively! (Because why not?)
|
// For running the program natively! (Because why not?)
|
||||||
#[cfg(not(target_arch = "wasm32"))]
|
#[cfg(not(target_arch = "wasm32"))]
|
||||||
fn main() -> eframe::Result<()> {
|
fn main() -> eframe::Result<()> {
|
||||||
let subscriber = tracing_subscriber::FmtSubscriber::builder()
|
let subscriber = tracing_subscriber::FmtSubscriber::builder()
|
||||||
.with_max_level(tracing::Level::INFO)
|
.with_max_level(tracing::Level::INFO)
|
||||||
.finish();
|
.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(
|
eframe::run_native(
|
||||||
"(Yet-to-be-named) Graphing Software",
|
"(Yet-to-be-named) Graphing Software",
|
||||||
eframe::NativeOptions::default(),
|
eframe::NativeOptions::default(),
|
||||||
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
|
Box::new(|cc| Box::new(math_app::MathApp::new(cc))),
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|||||||
929
src/math_app.rs
929
src/math_app.rs
File diff suppressed because it is too large
Load Diff
230
src/misc.rs
230
src/misc.rs
@ -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 egui_plot::{Line, PlotPoint, PlotPoints, Points};
|
||||||
use emath::Pos2;
|
use emath::Pos2;
|
||||||
use getrandom::getrandom;
|
use getrandom::getrandom;
|
||||||
@ -7,69 +7,69 @@ use parsing::FlatExWrapper;
|
|||||||
|
|
||||||
/// Implements traits that are useful when dealing with Vectors of egui's `Value`
|
/// Implements traits that are useful when dealing with Vectors of egui's `Value`
|
||||||
pub trait EguiHelper {
|
pub trait EguiHelper {
|
||||||
/// Converts to `egui::plot::Values`
|
/// Converts to `egui::plot::Values`
|
||||||
fn to_values(self) -> PlotPoints;
|
fn to_values(self) -> PlotPoints;
|
||||||
|
|
||||||
/// Converts to `egui::plot::Line`
|
/// Converts to `egui::plot::Line`
|
||||||
fn to_line(self) -> Line;
|
fn to_line(self) -> Line;
|
||||||
|
|
||||||
/// Converts to `egui::plot::Points`
|
/// Converts to `egui::plot::Points`
|
||||||
fn to_points(self) -> Points;
|
fn to_points(self) -> Points;
|
||||||
|
|
||||||
/// Converts Vector of Values into vector of tuples
|
/// Converts Vector of Values into vector of tuples
|
||||||
fn to_tuple(self) -> Vec<(f64, f64)>;
|
fn to_tuple(self) -> Vec<(f64, f64)>;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl EguiHelper for Vec<PlotPoint> {
|
impl EguiHelper for Vec<PlotPoint> {
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn to_values(self) -> PlotPoints {
|
fn to_values(self) -> PlotPoints {
|
||||||
PlotPoints::from(unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<[f64; 2]>>(self) })
|
PlotPoints::from(unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<[f64; 2]>>(self) })
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn to_line(self) -> Line {
|
fn to_line(self) -> Line {
|
||||||
Line::new(self.to_values())
|
Line::new(self.to_values())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn to_points(self) -> Points {
|
fn to_points(self) -> Points {
|
||||||
Points::new(self.to_values())
|
Points::new(self.to_values())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
fn to_tuple(self) -> Vec<(f64, f64)> {
|
fn to_tuple(self) -> Vec<(f64, f64)> {
|
||||||
unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<(f64, f64)>>(self) }
|
unsafe { std::mem::transmute::<Vec<PlotPoint>, Vec<(f64, f64)>>(self) }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait Offset {
|
pub trait Offset {
|
||||||
fn offset_y(self, y_offset: f32) -> Pos2;
|
fn offset_y(self, y_offset: f32) -> Pos2;
|
||||||
fn offset_x(self, x_offset: f32) -> Pos2;
|
fn offset_x(self, x_offset: f32) -> Pos2;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Offset for Pos2 {
|
impl Offset for Pos2 {
|
||||||
fn offset_y(self, y_offset: f32) -> Pos2 {
|
fn offset_y(self, y_offset: f32) -> Pos2 {
|
||||||
Pos2 {
|
Pos2 {
|
||||||
x: self.x,
|
x: self.x,
|
||||||
y: self.y + y_offset,
|
y: self.y + y_offset,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn offset_x(self, x_offset: f32) -> Pos2 {
|
fn offset_x(self, x_offset: f32) -> Pos2 {
|
||||||
Pos2 {
|
Pos2 {
|
||||||
x: self.x + x_offset,
|
x: self.x + x_offset,
|
||||||
y: self.y,
|
y: self.y,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
/// Rounds f64 to `n` decimal places
|
/// Rounds f64 to `n` decimal places
|
||||||
pub fn decimal_round(x: f64, n: usize) -> f64 {
|
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
|
// round and devide in order to cutoff after the `n`th decimal place
|
||||||
(x * large_number).round() / large_number
|
(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)
|
/// `f_1` is f'(x) aka the derivative of f(x)
|
||||||
/// The function returns a Vector of `x` values where roots occur
|
/// The function returns a Vector of `x` values where roots occur
|
||||||
pub fn newtons_method_helper(
|
pub fn newtons_method_helper(
|
||||||
threshold: f64, range: &std::ops::Range<f64>, data: &[PlotPoint], f: &FlatExWrapper,
|
threshold: f64,
|
||||||
f_1: &FlatExWrapper,
|
range: &std::ops::Range<f64>,
|
||||||
|
data: &[PlotPoint],
|
||||||
|
f: &FlatExWrapper,
|
||||||
|
f_1: &FlatExWrapper,
|
||||||
) -> Vec<f64> {
|
) -> Vec<f64> {
|
||||||
data.iter()
|
data.iter()
|
||||||
.tuple_windows()
|
.tuple_windows()
|
||||||
.filter(|(prev, curr)| prev.y.is_finite() && curr.y.is_finite())
|
.filter(|(prev, curr)| prev.y.is_finite() && curr.y.is_finite())
|
||||||
.filter(|(prev, curr)| prev.y.signum() != curr.y.signum())
|
.filter(|(prev, curr)| prev.y.signum() != curr.y.signum())
|
||||||
.map(|(start, _)| start.x)
|
.map(|(start, _)| start.x)
|
||||||
.map(|x| newtons_method(f, f_1, x, range, threshold))
|
.map(|x| newtons_method(f, f_1, x, range, threshold))
|
||||||
.filter(|x| x.is_some())
|
.filter(|x| x.is_some())
|
||||||
.map(|x| unsafe { x.unwrap_unchecked() })
|
.map(|x| unsafe { x.unwrap_unchecked() })
|
||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// `range` is the range of valid x values (used to stop calculation when
|
/// `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)
|
/// `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
|
/// The function returns an `Option<f64>` of the x value at which a root occurs
|
||||||
pub fn newtons_method(
|
pub fn newtons_method(
|
||||||
f: &FlatExWrapper, f_1: &FlatExWrapper, start_x: f64, range: &std::ops::Range<f64>,
|
f: &FlatExWrapper,
|
||||||
threshold: f64,
|
f_1: &FlatExWrapper,
|
||||||
|
start_x: f64,
|
||||||
|
range: &std::ops::Range<f64>,
|
||||||
|
threshold: f64,
|
||||||
) -> Option<f64> {
|
) -> Option<f64> {
|
||||||
let mut x1: f64 = start_x;
|
let mut x1: f64 = start_x;
|
||||||
let mut x2: f64;
|
let mut x2: f64;
|
||||||
let mut derivative: f64;
|
let mut derivative: f64;
|
||||||
loop {
|
loop {
|
||||||
derivative = f_1.eval(&[x1]);
|
derivative = f_1.eval(&[x1]);
|
||||||
if !derivative.is_finite() {
|
if !derivative.is_finite() {
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
|
|
||||||
x2 = x1 - (f.eval(&[x1]) / derivative);
|
x2 = x1 - (f.eval(&[x1]) / derivative);
|
||||||
if !x2.is_finite() | !range.contains(&x2) {
|
if !x2.is_finite() | !range.contains(&x2) {
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
|
|
||||||
// If below threshold, break
|
// If below threshold, break
|
||||||
if (x2 - x1).abs() < threshold {
|
if (x2 - x1).abs() < threshold {
|
||||||
return Some(x2);
|
return Some(x2);
|
||||||
}
|
}
|
||||||
|
|
||||||
x1 = x2;
|
x1 = x2;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Inputs `Vec<Option<T>>` and outputs a `String` containing a pretty representation of the Vector
|
/// 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 {
|
pub fn option_vec_printer<T: ToString>(data: &[Option<T>]) -> String {
|
||||||
let formatted: String = data
|
let formatted: String = data
|
||||||
.iter()
|
.iter()
|
||||||
.map(|item| match item {
|
.map(|item| match item {
|
||||||
Some(x) => x.to_string(),
|
Some(x) => x.to_string(),
|
||||||
None => "None".to_owned(),
|
None => "None".to_owned(),
|
||||||
})
|
})
|
||||||
.join(", ");
|
.join(", ");
|
||||||
|
|
||||||
format!("[{}]", formatted)
|
format!("[{}]", formatted)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Returns a vector of length `max_i` starting at value `min_x` with step of `step`
|
/// 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> {
|
pub fn step_helper(max_i: usize, min_x: f64, step: f64) -> Vec<f64> {
|
||||||
(0..max_i)
|
(0..max_i)
|
||||||
.map(move |x: usize| (x as f64 * step) + min_x)
|
.map(move |x: usize| (x as f64 * step) + min_x)
|
||||||
.collect()
|
.collect()
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO: use in hovering over points
|
// TODO: use in hovering over points
|
||||||
/// Attempts to see what variable `x` is almost
|
/// Attempts to see what variable `x` is almost
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn almost_variable(x: f64) -> Option<char> {
|
pub fn almost_variable(x: f64) -> Option<char> {
|
||||||
const EPSILON: f32 = f32::EPSILON * 2.0;
|
const EPSILON: f32 = f32::EPSILON * 2.0;
|
||||||
if emath::almost_equal(x as f32, std::f32::consts::E, EPSILON) {
|
if emath::almost_equal(x as f32, std::f32::consts::E, EPSILON) {
|
||||||
Some('e')
|
Some('e')
|
||||||
} else if emath::almost_equal(x as f32, std::f32::consts::PI, EPSILON) {
|
} else if emath::almost_equal(x as f32, std::f32::consts::PI, EPSILON) {
|
||||||
Some('π')
|
Some('π')
|
||||||
} else {
|
} else {
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub const HASH_LENGTH: usize = 8;
|
pub const HASH_LENGTH: usize = 8;
|
||||||
@ -166,41 +172,41 @@ pub type HashBytes = [u8; HASH_LENGTH];
|
|||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn hashed_storage_create(hashbytes: HashBytes, data: &[u8]) -> String {
|
pub fn hashed_storage_create(hashbytes: HashBytes, data: &[u8]) -> String {
|
||||||
let combined_data = [hashbytes.to_vec(), data.to_vec()].concat();
|
let combined_data = [hashbytes.to_vec(), data.to_vec()].concat();
|
||||||
general_purpose::STANDARD.encode(combined_data)
|
general_purpose::STANDARD.encode(combined_data)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, Vec<u8>)> {
|
pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, Vec<u8>)> {
|
||||||
// Decode base64 data
|
// Decode base64 data
|
||||||
let decoded_bytes = general_purpose::STANDARD.decode(data).ok()?;
|
let decoded_bytes = general_purpose::STANDARD.decode(data).ok()?;
|
||||||
|
|
||||||
// Make sure data is long enough to decode
|
// Make sure data is long enough to decode
|
||||||
if HASH_LENGTH > decoded_bytes.len() {
|
if HASH_LENGTH > decoded_bytes.len() {
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Split hash and data
|
// Split hash and data
|
||||||
let (hash_bytes, data_bytes) = decoded_bytes.split_at(HASH_LENGTH);
|
let (hash_bytes, data_bytes) = decoded_bytes.split_at(HASH_LENGTH);
|
||||||
|
|
||||||
// Convert hash bytes to HashBytes
|
// Convert hash bytes to HashBytes
|
||||||
let hash: HashBytes = hash_bytes.try_into().ok()?;
|
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
|
/// Creates and returns random u64
|
||||||
pub fn random_u64() -> Result<u64, getrandom::Error> {
|
pub fn random_u64() -> Result<u64, getrandom::Error> {
|
||||||
// Buffer of 8 `u8`s that are later merged into one u64
|
// Buffer of 8 `u8`s that are later merged into one u64
|
||||||
let mut buf = [0u8; 8];
|
let mut buf = [0u8; 8];
|
||||||
// Populate buffer with random values
|
// Populate buffer with random values
|
||||||
getrandom(&mut buf)?;
|
getrandom(&mut buf)?;
|
||||||
// Merge buffer into u64
|
// Merge buffer into u64
|
||||||
Ok(u64::from_be_bytes(buf))
|
Ok(u64::from_be_bytes(buf))
|
||||||
}
|
}
|
||||||
|
|
||||||
include!(concat!(env!("OUT_DIR"), "/valid_chars.rs"));
|
include!(concat!(env!("OUT_DIR"), "/valid_chars.rs"));
|
||||||
|
|
||||||
pub fn is_valid_char(c: char) -> bool {
|
pub fn is_valid_char(c: char) -> bool {
|
||||||
c.is_alphanumeric() | VALID_EXTRA_CHARS.contains(&c)
|
c.is_alphanumeric() | VALID_EXTRA_CHARS.contains(&c)
|
||||||
}
|
}
|
||||||
|
|||||||
@ -2,19 +2,19 @@ use itertools::Itertools;
|
|||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn to_unicode_hash(c: char) -> String {
|
pub fn to_unicode_hash(c: char) -> String {
|
||||||
c.escape_unicode()
|
c.escape_unicode()
|
||||||
.to_string()
|
.to_string()
|
||||||
.replace(r"\\u{", "")
|
.replace(r"\\u{", "")
|
||||||
.replace(['{', '}'], "")
|
.replace(['{', '}'], "")
|
||||||
.to_uppercase()
|
.to_uppercase()
|
||||||
}
|
}
|
||||||
|
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
pub fn to_chars_array(chars: Vec<char>) -> String {
|
pub fn to_chars_array(chars: Vec<char>) -> String {
|
||||||
"[".to_string()
|
"[".to_string()
|
||||||
+ &chars
|
+ &chars
|
||||||
.iter()
|
.iter()
|
||||||
.map(|c| format!("'{}'", c.escape_unicode()))
|
.map(|c| format!("'{}'", c.escape_unicode()))
|
||||||
.join(", ")
|
.join(", ")
|
||||||
+ "]"
|
+ "]"
|
||||||
}
|
}
|
||||||
|
|||||||
@ -3,12 +3,15 @@ use egui::{Id, InnerResponse};
|
|||||||
|
|
||||||
/// Creates an area ontop of a widget with an y offset
|
/// Creates an area ontop of a widget with an y offset
|
||||||
pub fn widgets_ontop<R>(
|
pub fn widgets_ontop<R>(
|
||||||
ui: &egui::Ui, id: Id, re: &egui::Response, y_offset: f32,
|
ui: &egui::Ui,
|
||||||
add_contents: impl FnOnce(&mut egui::Ui) -> R,
|
id: Id,
|
||||||
|
re: &egui::Response,
|
||||||
|
y_offset: f32,
|
||||||
|
add_contents: impl FnOnce(&mut egui::Ui) -> R,
|
||||||
) -> InnerResponse<R> {
|
) -> InnerResponse<R> {
|
||||||
let area = egui::Area::new(id)
|
let area = egui::Area::new(id)
|
||||||
.fixed_pos(re.rect.min.offset_y(y_offset))
|
.fixed_pos(re.rect.min.offset_y(y_offset))
|
||||||
.order(egui::Order::Foreground);
|
.order(egui::Order::Foreground);
|
||||||
|
|
||||||
area.show(ui.ctx(), |ui| add_contents(ui))
|
area.show(ui.ctx(), |ui| add_contents(ui))
|
||||||
}
|
}
|
||||||
|
|||||||
@ -1,159 +1,159 @@
|
|||||||
use parsing::{AutoComplete, Hint, Movement};
|
use parsing::{AutoComplete, Hint, Movement};
|
||||||
|
|
||||||
enum Action<'a> {
|
enum Action<'a> {
|
||||||
AssertIndex(usize),
|
AssertIndex(usize),
|
||||||
AssertString(&'a str),
|
AssertString(&'a str),
|
||||||
AssertHint(&'a str),
|
AssertHint(&'a str),
|
||||||
SetString(&'a str),
|
SetString(&'a str),
|
||||||
Move(Movement),
|
Move(Movement),
|
||||||
}
|
}
|
||||||
use Action::*;
|
use Action::*;
|
||||||
|
|
||||||
fn ac_tester(actions: &[Action]) {
|
fn ac_tester(actions: &[Action]) {
|
||||||
let mut ac = AutoComplete::default();
|
let mut ac = AutoComplete::default();
|
||||||
for action in actions.iter() {
|
for action in actions.iter() {
|
||||||
match action {
|
match action {
|
||||||
AssertIndex(target_i) => {
|
AssertIndex(target_i) => {
|
||||||
if &ac.i != target_i {
|
if &ac.i != target_i {
|
||||||
panic!(
|
panic!(
|
||||||
"AssertIndex failed: Current: '{}' Expected: '{}'",
|
"AssertIndex failed: Current: '{}' Expected: '{}'",
|
||||||
ac.i, target_i
|
ac.i, target_i
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
AssertString(target_string) => {
|
AssertString(target_string) => {
|
||||||
if &ac.string != target_string {
|
if &ac.string != target_string {
|
||||||
panic!(
|
panic!(
|
||||||
"AssertString failed: Current: '{}' Expected: '{}'",
|
"AssertString failed: Current: '{}' Expected: '{}'",
|
||||||
ac.string, target_string
|
ac.string, target_string
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
AssertHint(target_hint) => match ac.hint {
|
AssertHint(target_hint) => match ac.hint {
|
||||||
Hint::None => {
|
Hint::None => {
|
||||||
if !target_hint.is_empty() {
|
if !target_hint.is_empty() {
|
||||||
panic!(
|
panic!(
|
||||||
"AssertHint failed on `Hint::None`: Expected: {}",
|
"AssertHint failed on `Hint::None`: Expected: {}",
|
||||||
target_hint
|
target_hint
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Hint::Many(hints) => {
|
Hint::Many(hints) => {
|
||||||
let hint = hints[ac.i];
|
let hint = hints[ac.i];
|
||||||
if &hint != target_hint {
|
if &hint != target_hint {
|
||||||
panic!(
|
panic!(
|
||||||
"AssertHint failed on `Hint::Many`: Current: '{}' (index: {}) Expected: '{}'",
|
"AssertHint failed on `Hint::Many`: Current: '{}' (index: {}) Expected: '{}'",
|
||||||
hint, ac.i, target_hint
|
hint, ac.i, target_hint
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Hint::Single(hint) => {
|
Hint::Single(hint) => {
|
||||||
if hint != target_hint {
|
if hint != target_hint {
|
||||||
panic!(
|
panic!(
|
||||||
"AssertHint failed on `Hint::Single`: Current: '{}' Expected: '{}'",
|
"AssertHint failed on `Hint::Single`: Current: '{}' Expected: '{}'",
|
||||||
hint, target_hint
|
hint, target_hint
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
SetString(target_string) => {
|
SetString(target_string) => {
|
||||||
ac.update_string(target_string);
|
ac.update_string(target_string);
|
||||||
}
|
}
|
||||||
Move(target_movement) => {
|
Move(target_movement) => {
|
||||||
ac.register_movement(target_movement);
|
ac.register_movement(target_movement);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn single() {
|
fn single() {
|
||||||
ac_tester(&[
|
ac_tester(&[
|
||||||
SetString(""),
|
SetString(""),
|
||||||
AssertHint("x^2"),
|
AssertHint("x^2"),
|
||||||
Move(Movement::Up),
|
Move(Movement::Up),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString(""),
|
AssertString(""),
|
||||||
AssertHint("x^2"),
|
AssertHint("x^2"),
|
||||||
Move(Movement::Down),
|
Move(Movement::Down),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString(""),
|
AssertString(""),
|
||||||
AssertHint("x^2"),
|
AssertHint("x^2"),
|
||||||
Move(Movement::Complete),
|
Move(Movement::Complete),
|
||||||
AssertString("x^2"),
|
AssertString("x^2"),
|
||||||
AssertHint(""),
|
AssertHint(""),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
]);
|
]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn multi() {
|
fn multi() {
|
||||||
ac_tester(&[
|
ac_tester(&[
|
||||||
SetString("s"),
|
SetString("s"),
|
||||||
AssertHint("in("),
|
AssertHint("in("),
|
||||||
Move(Movement::Up),
|
Move(Movement::Up),
|
||||||
AssertIndex(3),
|
AssertIndex(3),
|
||||||
AssertString("s"),
|
AssertString("s"),
|
||||||
AssertHint("ignum("),
|
AssertHint("ignum("),
|
||||||
Move(Movement::Down),
|
Move(Movement::Down),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString("s"),
|
AssertString("s"),
|
||||||
AssertHint("in("),
|
AssertHint("in("),
|
||||||
Move(Movement::Down),
|
Move(Movement::Down),
|
||||||
AssertIndex(1),
|
AssertIndex(1),
|
||||||
AssertString("s"),
|
AssertString("s"),
|
||||||
AssertHint("qrt("),
|
AssertHint("qrt("),
|
||||||
Move(Movement::Up),
|
Move(Movement::Up),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString("s"),
|
AssertString("s"),
|
||||||
AssertHint("in("),
|
AssertHint("in("),
|
||||||
Move(Movement::Complete),
|
Move(Movement::Complete),
|
||||||
AssertString("sin("),
|
AssertString("sin("),
|
||||||
AssertHint(")"),
|
AssertHint(")"),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
]);
|
]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn none() {
|
fn none() {
|
||||||
// string that should give no hints
|
// string that should give no hints
|
||||||
let random = "qwert987gybhj";
|
let random = "qwert987gybhj";
|
||||||
assert_eq!(parsing::generate_hint(random), &Hint::None);
|
assert_eq!(parsing::generate_hint(random), &Hint::None);
|
||||||
|
|
||||||
ac_tester(&[
|
ac_tester(&[
|
||||||
SetString(random),
|
SetString(random),
|
||||||
AssertHint(""),
|
AssertHint(""),
|
||||||
Move(Movement::Up),
|
Move(Movement::Up),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString(random),
|
AssertString(random),
|
||||||
AssertHint(""),
|
AssertHint(""),
|
||||||
Move(Movement::Down),
|
Move(Movement::Down),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString(random),
|
AssertString(random),
|
||||||
AssertHint(""),
|
AssertHint(""),
|
||||||
Move(Movement::Complete),
|
Move(Movement::Complete),
|
||||||
AssertString(random),
|
AssertString(random),
|
||||||
AssertHint(""),
|
AssertHint(""),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
]);
|
]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn parens() {
|
fn parens() {
|
||||||
ac_tester(&[
|
ac_tester(&[
|
||||||
SetString("sin(x"),
|
SetString("sin(x"),
|
||||||
AssertHint(")"),
|
AssertHint(")"),
|
||||||
Move(Movement::Up),
|
Move(Movement::Up),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString("sin(x"),
|
AssertString("sin(x"),
|
||||||
AssertHint(")"),
|
AssertHint(")"),
|
||||||
Move(Movement::Down),
|
Move(Movement::Down),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
AssertString("sin(x"),
|
AssertString("sin(x"),
|
||||||
AssertHint(")"),
|
AssertHint(")"),
|
||||||
Move(Movement::Complete),
|
Move(Movement::Complete),
|
||||||
AssertString("sin(x)"),
|
AssertString("sin(x)"),
|
||||||
AssertHint(""),
|
AssertHint(""),
|
||||||
AssertIndex(0),
|
AssertIndex(0),
|
||||||
]);
|
]);
|
||||||
}
|
}
|
||||||
|
|||||||
@ -1,262 +1,273 @@
|
|||||||
use ytbn_graphing_software::{AppSettings, EguiHelper, FunctionEntry, Riemann};
|
use ytbn_graphing_software::{AppSettings, EguiHelper, FunctionEntry, Riemann};
|
||||||
|
|
||||||
fn app_settings_constructor(
|
fn app_settings_constructor(
|
||||||
sum: Riemann, integral_min_x: f64, integral_max_x: f64, pixel_width: usize,
|
sum: Riemann,
|
||||||
integral_num: usize, min_x: f64, max_x: f64,
|
integral_min_x: f64,
|
||||||
|
integral_max_x: f64,
|
||||||
|
pixel_width: usize,
|
||||||
|
integral_num: usize,
|
||||||
|
min_x: f64,
|
||||||
|
max_x: f64,
|
||||||
) -> AppSettings {
|
) -> AppSettings {
|
||||||
AppSettings {
|
AppSettings {
|
||||||
riemann_sum: sum,
|
riemann_sum: sum,
|
||||||
integral_min_x,
|
integral_min_x,
|
||||||
integral_max_x,
|
integral_max_x,
|
||||||
min_x,
|
min_x,
|
||||||
max_x,
|
max_x,
|
||||||
integral_changed: true,
|
integral_changed: true,
|
||||||
integral_num,
|
integral_num,
|
||||||
do_extrema: false,
|
do_extrema: false,
|
||||||
do_roots: false,
|
do_roots: false,
|
||||||
plot_width: pixel_width,
|
plot_width: pixel_width,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
static BACK_TARGET: [(f64, f64); 11] = [
|
static BACK_TARGET: [(f64, f64); 11] = [
|
||||||
(-1.0, 1.0),
|
(-1.0, 1.0),
|
||||||
(-0.8, 0.6400000000000001),
|
(-0.8, 0.6400000000000001),
|
||||||
(-0.6, 0.36),
|
(-0.6, 0.36),
|
||||||
(-0.4, 0.16000000000000003),
|
(-0.4, 0.16000000000000003),
|
||||||
(-0.19999999999999996, 0.03999999999999998),
|
(-0.19999999999999996, 0.03999999999999998),
|
||||||
(0.0, 0.0),
|
(0.0, 0.0),
|
||||||
(0.19999999999999996, 0.03999999999999998),
|
(0.19999999999999996, 0.03999999999999998),
|
||||||
(0.3999999999999999, 0.15999999999999992),
|
(0.3999999999999999, 0.15999999999999992),
|
||||||
(0.6000000000000001, 0.3600000000000001),
|
(0.6000000000000001, 0.3600000000000001),
|
||||||
(0.8, 0.6400000000000001),
|
(0.8, 0.6400000000000001),
|
||||||
(1.0, 1.0),
|
(1.0, 1.0),
|
||||||
];
|
];
|
||||||
|
|
||||||
static DERIVATIVE_TARGET: [(f64, f64); 11] = [
|
static DERIVATIVE_TARGET: [(f64, f64); 11] = [
|
||||||
(-1.0, -2.0),
|
(-1.0, -2.0),
|
||||||
(-0.8, -1.6),
|
(-0.8, -1.6),
|
||||||
(-0.6, -1.2),
|
(-0.6, -1.2),
|
||||||
(-0.4, -0.8),
|
(-0.4, -0.8),
|
||||||
(-0.19999999999999996, -0.3999999999999999),
|
(-0.19999999999999996, -0.3999999999999999),
|
||||||
(0.0, 0.0),
|
(0.0, 0.0),
|
||||||
(0.19999999999999996, 0.3999999999999999),
|
(0.19999999999999996, 0.3999999999999999),
|
||||||
(0.3999999999999999, 0.7999999999999998),
|
(0.3999999999999999, 0.7999999999999998),
|
||||||
(0.6000000000000001, 1.2000000000000002),
|
(0.6000000000000001, 1.2000000000000002),
|
||||||
(0.8, 1.6),
|
(0.8, 1.6),
|
||||||
(1.0, 2.0),
|
(1.0, 2.0),
|
||||||
];
|
];
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
fn do_test(sum: Riemann, area_target: f64) {
|
fn do_test(sum: Riemann, area_target: f64) {
|
||||||
let settings = app_settings_constructor(sum, -1.0, 1.0, 10, 10, -1.0, 1.0);
|
let settings = app_settings_constructor(sum, -1.0, 1.0, 10, 10, -1.0, 1.0);
|
||||||
|
|
||||||
let mut function = FunctionEntry::default();
|
let mut function = FunctionEntry::default();
|
||||||
function.update_string("x^2");
|
function.update_string("x^2");
|
||||||
function.integral = true;
|
function.integral = true;
|
||||||
function.derivative = true;
|
function.derivative = true;
|
||||||
|
|
||||||
let mut settings = settings;
|
let mut settings = settings;
|
||||||
{
|
{
|
||||||
function.calculate(true, true, false, settings);
|
function.calculate(true, true, false, settings);
|
||||||
assert!(!function.back_data.is_empty());
|
assert!(!function.back_data.is_empty());
|
||||||
assert_eq!(function.back_data.len(), settings.plot_width + 1);
|
assert_eq!(function.back_data.len(), settings.plot_width + 1);
|
||||||
|
|
||||||
assert!(function.integral);
|
assert!(function.integral);
|
||||||
assert!(function.derivative);
|
assert!(function.derivative);
|
||||||
|
|
||||||
assert_eq!(!function.root_data.is_empty(), settings.do_roots);
|
assert_eq!(!function.root_data.is_empty(), settings.do_roots);
|
||||||
assert_eq!(!function.extrema_data.is_empty(), settings.do_extrema);
|
assert_eq!(!function.extrema_data.is_empty(), settings.do_extrema);
|
||||||
assert!(!function.derivative_data.is_empty());
|
assert!(!function.derivative_data.is_empty());
|
||||||
assert!(function.integral_data.is_some());
|
assert!(function.integral_data.is_some());
|
||||||
|
|
||||||
assert_eq!(function.integral_data.clone().unwrap().1, area_target);
|
assert_eq!(function.integral_data.clone().unwrap().1, area_target);
|
||||||
|
|
||||||
let a = function.derivative_data.clone().to_tuple();
|
let a = function.derivative_data.clone().to_tuple();
|
||||||
|
|
||||||
assert_eq!(a.len(), DERIVATIVE_TARGET.len());
|
assert_eq!(a.len(), DERIVATIVE_TARGET.len());
|
||||||
|
|
||||||
for i in 0..a.len() {
|
for i in 0..a.len() {
|
||||||
if !emath::almost_equal(a[i].0 as f32, DERIVATIVE_TARGET[i].0 as f32, f32::EPSILON)
|
if !emath::almost_equal(a[i].0 as f32, DERIVATIVE_TARGET[i].0 as f32, f32::EPSILON)
|
||||||
| !emath::almost_equal(a[i].1 as f32, DERIVATIVE_TARGET[i].1 as f32, f32::EPSILON)
|
| !emath::almost_equal(a[i].1 as f32, DERIVATIVE_TARGET[i].1 as f32, f32::EPSILON)
|
||||||
{
|
{
|
||||||
panic!("Expected: {:?}\nGot: {:?}", a, DERIVATIVE_TARGET);
|
panic!("Expected: {:?}\nGot: {:?}", a, DERIVATIVE_TARGET);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
let a_1 = function.back_data.clone().to_tuple();
|
let a_1 = function.back_data.clone().to_tuple();
|
||||||
|
|
||||||
assert_eq!(a_1.len(), BACK_TARGET.len());
|
assert_eq!(a_1.len(), BACK_TARGET.len());
|
||||||
|
|
||||||
assert_eq!(a.len(), BACK_TARGET.len());
|
assert_eq!(a.len(), BACK_TARGET.len());
|
||||||
|
|
||||||
for i in 0..a.len() {
|
for i in 0..a.len() {
|
||||||
if !emath::almost_equal(a_1[i].0 as f32, BACK_TARGET[i].0 as f32, f32::EPSILON)
|
if !emath::almost_equal(a_1[i].0 as f32, BACK_TARGET[i].0 as f32, f32::EPSILON)
|
||||||
| !emath::almost_equal(a_1[i].1 as f32, BACK_TARGET[i].1 as f32, f32::EPSILON)
|
| !emath::almost_equal(a_1[i].1 as f32, BACK_TARGET[i].1 as f32, f32::EPSILON)
|
||||||
{
|
{
|
||||||
panic!("Expected: {:?}\nGot: {:?}", a_1, BACK_TARGET);
|
panic!("Expected: {:?}\nGot: {:?}", a_1, BACK_TARGET);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
settings.min_x += 1.0;
|
settings.min_x += 1.0;
|
||||||
settings.max_x += 1.0;
|
settings.max_x += 1.0;
|
||||||
function.calculate(true, true, false, settings);
|
function.calculate(true, true, false, settings);
|
||||||
|
|
||||||
let a = function
|
let a = function
|
||||||
.derivative_data
|
.derivative_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_tuple()
|
.to_tuple()
|
||||||
.iter()
|
.iter()
|
||||||
.take(6)
|
.take(6)
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
let b = DERIVATIVE_TARGET
|
let b = DERIVATIVE_TARGET
|
||||||
.iter()
|
.iter()
|
||||||
.rev()
|
.rev()
|
||||||
.take(6)
|
.take(6)
|
||||||
.rev()
|
.rev()
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
assert_eq!(a.len(), b.len());
|
assert_eq!(a.len(), b.len());
|
||||||
|
|
||||||
for i in 0..a.len() {
|
for i in 0..a.len() {
|
||||||
if !emath::almost_equal(a[i].0 as f32, b[i].0 as f32, f32::EPSILON)
|
if !emath::almost_equal(a[i].0 as f32, b[i].0 as f32, f32::EPSILON)
|
||||||
| !emath::almost_equal(a[i].1 as f32, b[i].1 as f32, f32::EPSILON)
|
| !emath::almost_equal(a[i].1 as f32, b[i].1 as f32, f32::EPSILON)
|
||||||
{
|
{
|
||||||
panic!("Expected: {:?}\nGot: {:?}", a, b);
|
panic!("Expected: {:?}\nGot: {:?}", a, b);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
let a_1 = function
|
let a_1 = function
|
||||||
.back_data
|
.back_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_tuple()
|
.to_tuple()
|
||||||
.iter()
|
.iter()
|
||||||
.take(6)
|
.take(6)
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
let b_1 = BACK_TARGET
|
let b_1 = BACK_TARGET
|
||||||
.iter()
|
.iter()
|
||||||
.rev()
|
.rev()
|
||||||
.take(6)
|
.take(6)
|
||||||
.rev()
|
.rev()
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
assert_eq!(a_1.len(), b_1.len());
|
assert_eq!(a_1.len(), b_1.len());
|
||||||
|
|
||||||
assert_eq!(a.len(), b_1.len());
|
assert_eq!(a.len(), b_1.len());
|
||||||
|
|
||||||
for i in 0..a.len() {
|
for i in 0..a.len() {
|
||||||
if !emath::almost_equal(a_1[i].0 as f32, b_1[i].0 as f32, f32::EPSILON)
|
if !emath::almost_equal(a_1[i].0 as f32, b_1[i].0 as f32, f32::EPSILON)
|
||||||
| !emath::almost_equal(a_1[i].1 as f32, b_1[i].1 as f32, f32::EPSILON)
|
| !emath::almost_equal(a_1[i].1 as f32, b_1[i].1 as f32, f32::EPSILON)
|
||||||
{
|
{
|
||||||
panic!("Expected: {:?}\nGot: {:?}", a_1, b_1);
|
panic!("Expected: {:?}\nGot: {:?}", a_1, b_1);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
settings.min_x -= 2.0;
|
settings.min_x -= 2.0;
|
||||||
settings.max_x -= 2.0;
|
settings.max_x -= 2.0;
|
||||||
function.calculate(true, true, false, settings);
|
function.calculate(true, true, false, settings);
|
||||||
|
|
||||||
let a = function
|
let a = function
|
||||||
.derivative_data
|
.derivative_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_tuple()
|
.to_tuple()
|
||||||
.iter()
|
.iter()
|
||||||
.rev()
|
.rev()
|
||||||
.take(6)
|
.take(6)
|
||||||
.rev()
|
.rev()
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
let b = DERIVATIVE_TARGET
|
let b = DERIVATIVE_TARGET
|
||||||
.iter()
|
.iter()
|
||||||
.take(6)
|
.take(6)
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
assert_eq!(a.len(), b.len());
|
assert_eq!(a.len(), b.len());
|
||||||
|
|
||||||
for i in 0..a.len() {
|
for i in 0..a.len() {
|
||||||
if !emath::almost_equal(a[i].0 as f32, b[i].0 as f32, f32::EPSILON)
|
if !emath::almost_equal(a[i].0 as f32, b[i].0 as f32, f32::EPSILON)
|
||||||
| !emath::almost_equal(a[i].1 as f32, b[i].1 as f32, f32::EPSILON)
|
| !emath::almost_equal(a[i].1 as f32, b[i].1 as f32, f32::EPSILON)
|
||||||
{
|
{
|
||||||
panic!("Expected: {:?}\nGot: {:?}", a, b);
|
panic!("Expected: {:?}\nGot: {:?}", a, b);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
let a_1 = function
|
let a_1 = function
|
||||||
.back_data
|
.back_data
|
||||||
.clone()
|
.clone()
|
||||||
.to_tuple()
|
.to_tuple()
|
||||||
.iter()
|
.iter()
|
||||||
.rev()
|
.rev()
|
||||||
.take(6)
|
.take(6)
|
||||||
.rev()
|
.rev()
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
let b_1 = BACK_TARGET
|
let b_1 = BACK_TARGET
|
||||||
.iter()
|
.iter()
|
||||||
.take(6)
|
.take(6)
|
||||||
.cloned()
|
.cloned()
|
||||||
.collect::<Vec<(f64, f64)>>();
|
.collect::<Vec<(f64, f64)>>();
|
||||||
|
|
||||||
assert_eq!(a_1.len(), b_1.len());
|
assert_eq!(a_1.len(), b_1.len());
|
||||||
|
|
||||||
assert_eq!(a.len(), b_1.len());
|
assert_eq!(a.len(), b_1.len());
|
||||||
|
|
||||||
for i in 0..a.len() {
|
for i in 0..a.len() {
|
||||||
if !emath::almost_equal(a_1[i].0 as f32, b_1[i].0 as f32, f32::EPSILON)
|
if !emath::almost_equal(a_1[i].0 as f32, b_1[i].0 as f32, f32::EPSILON)
|
||||||
| !emath::almost_equal(a_1[i].1 as f32, b_1[i].1 as f32, f32::EPSILON)
|
| !emath::almost_equal(a_1[i].1 as f32, b_1[i].1 as f32, f32::EPSILON)
|
||||||
{
|
{
|
||||||
panic!("Expected: {:?}\nGot: {:?}", a_1, b_1);
|
panic!("Expected: {:?}\nGot: {:?}", a_1, b_1);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
function.update_string("sin(x)");
|
function.update_string("sin(x)");
|
||||||
assert!(function.get_test_result().is_none());
|
assert!(function.get_test_result().is_none());
|
||||||
assert_eq!(&function.raw_func_str, "sin(x)");
|
assert_eq!(&function.raw_func_str, "sin(x)");
|
||||||
|
|
||||||
function.integral = false;
|
function.integral = false;
|
||||||
function.derivative = false;
|
function.derivative = false;
|
||||||
|
|
||||||
assert!(!function.integral);
|
assert!(!function.integral);
|
||||||
assert!(!function.derivative);
|
assert!(!function.derivative);
|
||||||
|
|
||||||
assert!(function.back_data.is_empty());
|
assert!(function.back_data.is_empty());
|
||||||
assert!(function.integral_data.is_none());
|
assert!(function.integral_data.is_none());
|
||||||
assert!(function.root_data.is_empty());
|
assert!(function.root_data.is_empty());
|
||||||
assert!(function.extrema_data.is_empty());
|
assert!(function.extrema_data.is_empty());
|
||||||
assert!(function.derivative_data.is_empty());
|
assert!(function.derivative_data.is_empty());
|
||||||
|
|
||||||
settings.min_x -= 1.0;
|
settings.min_x -= 1.0;
|
||||||
settings.max_x -= 1.0;
|
settings.max_x -= 1.0;
|
||||||
|
|
||||||
function.calculate(true, true, false, settings);
|
function.calculate(true, true, false, settings);
|
||||||
|
|
||||||
assert!(!function.back_data.is_empty());
|
assert!(!function.back_data.is_empty());
|
||||||
assert!(function.integral_data.is_none());
|
assert!(function.integral_data.is_none());
|
||||||
assert!(function.root_data.is_empty());
|
assert!(function.root_data.is_empty());
|
||||||
assert!(function.extrema_data.is_empty());
|
assert!(function.extrema_data.is_empty());
|
||||||
assert!(!function.derivative_data.is_empty());
|
assert!(!function.derivative_data.is_empty());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn left_function() { do_test(Riemann::Left, 0.9600000000000001); }
|
fn left_function() {
|
||||||
|
do_test(Riemann::Left, 0.9600000000000001);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn middle_function() { do_test(Riemann::Middle, 0.92); }
|
fn middle_function() {
|
||||||
|
do_test(Riemann::Middle, 0.92);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn right_function() { do_test(Riemann::Right, 0.8800000000000001); }
|
fn right_function() {
|
||||||
|
do_test(Riemann::Right, 0.8800000000000001);
|
||||||
|
}
|
||||||
|
|||||||
172
tests/misc.rs
172
tests/misc.rs
@ -2,90 +2,90 @@
|
|||||||
/// Ensures [`decimal_round`] returns correct values
|
/// Ensures [`decimal_round`] returns correct values
|
||||||
#[test]
|
#[test]
|
||||||
fn decimal_round() {
|
fn decimal_round() {
|
||||||
use ytbn_graphing_software::decimal_round;
|
use ytbn_graphing_software::decimal_round;
|
||||||
|
|
||||||
assert_eq!(decimal_round(0.00001, 1), 0.0);
|
assert_eq!(decimal_round(0.00001, 1), 0.0);
|
||||||
assert_eq!(decimal_round(0.00001, 2), 0.0);
|
assert_eq!(decimal_round(0.00001, 2), 0.0);
|
||||||
assert_eq!(decimal_round(0.00001, 3), 0.0);
|
assert_eq!(decimal_round(0.00001, 3), 0.0);
|
||||||
assert_eq!(decimal_round(0.00001, 4), 0.0);
|
assert_eq!(decimal_round(0.00001, 4), 0.0);
|
||||||
assert_eq!(decimal_round(0.00001, 5), 0.00001);
|
assert_eq!(decimal_round(0.00001, 5), 0.00001);
|
||||||
|
|
||||||
assert_eq!(decimal_round(0.12345, 1), 0.1);
|
assert_eq!(decimal_round(0.12345, 1), 0.1);
|
||||||
assert_eq!(decimal_round(0.12345, 2), 0.12);
|
assert_eq!(decimal_round(0.12345, 2), 0.12);
|
||||||
assert_eq!(decimal_round(0.12345, 3), 0.123);
|
assert_eq!(decimal_round(0.12345, 3), 0.123);
|
||||||
assert_eq!(decimal_round(0.12345, 4), 0.1235); // rounds up
|
assert_eq!(decimal_round(0.12345, 4), 0.1235); // rounds up
|
||||||
assert_eq!(decimal_round(0.12345, 5), 0.12345);
|
assert_eq!(decimal_round(0.12345, 5), 0.12345);
|
||||||
|
|
||||||
assert_eq!(decimal_round(1.9, 0), 2.0);
|
assert_eq!(decimal_round(1.9, 0), 2.0);
|
||||||
assert_eq!(decimal_round(1.9, 1), 1.9);
|
assert_eq!(decimal_round(1.9, 1), 1.9);
|
||||||
}
|
}
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn step_helper() {
|
fn step_helper() {
|
||||||
use ytbn_graphing_software::step_helper;
|
use ytbn_graphing_software::step_helper;
|
||||||
|
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
step_helper(10, 2.0, 3.0),
|
step_helper(10, 2.0, 3.0),
|
||||||
vec![2.0, 5.0, 8.0, 11.0, 14.0, 17.0, 20.0, 23.0, 26.0, 29.0]
|
vec![2.0, 5.0, 8.0, 11.0, 14.0, 17.0, 20.0, 23.0, 26.0, 29.0]
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Tests [`option_vec_printer`]
|
/// Tests [`option_vec_printer`]
|
||||||
#[test]
|
#[test]
|
||||||
fn option_vec_printer() {
|
fn option_vec_printer() {
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
use ytbn_graphing_software::option_vec_printer;
|
use ytbn_graphing_software::option_vec_printer;
|
||||||
|
|
||||||
let values_strings: HashMap<Vec<Option<&str>>, &str> = HashMap::from([
|
let values_strings: HashMap<Vec<Option<&str>>, &str> = HashMap::from([
|
||||||
(vec![None], "[None]"),
|
(vec![None], "[None]"),
|
||||||
(vec![Some("text"), None], "[text, None]"),
|
(vec![Some("text"), None], "[text, None]"),
|
||||||
(vec![None, None], "[None, None]"),
|
(vec![None, None], "[None, None]"),
|
||||||
(vec![Some("text1"), Some("text2")], "[text1, text2]"),
|
(vec![Some("text1"), Some("text2")], "[text1, text2]"),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values_strings {
|
for (key, value) in values_strings {
|
||||||
assert_eq!(option_vec_printer(&key), value);
|
assert_eq!(option_vec_printer(&key), value);
|
||||||
}
|
}
|
||||||
|
|
||||||
let values_nums = HashMap::from([
|
let values_nums = HashMap::from([
|
||||||
(vec![Some(10)], "[10]"),
|
(vec![Some(10)], "[10]"),
|
||||||
(vec![Some(10), None], "[10, None]"),
|
(vec![Some(10), None], "[10, None]"),
|
||||||
(vec![None, Some(10)], "[None, 10]"),
|
(vec![None, Some(10)], "[None, 10]"),
|
||||||
(vec![Some(10), Some(100)], "[10, 100]"),
|
(vec![Some(10), Some(100)], "[10, 100]"),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values_nums {
|
for (key, value) in values_nums {
|
||||||
assert_eq!(option_vec_printer(&key), value);
|
assert_eq!(option_vec_printer(&key), value);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn hashed_storage() {
|
fn hashed_storage() {
|
||||||
use ytbn_graphing_software::{hashed_storage_create, hashed_storage_read};
|
use ytbn_graphing_software::{hashed_storage_create, hashed_storage_read};
|
||||||
|
|
||||||
let commit = "abcdefeg".chars().map(|c| c as u8).collect::<Vec<u8>>();
|
let commit = "abcdefeg".chars().map(|c| c as u8).collect::<Vec<u8>>();
|
||||||
let data = "really cool data"
|
let data = "really cool data"
|
||||||
.chars()
|
.chars()
|
||||||
.map(|c| c as u8)
|
.map(|c| c as u8)
|
||||||
.collect::<Vec<u8>>();
|
.collect::<Vec<u8>>();
|
||||||
let storage_tmp: [u8; 8] = commit
|
let storage_tmp: [u8; 8] = commit
|
||||||
.as_slice()
|
.as_slice()
|
||||||
.try_into()
|
.try_into()
|
||||||
.expect("cannot turn into [u8; 8]");
|
.expect("cannot turn into [u8; 8]");
|
||||||
let storage = hashed_storage_create(storage_tmp, data.as_slice());
|
let storage = hashed_storage_create(storage_tmp, data.as_slice());
|
||||||
|
|
||||||
let read = hashed_storage_read(&storage);
|
let read = hashed_storage_read(&storage);
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
read.map(|(a, b)| (a.to_vec(), b.to_vec())),
|
read.map(|(a, b)| (a.to_vec(), b.to_vec())),
|
||||||
Some((commit.to_vec(), data.to_vec()))
|
Some((commit.to_vec(), data.to_vec()))
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn invalid_hashed_storage() {
|
fn invalid_hashed_storage() {
|
||||||
use ytbn_graphing_software::hashed_storage_read;
|
use ytbn_graphing_software::hashed_storage_read;
|
||||||
assert_eq!(hashed_storage_read("aaaa"), None);
|
assert_eq!(hashed_storage_read("aaaa"), None);
|
||||||
}
|
}
|
||||||
|
|
||||||
// #[test]
|
// #[test]
|
||||||
@ -141,45 +141,45 @@ fn invalid_hashed_storage() {
|
|||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn newtons_method() {
|
fn newtons_method() {
|
||||||
use parsing::BackingFunction;
|
use parsing::BackingFunction;
|
||||||
use parsing::FlatExWrapper;
|
use parsing::FlatExWrapper;
|
||||||
fn get_flatexwrapper(func: &str) -> FlatExWrapper {
|
fn get_flatexwrapper(func: &str) -> FlatExWrapper {
|
||||||
let mut backing_func = BackingFunction::new(func).unwrap();
|
let mut backing_func = BackingFunction::new(func).unwrap();
|
||||||
backing_func.get_function_derivative(0).clone()
|
backing_func.get_function_derivative(0).clone()
|
||||||
}
|
}
|
||||||
|
|
||||||
use ytbn_graphing_software::newtons_method;
|
use ytbn_graphing_software::newtons_method;
|
||||||
|
|
||||||
let data = newtons_method(
|
let data = newtons_method(
|
||||||
&get_flatexwrapper("x^2 -1"),
|
&get_flatexwrapper("x^2 -1"),
|
||||||
&get_flatexwrapper("2x"),
|
&get_flatexwrapper("2x"),
|
||||||
3.0,
|
3.0,
|
||||||
&(0.0..5.0),
|
&(0.0..5.0),
|
||||||
f64::EPSILON,
|
f64::EPSILON,
|
||||||
);
|
);
|
||||||
assert_eq!(data, Some(1.0));
|
assert_eq!(data, Some(1.0));
|
||||||
|
|
||||||
let data = newtons_method(
|
let data = newtons_method(
|
||||||
&get_flatexwrapper("sin(x)"),
|
&get_flatexwrapper("sin(x)"),
|
||||||
&get_flatexwrapper("cos(x)"),
|
&get_flatexwrapper("cos(x)"),
|
||||||
3.0,
|
3.0,
|
||||||
&(2.95..3.18),
|
&(2.95..3.18),
|
||||||
f64::EPSILON,
|
f64::EPSILON,
|
||||||
);
|
);
|
||||||
assert_eq!(data, Some(std::f64::consts::PI));
|
assert_eq!(data, Some(std::f64::consts::PI));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn to_unicode_hash() {
|
fn to_unicode_hash() {
|
||||||
use ytbn_graphing_software::to_unicode_hash;
|
use ytbn_graphing_software::to_unicode_hash;
|
||||||
assert_eq!(to_unicode_hash('\u{1f31e}'), "\\U1F31E");
|
assert_eq!(to_unicode_hash('\u{1f31e}'), "\\U1F31E");
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn to_chars_array() {
|
fn to_chars_array() {
|
||||||
use ytbn_graphing_software::to_chars_array;
|
use ytbn_graphing_software::to_chars_array;
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
to_chars_array(vec!['\u{1f31e}', '\u{2d12c}']),
|
to_chars_array(vec!['\u{1f31e}', '\u{2d12c}']),
|
||||||
r"['\u{1f31e}', '\u{2d12c}']"
|
r"['\u{1f31e}', '\u{2d12c}']"
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|||||||
428
tests/parsing.rs
428
tests/parsing.rs
@ -3,292 +3,292 @@ use std::collections::HashMap;
|
|||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn hashmap_gen_test() {
|
fn hashmap_gen_test() {
|
||||||
let data = ["time", "text", "test"];
|
let data = ["time", "text", "test"];
|
||||||
let expect = vec![
|
let expect = vec![
|
||||||
("t", "Hint::Many(&[\"ime(\", \"ext(\", \"est(\"])"),
|
("t", "Hint::Many(&[\"ime(\", \"ext(\", \"est(\"])"),
|
||||||
("te", "Hint::Many(&[\"xt(\", \"st(\"])"),
|
("te", "Hint::Many(&[\"xt(\", \"st(\"])"),
|
||||||
("tes", "Hint::Single(\"t(\")"),
|
("tes", "Hint::Single(\"t(\")"),
|
||||||
("test", "Hint::Single(\"(\")"),
|
("test", "Hint::Single(\"(\")"),
|
||||||
("tex", "Hint::Single(\"t(\")"),
|
("tex", "Hint::Single(\"t(\")"),
|
||||||
("text", "Hint::Single(\"(\")"),
|
("text", "Hint::Single(\"(\")"),
|
||||||
("ti", "Hint::Single(\"me(\")"),
|
("ti", "Hint::Single(\"me(\")"),
|
||||||
("tim", "Hint::Single(\"e(\")"),
|
("tim", "Hint::Single(\"e(\")"),
|
||||||
("time", "Hint::Single(\"(\")"),
|
("time", "Hint::Single(\"(\")"),
|
||||||
];
|
];
|
||||||
|
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
parsing::compile_hashmap(data.iter().map(|e| e.to_string()).collect()),
|
parsing::compile_hashmap(data.iter().map(|e| e.to_string()).collect()),
|
||||||
expect
|
expect
|
||||||
.iter()
|
.iter()
|
||||||
.map(|(a, b)| (a.to_string(), b.to_string()))
|
.map(|(a, b)| (a.to_string(), b.to_string()))
|
||||||
.collect::<Vec<(String, String)>>()
|
.collect::<Vec<(String, String)>>()
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Returns if function with string `func_str` is valid after processing through [`process_func_str`]
|
/// Returns if function with string `func_str` is valid after processing through [`process_func_str`]
|
||||||
fn func_is_valid(func_str: &str) -> bool {
|
fn func_is_valid(func_str: &str) -> bool {
|
||||||
parsing::BackingFunction::new(&parsing::process_func_str(func_str)).is_ok()
|
parsing::BackingFunction::new(&parsing::process_func_str(func_str)).is_ok()
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Used for testing: passes function to [`process_func_str`] before running [`test_func`]. if `expect_valid` == `true`, it expects no errors to be created.
|
/// Used for testing: passes function to [`process_func_str`] before running [`test_func`]. if `expect_valid` == `true`, it expects no errors to be created.
|
||||||
fn test_func_helper(func_str: &str, expect_valid: bool) {
|
fn test_func_helper(func_str: &str, expect_valid: bool) {
|
||||||
let is_valid = func_is_valid(func_str);
|
let is_valid = func_is_valid(func_str);
|
||||||
let string = format!(
|
let string = format!(
|
||||||
"function: {} (expected: {}, got: {})",
|
"function: {} (expected: {}, got: {})",
|
||||||
func_str, expect_valid, is_valid
|
func_str, expect_valid, is_valid
|
||||||
);
|
);
|
||||||
|
|
||||||
if is_valid == expect_valid {
|
if is_valid == expect_valid {
|
||||||
println!("{}", string);
|
println!("{}", string);
|
||||||
} else {
|
} else {
|
||||||
panic!("{}", string);
|
panic!("{}", string);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Tests to make sure functions that are expected to succeed, succeed.
|
/// Tests to make sure functions that are expected to succeed, succeed.
|
||||||
#[test]
|
#[test]
|
||||||
fn test_expected() {
|
fn test_expected() {
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
("", true),
|
("", true),
|
||||||
("x^2", true),
|
("x^2", true),
|
||||||
("2x", true),
|
("2x", true),
|
||||||
("E^x", true),
|
("E^x", true),
|
||||||
("log10(x)", true),
|
("log10(x)", true),
|
||||||
("xxxxx", true),
|
("xxxxx", true),
|
||||||
("sin(x)", true),
|
("sin(x)", true),
|
||||||
("xsin(x)", true),
|
("xsin(x)", true),
|
||||||
("sin(x)cos(x)", true),
|
("sin(x)cos(x)", true),
|
||||||
("x/0", true),
|
("x/0", true),
|
||||||
("(x+1)(x-3)", true),
|
("(x+1)(x-3)", true),
|
||||||
("cos(xsin(x)x)", true),
|
("cos(xsin(x)x)", true),
|
||||||
("(2x+1)x", true),
|
("(2x+1)x", true),
|
||||||
("(2x+1)pi", true),
|
("(2x+1)pi", true),
|
||||||
("pi(2x+1)", true),
|
("pi(2x+1)", true),
|
||||||
("pipipipipipix", true),
|
("pipipipipipix", true),
|
||||||
("e^sin(x)", true),
|
("e^sin(x)", true),
|
||||||
("E^sin(x)", true),
|
("E^sin(x)", true),
|
||||||
("e^x", true),
|
("e^x", true),
|
||||||
("x**2", true),
|
("x**2", true),
|
||||||
("a", false),
|
("a", false),
|
||||||
("log222(x)", false),
|
("log222(x)", false),
|
||||||
("abcdef", false),
|
("abcdef", false),
|
||||||
("log10(x", false),
|
("log10(x", false),
|
||||||
("x^a", false),
|
("x^a", false),
|
||||||
("sin(cos(x)))", false),
|
("sin(cos(x)))", false),
|
||||||
("0/0", false),
|
("0/0", false),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
test_func_helper(key, value);
|
test_func_helper(key, value);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Helps with tests of [`process_func_str`]
|
/// Helps with tests of [`process_func_str`]
|
||||||
fn test_process_helper(input: &str, expected: &str) {
|
fn test_process_helper(input: &str, expected: &str) {
|
||||||
assert_eq!(&parsing::process_func_str(input), expected);
|
assert_eq!(&parsing::process_func_str(input), expected);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Tests to make sure my cursed function works as intended
|
/// Tests to make sure my cursed function works as intended
|
||||||
#[test]
|
#[test]
|
||||||
fn func_process_test() {
|
fn func_process_test() {
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
("2x", "2*x"),
|
("2x", "2*x"),
|
||||||
(")(", ")*("),
|
(")(", ")*("),
|
||||||
("(2", "(2"),
|
("(2", "(2"),
|
||||||
("log10(x)", "log10(x)"),
|
("log10(x)", "log10(x)"),
|
||||||
("log2(x)", "log2(x)"),
|
("log2(x)", "log2(x)"),
|
||||||
("pipipipipipi", "π*π*π*π*π*π"),
|
("pipipipipipi", "π*π*π*π*π*π"),
|
||||||
("10pi", "10*π"),
|
("10pi", "10*π"),
|
||||||
("pi10", "π*10"),
|
("pi10", "π*10"),
|
||||||
("10pi10", "10*π*10"),
|
("10pi10", "10*π*10"),
|
||||||
("emax(x)", "e*max(x)"),
|
("emax(x)", "e*max(x)"),
|
||||||
("pisin(x)", "π*sin(x)"),
|
("pisin(x)", "π*sin(x)"),
|
||||||
("e^sin(x)", "e^sin(x)"),
|
("e^sin(x)", "e^sin(x)"),
|
||||||
("x**2", "x^2"),
|
("x**2", "x^2"),
|
||||||
("(x+1)(x-3)", "(x+1)*(x-3)"),
|
("(x+1)(x-3)", "(x+1)*(x-3)"),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
test_process_helper(key, value);
|
test_process_helper(key, value);
|
||||||
}
|
}
|
||||||
|
|
||||||
for func in SUPPORTED_FUNCTIONS.iter() {
|
for func in SUPPORTED_FUNCTIONS.iter() {
|
||||||
let func_new = format!("{}(x)", func);
|
let func_new = format!("{}(x)", func);
|
||||||
test_process_helper(&func_new, &func_new);
|
test_process_helper(&func_new, &func_new);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Tests to make sure hints are properly outputed based on input
|
/// Tests to make sure hints are properly outputed based on input
|
||||||
#[test]
|
#[test]
|
||||||
fn hints() {
|
fn hints() {
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
("", Hint::Single("x^2")),
|
("", Hint::Single("x^2")),
|
||||||
("si", Hint::Many(&["n(", "nh(", "gnum("])),
|
("si", Hint::Many(&["n(", "nh(", "gnum("])),
|
||||||
("log", Hint::Many(&["2(", "10("])),
|
("log", Hint::Many(&["2(", "10("])),
|
||||||
("cos", Hint::Many(&["(", "h("])),
|
("cos", Hint::Many(&["(", "h("])),
|
||||||
("sin(", Hint::Single(")")),
|
("sin(", Hint::Single(")")),
|
||||||
("sqrt", Hint::Single("(")),
|
("sqrt", Hint::Single("(")),
|
||||||
("ln(x)", Hint::None),
|
("ln(x)", Hint::None),
|
||||||
("ln(x)cos", Hint::Many(&["(", "h("])),
|
("ln(x)cos", Hint::Many(&["(", "h("])),
|
||||||
("ln(x)*cos", Hint::Many(&["(", "h("])),
|
("ln(x)*cos", Hint::Many(&["(", "h("])),
|
||||||
("sin(cos", Hint::Many(&["(", "h("])),
|
("sin(cos", Hint::Many(&["(", "h("])),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
println!("{} + {:?}", key, value);
|
println!("{} + {:?}", key, value);
|
||||||
assert_eq!(parsing::generate_hint(key), &value);
|
assert_eq!(parsing::generate_hint(key), &value);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn hint_to_string() {
|
fn hint_to_string() {
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
("x^2", Hint::Single("x^2")),
|
("x^2", Hint::Single("x^2")),
|
||||||
(
|
(
|
||||||
r#"["n(", "nh(", "gnum("]"#,
|
r#"["n(", "nh(", "gnum("]"#,
|
||||||
Hint::Many(&["n(", "nh(", "gnum("]),
|
Hint::Many(&["n(", "nh(", "gnum("]),
|
||||||
),
|
),
|
||||||
(r#"["n("]"#, Hint::Many(&["n("])),
|
(r#"["n("]"#, Hint::Many(&["n("])),
|
||||||
("None", Hint::None),
|
("None", Hint::None),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
assert_eq!(value.to_string(), key);
|
assert_eq!(value.to_string(), key);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn invalid_function() {
|
fn invalid_function() {
|
||||||
use parsing::SplitType;
|
use parsing::SplitType;
|
||||||
|
|
||||||
SUPPORTED_FUNCTIONS
|
SUPPORTED_FUNCTIONS
|
||||||
.iter()
|
.iter()
|
||||||
.flat_map(|func1| {
|
.flat_map(|func1| {
|
||||||
SUPPORTED_FUNCTIONS
|
SUPPORTED_FUNCTIONS
|
||||||
.iter()
|
.iter()
|
||||||
.map(|func2| func1.to_string() + func2)
|
.map(|func2| func1.to_string() + func2)
|
||||||
.collect::<Vec<String>>()
|
.collect::<Vec<String>>()
|
||||||
})
|
})
|
||||||
.filter(|func| !SUPPORTED_FUNCTIONS.contains(&func.as_str()))
|
.filter(|func| !SUPPORTED_FUNCTIONS.contains(&func.as_str()))
|
||||||
.for_each(|key| {
|
.for_each(|key| {
|
||||||
let split = parsing::split_function(&key, SplitType::Multiplication);
|
let split = parsing::split_function(&key, SplitType::Multiplication);
|
||||||
|
|
||||||
if split.len() != 1 {
|
if split.len() != 1 {
|
||||||
panic!("failed: {} (len: {}, split: {:?})", key, split.len(), split);
|
panic!("failed: {} (len: {}, split: {:?})", key, split.len(), split);
|
||||||
}
|
}
|
||||||
|
|
||||||
let generated_hint = parsing::generate_hint(&key);
|
let generated_hint = parsing::generate_hint(&key);
|
||||||
if generated_hint.is_none() {
|
if generated_hint.is_none() {
|
||||||
println!("success: {}", key);
|
println!("success: {}", key);
|
||||||
} else {
|
} else {
|
||||||
panic!("failed: {} (Hint: '{}')", key, generated_hint);
|
panic!("failed: {} (Hint: '{}')", key, generated_hint);
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn split_function_multiplication() {
|
fn split_function_multiplication() {
|
||||||
use parsing::SplitType;
|
use parsing::SplitType;
|
||||||
|
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
("cos(x)", vec!["cos(x)"]),
|
("cos(x)", vec!["cos(x)"]),
|
||||||
("cos(", vec!["cos("]),
|
("cos(", vec!["cos("]),
|
||||||
("cos(x)sin(x)", vec!["cos(x)", "sin(x)"]),
|
("cos(x)sin(x)", vec!["cos(x)", "sin(x)"]),
|
||||||
("aaaaaaaaaaa", vec!["aaaaaaaaaaa"]),
|
("aaaaaaaaaaa", vec!["aaaaaaaaaaa"]),
|
||||||
("emax(x)", vec!["e", "max(x)"]),
|
("emax(x)", vec!["e", "max(x)"]),
|
||||||
("x", vec!["x"]),
|
("x", vec!["x"]),
|
||||||
("xxx", vec!["x", "x", "x"]),
|
("xxx", vec!["x", "x", "x"]),
|
||||||
("sin(cos(x)x)", vec!["sin(cos(x)", "x)"]),
|
("sin(cos(x)x)", vec!["sin(cos(x)", "x)"]),
|
||||||
("sin(x)*cos(x)", vec!["sin(x)", "cos(x)"]),
|
("sin(x)*cos(x)", vec!["sin(x)", "cos(x)"]),
|
||||||
("x*x", vec!["x", "x"]),
|
("x*x", vec!["x", "x"]),
|
||||||
("10*10", vec!["10", "10"]),
|
("10*10", vec!["10", "10"]),
|
||||||
("a1b2c3d4", vec!["a1b2c3d4"]),
|
("a1b2c3d4", vec!["a1b2c3d4"]),
|
||||||
("cos(sin(x)cos(x))", vec!["cos(sin(x)", "cos(x))"]),
|
("cos(sin(x)cos(x))", vec!["cos(sin(x)", "cos(x))"]),
|
||||||
("", Vec::new()),
|
("", Vec::new()),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
parsing::split_function(key, SplitType::Multiplication),
|
parsing::split_function(key, SplitType::Multiplication),
|
||||||
value
|
value
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn split_function_terms() {
|
fn split_function_terms() {
|
||||||
use parsing::SplitType;
|
use parsing::SplitType;
|
||||||
|
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
(
|
(
|
||||||
"cos(sin(x)cos(x))",
|
"cos(sin(x)cos(x))",
|
||||||
vec!["cos(", "sin(", "x)", "cos(", "x))"],
|
vec!["cos(", "sin(", "x)", "cos(", "x))"],
|
||||||
),
|
),
|
||||||
("", Vec::new()),
|
("", Vec::new()),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
assert_eq!(parsing::split_function(key, SplitType::Term), value);
|
assert_eq!(parsing::split_function(key, SplitType::Term), value);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn hint_tests() {
|
fn hint_tests() {
|
||||||
{
|
{
|
||||||
let hint = Hint::None;
|
let hint = Hint::None;
|
||||||
assert!(hint.is_none());
|
assert!(hint.is_none());
|
||||||
assert!(!hint.is_some());
|
assert!(!hint.is_some());
|
||||||
assert!(!hint.is_single());
|
assert!(!hint.is_single());
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
let hint = Hint::Single("");
|
let hint = Hint::Single("");
|
||||||
assert!(!hint.is_none());
|
assert!(!hint.is_none());
|
||||||
assert!(hint.is_some());
|
assert!(hint.is_some());
|
||||||
assert!(hint.is_single());
|
assert!(hint.is_single());
|
||||||
}
|
}
|
||||||
|
|
||||||
{
|
{
|
||||||
let hint = Hint::Many(&[""]);
|
let hint = Hint::Many(&[""]);
|
||||||
assert!(!hint.is_none());
|
assert!(!hint.is_none());
|
||||||
assert!(hint.is_some());
|
assert!(hint.is_some());
|
||||||
assert!(!hint.is_single());
|
assert!(!hint.is_single());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn get_last_term() {
|
fn get_last_term() {
|
||||||
let values = HashMap::from([
|
let values = HashMap::from([
|
||||||
("cos(x)", "x)"),
|
("cos(x)", "x)"),
|
||||||
("cos(", "cos("),
|
("cos(", "cos("),
|
||||||
("aaaaaaaaaaa", "aaaaaaaaaaa"),
|
("aaaaaaaaaaa", "aaaaaaaaaaa"),
|
||||||
("x", "x"),
|
("x", "x"),
|
||||||
("xxx", "x"),
|
("xxx", "x"),
|
||||||
("x*x", "x"),
|
("x*x", "x"),
|
||||||
("10*10", "10"),
|
("10*10", "10"),
|
||||||
("sin(cos", "cos"),
|
("sin(cos", "cos"),
|
||||||
("exp(cos(exp(sin", "sin"),
|
("exp(cos(exp(sin", "sin"),
|
||||||
]);
|
]);
|
||||||
|
|
||||||
for (key, value) in values {
|
for (key, value) in values {
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
parsing::get_last_term(key.chars().collect::<Vec<char>>().as_slice()),
|
parsing::get_last_term(key.chars().collect::<Vec<char>>().as_slice()),
|
||||||
Some(value.to_owned())
|
Some(value.to_owned())
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn hint_accessor() {
|
fn hint_accessor() {
|
||||||
assert_eq!(Hint::Single("hint").many(), None);
|
assert_eq!(Hint::Single("hint").many(), None);
|
||||||
assert_eq!(Hint::Single("hint").single(), Some("hint"));
|
assert_eq!(Hint::Single("hint").single(), Some("hint"));
|
||||||
|
|
||||||
assert_eq!(Hint::Many(&["hint", "hint2"]).single(), None);
|
assert_eq!(Hint::Many(&["hint", "hint2"]).single(), None);
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
Hint::Many(&["hint", "hint2"]).many(),
|
Hint::Many(&["hint", "hint2"]).many(),
|
||||||
Some(["hint", "hint2"].as_slice())
|
Some(["hint", "hint2"].as_slice())
|
||||||
);
|
);
|
||||||
|
|
||||||
assert_eq!(Hint::None.single(), None);
|
assert_eq!(Hint::None.single(), None);
|
||||||
assert_eq!(Hint::None.many(), None);
|
assert_eq!(Hint::None.many(), None);
|
||||||
}
|
}
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user