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

Compare commits

base: titaniumtown:d592c746549d7436e20fe53a7f1be5f6d745565c
Branches Tags
titaniumtown:main
...
compare: titaniumtown:aa076312966754b6af77b713448c47962471109f
Branches Tags
titaniumtown:main

10 Commits
d592c74654 ... aa07631296

Author SHA1 Message Date
Simon Gardling
aa07631296
cargo clippy + fmt 2025-12-03 11:43:42 -05:00
Simon Gardling
5a92020dae
fix localstorage error 2025-12-03 11:42:13 -05:00
Simon Gardling
0889f81664
pin wasm-bindgen-futures 2025-12-03 11:34:29 -05:00
Simon Gardling
87de396fc2
edition: 2021 -> 2024 2025-12-03 11:32:29 -05:00
Simon Gardling
724d705d21
remove nightly features 2025-12-03 11:32:29 -05:00
Simon Gardling
53cb50316e
remove impl const 2025-12-03 11:32:29 -05:00
Simon Gardling
75092e7d9f
don't do sketchy egui Id stuff 2025-12-03 11:32:24 -05:00
Simon Gardling
5e01e1762f
nix + web stuff 2025-12-03 11:23:49 -05:00
Simon Gardling
4c9def194e
remove .vscode and .github 2025-12-03 11:23:49 -05:00
Simon Gardling
0edd1b51a1
remove shell scripts 2025-12-03 11:23:49 -05:00
29 changed files with 3669 additions and 2946 deletions
Show Stats Expand all files Collapse all files

50
.github/workflows/ci.yml vendored
View File

@ -1,50 +0,0 @@
on: [push, pull_request]
name: CI
jobs:
check:
name: Check
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install toolchain
uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: nightly
override: true
- name: Install fonttools
run: sudo apt-get install -y fonttools libzstd-dev
- name: Run cargo check
uses: actions-rs/cargo@v1
with:
command: check
parsing_test:
name: Tests
runs-on: ubuntu-latest
steps:
- name: Checkout sources
uses: actions/checkout@v2
- name: Install toolchain
uses: actions-rs/toolchain@v1
with:
profile: minimal
toolchain: nightly
override: true
- name: Install fonttools
run: sudo apt-get install -y fonttools libzstd-dev
- name: Install cargo-all-features
uses: actions-rs/install@v0.1
with:
crate: cargo-all-features
version: latest
- run: cargo test-all-features

4
.rustfmt.toml
View File

@ -1,4 +0,0 @@
edition = "2021"
fn_params_layout = "Compressed"
fn_single_line = true
hard_tabs = true

5
.vscode/settings.json vendored
View File

@ -1,5 +0,0 @@
{
"files.insertFinalNewline": true,
"editor.formatOnSave": true,
"files.trimTrailingWhitespace": true,
}

1878
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

20
Cargo.toml
View File

@ -1,7 +1,7 @@
[package] [package]
name = "ytbn_graphing_software" name = "ytbn_graphing_software"
version = "0.1.0" version = "0.1.0"
edition = "2021" edition = "2024"
license = "AGPL-3.0" license = "AGPL-3.0"
repository = "https://github.com/Titaniumtown/YTBN-Graphing-Software" repository = "https://github.com/Titaniumtown/YTBN-Graphing-Software"
description = "Crossplatform (and web-compatible) graphing calculator" description = "Crossplatform (and web-compatible) graphing calculator"
@ -33,17 +33,17 @@ strip = false
[dependencies] [dependencies]
parsing = { path = "./parsing" } parsing = { path = "./parsing" }
eframe = { git = "https://github.com/titaniumtown/egui.git", default-features = false, features = [ eframe = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false, features = [
"glow", "glow",
] } ] }
egui = { git = "https://github.com/titaniumtown/egui.git", default-features = false, features = [ egui = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false, features = [
"serde", "serde",
] } ] }
epaint = { git = "https://github.com/titaniumtown/egui.git", default-features = false , features = [ epaint = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false , features = [
"bytemuck", "bytemuck",
] } ] }
emath = { git = "https://github.com/titaniumtown/egui.git", default-features = false } emath = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false }
egui_plot = { git = "https://github.com/titaniumtown/egui.git", default-features = false } egui_plot = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false }
@ -56,16 +56,17 @@ itertools = "0.10"
static_assertions = "1.1" static_assertions = "1.1"
bincode = "1.3" bincode = "1.3"
serde = "1" serde = "1"
base64 = "0.21"
[dev-dependencies] [dev-dependencies]
benchmarks = { path = "./benchmarks" } benchmarks = { path = "./benchmarks" }
[build-dependencies] [build-dependencies]
shadow-rs = "0.12" shadow-rs = "0.12"
epaint = { git = "https://github.com/titaniumtown/egui.git", default-features = false, features = [ epaint = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false, features = [
"bytemuck", "bytemuck",
] } ] }
egui = { git = "https://github.com/titaniumtown/egui.git", default-features = false, features = [ egui = { git = "https://github.com/titaniumtown/egui.git", rev = "b088efb9fa917845ecb54729a0d2fc592d2399e7", default-features = false, features = [
"serde", "serde",
] } ] }
bincode = "1.3" bincode = "1.3"
@ -88,7 +89,8 @@ wasm-bindgen = { version = "0.2", default-features = false, features = ["std"] }
web-sys = "0.3" web-sys = "0.3"
tracing-wasm = "0.2" tracing-wasm = "0.2"
getrandom = { version = "0.2", features = ["js"] } getrandom = { version = "0.2", features = ["js"] }
wasm-bindgen-futures = "0.4.34" # pinned to 0.4.54 in order to be compatible with nixos's wasm-bindgen-cli version
wasm-bindgen-futures = "=0.4.54"
[package.metadata.cargo-all-features] [package.metadata.cargo-all-features]
skip_optional_dependencies = true #don't test optional dependencies, only features skip_optional_dependencies = true #don't test optional dependencies, only features

1
benchmarks/Cargo.toml
View File

@ -9,5 +9,4 @@ license = "AGPL-3.0"
[dependencies] [dependencies]
pprof = { version = "0.9", features = ["flamegraph"] } pprof = { version = "0.9", features = ["flamegraph"] }
criterion = "0.3" criterion = "0.3"
criterion-macro = "0.3"
parsing = { path = "../parsing" } parsing = { path = "../parsing" }

23
benchmarks/src/lib.rs
View File

@ -1,17 +1,10 @@
#![feature(custom_test_frameworks)] use parsing::{split_function_chars, SplitType};
#![test_runner(criterion::runner)]
#[allow(unused_imports)]
use parsing::split_function_chars;
#[allow(unused_imports)]
use std::time::Duration; use std::time::Duration;
use std::{fs::File, os::raw::c_int, path::Path}; use std::{fs::File, os::raw::c_int, path::Path};
use criterion::profiler::Profiler; use criterion::profiler::Profiler;
#[allow(unused_imports)] use criterion::{criterion_group, criterion_main, Criterion};
use criterion::{BenchmarkId, Criterion};
use criterion_macro::criterion;
use pprof::ProfilerGuard; use pprof::ProfilerGuard;
pub struct FlamegraphProfiler<'a> { pub struct FlamegraphProfiler<'a> {
@ -62,7 +55,6 @@ fn custom_criterion_flamegraph() -> Criterion {
custom_criterion().with_profiler(FlamegraphProfiler::new(100)) custom_criterion().with_profiler(FlamegraphProfiler::new(100))
} }
#[criterion(custom_criterion())]
fn mutli_split_function(c: &mut Criterion) { fn mutli_split_function(c: &mut Criterion) {
let data_chars = vec![ let data_chars = vec![
"sin(x)cos(x)", "sin(x)cos(x)",
@ -86,20 +78,23 @@ fn mutli_split_function(c: &mut Criterion) {
for entry in data_chars { for entry in data_chars {
group.bench_function(entry.iter().collect::<String>(), |b| { group.bench_function(entry.iter().collect::<String>(), |b| {
b.iter(|| { b.iter(|| {
split_function_chars(&entry, parsing::suggestions::SplitType::Multiplication); split_function_chars(&entry, SplitType::Multiplication);
}) })
}); });
} }
group.finish(); group.finish();
} }
// #[criterion(custom_criterion_flamegraph())] // Uncomment to enable flamegraph profiling
// fn single_split_function(c: &mut Criterion) { // fn single_split_function(c: &mut Criterion) {
// let data_chars = "(2x+1)(3x+1)".chars().collect::<Vec<char>>(); // let data_chars = "(2x+1)(3x+1)".chars().collect::<Vec<char>>();
//
// c.bench_function("split_function", |b| { // c.bench_function("split_function", |b| {
// b.iter(|| { // b.iter(|| {
// split_function_chars(&data_chars); // split_function_chars(&data_chars, SplitType::Multiplication);
// }); // });
// }); // });
// } // }
criterion_group!(benches, mutli_split_function);
criterion_main!(benches);

270
build.rs
View File

@ -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");
} }

76
build.sh
View File

@ -1,76 +0,0 @@
#!/bin/bash
set -e
rm -fr tmp | true
rm -fr pkg | true
# cargo test
export RUSTFLAGS="--cfg=web_sys_unstable_apis"
if test "$1" == "" || test "$1" == "release"; then
time cargo build --release --target wasm32-unknown-unknown -Z build-std=core,compiler_builtins,alloc,std,panic_abort,panic_unwind,proc_macro,unwind -Z build-std-features=panic_immediate_abort --lib --timings
llvm-strip -s target/wasm32-unknown-unknown/release/ytbn_graphing_software.wasm
export TYPE="release"
elif test "$1" == "debug"; then
time cargo build --target wasm32-unknown-unknown -Z build-std=core,compiler_builtins,alloc,std,panic_abort,panic_unwind,proc_macro,unwind -Z build-std-features=panic-unwind --lib
export TYPE="debug"
else
echo "ERROR: build.sh, argument invalid"
exit 1
fi
pre_size=$(du -sb target/wasm32-unknown-unknown/${TYPE}/ytbn_graphing_software.wasm | awk '{ print $1 }')
echo "compiled size: $pre_size"
wasm-bindgen target/wasm32-unknown-unknown/${TYPE}/ytbn_graphing_software.wasm --out-dir pkg --target web --no-typescript
if test "$TYPE" == "release"; then
echo "running wasm-opt..."
time wasm-opt --converge -Oz --code-folding --const-hoisting --coalesce-locals-learning --vacuum --merge-locals --merge-blocks --fast-math --precompute --rse --low-memory-unused --once-reduction --optimize-instructions --licm --intrinsic-lowering \
--dce --dae-optimizing --inlining-optimizing --strip-debug \
-o pkg/ytbn_graphing_software_bg_2.wasm pkg/ytbn_graphing_software_bg.wasm
mv pkg/ytbn_graphing_software_bg_2.wasm pkg/ytbn_graphing_software_bg.wasm
fi
mkdir tmp
cp -r pkg/ytbn_graphing_software_bg.wasm tmp/
sed -i 's/fatal: true/fatal: false/g' pkg/ytbn_graphing_software.js
sed -i "s/TextEncoder('utf-8')/TextEncoder('utf-8', { ignoreBOM: true, fatal: false })/g" pkg/ytbn_graphing_software.js
#minify pkg/ytbn_graphing_software.js > tmp/ytbn_graphing_software.js
cp www/* tmp/
cp assets/logo.svg tmp/
#minify www/index.html > tmp/index.html
#minify www/sw.js > tmp/sw.js
cp www/index.html www/sw.js pkg/ytbn_graphing_software.js tmp/
wasm_sum=($(md5sum tmp/ytbn_graphing_software_bg.wasm))
js_sum=($(md5sum tmp/ytbn_graphing_software.js))
sum=($(echo "$wasm_sum $js_sum" | md5sum))
echo "sum: $sum"
new_wasm_name="${sum}.wasm"
new_js_name="${sum}.js"
mv tmp/ytbn_graphing_software_bg.wasm "tmp/${new_wasm_name}"
mv tmp/ytbn_graphing_software.js "tmp/${new_js_name}"
sed -i "s/ytbn_graphing_software_bg.wasm/${new_wasm_name}/g" tmp/*.*
sed -i "s/ytbn_graphing_software.js/${new_js_name}/g" tmp/*.*
new_size=$(du -b tmp/${new_wasm_name} | awk '{ print $1 }')
diff=$(echo "scale=5 ; $new_size / $pre_size" | bc)
percent=$(echo "scale=5 ; (1-$diff)*100" | bc)
echo "Total size: $(du -sb tmp)"
echo "Binary size: $new_size reduced: $percent%"

100
flake.lock generated Normal file
View File

@ -0,0 +1,100 @@
{
"nodes": {
"flake-utils": {
"inputs": {
"systems": "systems"
},
"locked": {
"lastModified": 1731533236,
"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
"owner": "numtide",
"repo": "flake-utils",
"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
"type": "github"
},
"original": {
"owner": "numtide",
"repo": "flake-utils",
"type": "github"
}
},
"nixpkgs": {
"locked": {
"lastModified": 1764517877,
"narHash": "sha256-pp3uT4hHijIC8JUK5MEqeAWmParJrgBVzHLNfJDZxg4=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "2d293cbfa5a793b4c50d17c05ef9e385b90edf6c",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixos-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"flake-utils": "flake-utils",
"nixpkgs": "nixpkgs",
"rust-overlay": "rust-overlay",
"simon-egui": "simon-egui"
}
},
"rust-overlay": {
"inputs": {
"nixpkgs": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1764729618,
"narHash": "sha256-z4RA80HCWv2los1KD346c+PwNPzMl79qgl7bCVgz8X0=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "52764074a85145d5001bf0aa30cb71936e9ad5b8",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
},
"simon-egui": {
"flake": false,
"locked": {
"lastModified": 1764730109,
"narHash": "sha256-vNETC0oq6tKJKF8KOGQKKIWRom38m0RwGgi3MPBrRx8=",
"owner": "Titaniumtown",
"repo": "egui",
"rev": "b63c21d70150f1b414370f0f9a8af56e886662f4",
"type": "github"
},
"original": {
"owner": "Titaniumtown",
"repo": "egui",
"rev": "b63c21d70150f1b414370f0f9a8af56e886662f4",
"type": "github"
}
},
"systems": {
"locked": {
"lastModified": 1681028828,
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
"owner": "nix-systems",
"repo": "default",
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
"type": "github"
},
"original": {
"owner": "nix-systems",
"repo": "default",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

214
flake.nix Normal file
View File

@ -0,0 +1,214 @@
{
description = "YTBN Graphing Software - Web-compatible graphing calculator";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
flake-utils.url = "github:numtide/flake-utils";
rust-overlay = {
url = "github:oxalica/rust-overlay";
inputs.nixpkgs.follows = "nixpkgs";
};
simon-egui = {
url = "github:Titaniumtown/egui/b63c21d70150f1b414370f0f9a8af56e886662f4";
flake = false;
};
};
outputs =
{
self,
nixpkgs,
flake-utils,
rust-overlay,
simon-egui,
}:
flake-utils.lib.eachDefaultSystem (
system:
let
overlays = [ (import rust-overlay) ];
pkgs = import nixpkgs {
inherit system overlays;
};
# Use nightly rust with wasm32 target
rustToolchain = pkgs.rust-bin.stable.latest.default.override {
targets = [ "wasm32-unknown-unknown" ];
};
rustPlatform = pkgs.makeRustPlatform {
cargo = rustToolchain;
rustc = rustToolchain;
};
# Create a combined source with the main project and dependencies
combinedSrc = pkgs.stdenv.mkDerivation {
name = "ytbn-combined-src";
phases = [ "installPhase" ];
installPhase = ''
mkdir -p $out/integral_site_rust
mkdir -p $out/simon-egui
cp -r ${./.}/* $out/integral_site_rust/
cp -r ${simon-egui}/* $out/simon-egui/
chmod -R u+w $out
'';
};
# Build the wasm library using rustPlatform
wasmLib = rustPlatform.buildRustPackage {
pname = "ytbn-graphing-software-wasm";
version = "0.1.0";
src = combinedSrc;
sourceRoot = "${combinedSrc.name}/integral_site_rust";
cargoLock = {
lockFile = ./Cargo.lock;
outputHashes = {
"ecolor-0.25.0" = "sha256-9s5LCngwvIIL43txT6sBs4JlRXqmYt1Kw8hlDnwx+DI=";
};
};
nativeBuildInputs = with pkgs; [
python3Packages.fonttools
pkg-config
clang
];
buildInputs = with pkgs; [
openssl
zstd
];
buildPhase = ''
runHook preBuild
export HOME=$TMPDIR
cargo build \
--release \
--lib \
--target wasm32-unknown-unknown
runHook postBuild
'';
installPhase = ''
runHook preInstall
mkdir -p $out/lib
cp target/wasm32-unknown-unknown/release/*.wasm $out/lib/
runHook postInstall
'';
doCheck = false;
};
# Final web package with wasm-bindgen processing
ytbn-graphing-software-web = pkgs.stdenv.mkDerivation {
pname = "ytbn-graphing-software-web";
version = "0.1.0";
src = ./.;
nativeBuildInputs = with pkgs; [
wasm-bindgen-cli
binaryen
];
buildPhase = ''
runHook preBuild
# Generate JS bindings
wasm-bindgen ${wasmLib}/lib/ytbn_graphing_software.wasm \
--out-dir out \
--out-name ytbn_graphing_software \
--target web \
--no-typescript
# Optimize wasm (enable features used by modern rust wasm targets)
wasm-opt out/ytbn_graphing_software_bg.wasm \
-O2 --fast-math \
--enable-bulk-memory \
--enable-nontrapping-float-to-int \
--enable-sign-ext \
--enable-mutable-globals \
-o out/ytbn_graphing_software_bg.wasm
runHook postBuild
'';
installPhase = ''
runHook preInstall
mkdir -p $out
# Copy wasm and js files
cp out/ytbn_graphing_software_bg.wasm $out/
cp out/ytbn_graphing_software.js $out/
# Copy static web assets
cp www/index.html $out/
cp www/manifest.json $out/
cp www/sw.js $out/
# Copy logo
cp assets/logo.svg $out/
runHook postInstall
'';
meta = with pkgs.lib; {
description = "Web-compatible graphing calculator similar to Desmos";
homepage = "https://github.com/Titaniumtown/YTBN-Graphing-Software";
license = licenses.agpl3Only;
platforms = platforms.all;
};
};
in
{
packages = {
default = ytbn-graphing-software-web;
web = ytbn-graphing-software-web;
wasm = wasmLib;
};
devShells.default = pkgs.mkShell {
nativeBuildInputs = with pkgs; [
rustToolchain
wasm-bindgen-cli
binaryen
python3Packages.fonttools
rust-analyzer
pkg-config
clang
# Runtime deps for native builds
libxkbcommon
libGL
wayland
xorg.libX11
xorg.libXcursor
xorg.libXi
];
buildInputs = with pkgs; [
openssl
zstd
];
LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath (
with pkgs;
[
libxkbcommon
libGL
wayland
xorg.libX11
xorg.libXcursor
xorg.libXi
]
);
};
}
);
}

20
parsing/src/autocomplete.rs
View File

@ -13,13 +13,19 @@ pub enum Movement {
} }
impl Movement { impl Movement {
pub const fn is_none(&self) -> bool { matches!(&self, &Self::None) } pub const fn is_none(&self) -> bool {
matches!(&self, &Self::None)
}
pub const fn is_complete(&self) -> bool { matches!(&self, &Self::Complete) } pub const fn is_complete(&self) -> bool {
matches!(&self, &Self::Complete)
}
} }
impl const Default for Movement { impl Default for Movement {
fn default() -> Self { Self::None } fn default() -> Self {
Self::None
}
} }
#[derive(Clone, PartialEq)] #[derive(Clone, PartialEq)]
@ -29,8 +35,10 @@ pub struct AutoComplete<'a> {
pub string: String, pub string: String,
} }
impl<'a> const Default for AutoComplete<'a> { impl<'a> Default for AutoComplete<'a> {
fn default() -> AutoComplete<'a> { AutoComplete::EMPTY } fn default() -> AutoComplete<'a> {
AutoComplete::EMPTY
}
} }
impl<'a> AutoComplete<'a> { impl<'a> AutoComplete<'a> {

3
parsing/src/lib.rs
View File

@ -1,6 +1,3 @@
#![feature(const_trait_impl)]
#![feature(const_mut_refs)]
#![feature(const_for)]
mod autocomplete; mod autocomplete;
mod autocomplete_hashmap; mod autocomplete_hashmap;
mod parsing; mod parsing;

18
parsing/src/parsing.rs
View File

@ -22,7 +22,9 @@ impl FlatExWrapper {
} }
#[inline] #[inline]
const fn is_none(&self) -> bool { self.func.is_none() } const fn is_none(&self) -> bool {
self.func.is_none()
}
#[inline] #[inline]
pub fn eval(&self, x: &[f64]) -> f64 { pub fn eval(&self, x: &[f64]) -> f64 {
@ -66,8 +68,10 @@ impl FlatExWrapper {
} }
} }
impl const Default for FlatExWrapper { impl Default for FlatExWrapper {
fn default() -> FlatExWrapper { FlatExWrapper::EMPTY } fn default() -> FlatExWrapper {
FlatExWrapper::EMPTY
}
} }
/// Function that includes f(x), f'(x), f'(x)'s string representation, and f''(x) /// Function that includes f(x), f'(x), f'(x)'s string representation, and f''(x)
#[derive(Clone, PartialEq)] #[derive(Clone, PartialEq)]
@ -80,11 +84,15 @@ pub struct BackingFunction {
} }
impl Default for BackingFunction { impl Default for BackingFunction {
fn default() -> Self { Self::new("").unwrap() } fn default() -> Self {
Self::new("").unwrap()
}
} }
impl BackingFunction { impl BackingFunction {
pub const fn is_none(&self) -> bool { self.function.is_none() } pub const fn is_none(&self) -> bool {
self.function.is_none()
}
/// Create new [`BackingFunction`] instance /// Create new [`BackingFunction`] instance
pub fn new(func_str: &str) -> Result<Self, String> { pub fn new(func_str: &str) -> Result<Self, String> {

15
push.sh
View File

@ -1,15 +0,0 @@
#!/bin/bash
set -e #kill script if error occurs
cargo test
bash build.sh release
echo "rsyncing"
# rsync -av --delete --info=progress2 tmp/ rpi-public:/mnt/hdd/http_share/ytbn/
rsync -av --delete --info=progress2 --exclude=".git" tmp/ ../titaniumtown.github.io/
rm -fr tmp
cd ../titaniumtown.github.io
git add .
git commit -m "update" | true
git push

50
src/consts.rs
View File

@ -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());

799
src/function_entry.rs
View File

@ -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 const 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()
}
} }

426
src/function_manager.rs
View File

@ -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::{create_id, get_u64_id, 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,267 +12,262 @@ 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((
create_id(11414819524356497634), // 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
S: Serializer, S: Serializer,
{ {
let mut s = serializer.serialize_struct("FunctionManager", 1)?; let mut s = serializer.serialize_struct("FunctionManager", 1)?;
s.serialize_field( s.serialize_field(
"data", "data",
&self &self
.functions .functions
.iter() .iter()
.map(|(id, func)| (get_u64_id(*id), func.clone())) .map(|(id, func)| (*id, func.clone()))
.collect::<Vec<(u64, FunctionEntry)>>(), .collect::<Vec<(Id, FunctionEntry)>>(),
)?; )?;
s.end() s.end()
} }
} }
impl<'de> Deserialize<'de> for FunctionManager { impl<'de> Deserialize<'de> for FunctionManager {
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(Vec<(u64, FunctionEntry)>); struct Helper(Vec<(Id, FunctionEntry)>);
let helper = Helper::deserialize(deserializer)?; let helper = Helper::deserialize(deserializer)?;
Ok(FunctionManager { Ok(FunctionManager {
functions: helper functions: helper.0.to_vec(),
.0 })
.iter() }
.cloned()
.map(|(id, func)| (create_id(id), func))
.collect::<Vec<(Id, FunctionEntry)>>(),
})
}
} }
/// 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()
{ {
// Doesn't need to have a number in id as there should only be 1 autocomplete popup in the entire gui let mut clicked = false;
// hashed "autocomplete_popup" let autocomplete_popup_id = Id::new("autocomplete popup");
const POPUP_ID: Id = create_id(7574801616484505465);
let mut clicked = false; egui::popup_below_widget(ui, autocomplete_popup_id, &re, |ui| {
hints.iter().enumerate().for_each(|(i, candidate)| {
if ui
.selectable_label(i == function.autocomplete.i, *candidate)
.clicked()
{
clicked = true;
function.autocomplete.i = i;
}
});
});
egui::popup_below_widget(ui, POPUP_ID, &re, |ui| { if clicked {
hints.iter().enumerate().for_each(|(i, candidate)| { function
if ui .autocomplete
.selectable_label(i == function.autocomplete.i, *candidate) .apply_hint(hints[function.autocomplete.i]);
.clicked()
{
clicked = true;
function.autocomplete.i = i;
}
});
});
if clicked { movement = Movement::Complete;
function } else {
.autocomplete ui.memory_mut(|x| x.open_popup(autocomplete_popup_id));
.apply_hint(hints[function.autocomplete.i]); }
}
// Don't need this here as it simply won't be display next frame // Push cursor to end if needed
// ui.memory_mut().close_popup(); if movement == Movement::Complete {
let mut state =
unsafe { TextEdit::load_state(ui.ctx(), te_id).unwrap_unchecked() };
let ccursor = egui::text::CCursor::new(function.autocomplete.string.len());
state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor)));
TextEdit::store_state(ui.ctx(), te_id, state);
}
}
movement = Movement::Complete; /// The y offset multiplier of the `buttons_area` area
} else { const BUTTONS_Y_OFFSET: f32 = 1.32;
ui.memory_mut(|x| x.open_popup(POPUP_ID)); const Y_OFFSET: f32 = crate::consts::FONT_SIZE * BUTTONS_Y_OFFSET;
}
}
// Push cursor to end if needed widgets_ontop(ui, Id::new(i), &re, Y_OFFSET, |ui| {
if movement == Movement::Complete { ui.horizontal(|ui| {
let mut state = // There's more than 1 function! Functions can now be deleted
unsafe { TextEdit::load_state(ui.ctx(), te_id).unwrap_unchecked() }; if ui
let ccursor = egui::text::CCursor::new(function.autocomplete.string.len()); .add_enabled(can_remove, button_area_button("✖"))
state.set_ccursor_range(Some(egui::text::CCursorRange::one(ccursor))); .on_hover_text("Delete Function")
TextEdit::store_state(ui.ctx(), te_id, state); .clicked()
} {
} remove_i = Some(i);
}
/// The y offset multiplier of the `buttons_area` area ui.add_enabled_ui(function.is_some(), |ui| {
const BUTTONS_Y_OFFSET: f32 = 1.32; // Toggle integral being enabled or not
const Y_OFFSET: f32 = crate::consts::FONT_SIZE * BUTTONS_Y_OFFSET; function.integral.bitxor_assign(
ui.add(button_area_button("∫"))
.on_hover_text(match function.integral {
true => "Don't integrate",
false => "Integrate",
})
.clicked(),
);
widgets_ontop(ui, create_id(i as u64), &re, Y_OFFSET, |ui| { // Toggle showing the derivative (even though it's already calculated this option just toggles if it's displayed or not)
ui.horizontal(|ui| { function.derivative.bitxor_assign(
// There's more than 1 function! Functions can now be deleted ui.add(button_area_button("d/dx"))
if ui .on_hover_text(match function.derivative {
.add_enabled(can_remove, button_area_button("✖")) true => "Don't Differentiate",
.on_hover_text("Delete Function") false => "Differentiate",
.clicked() })
{ .clicked(),
remove_i = Some(i); );
}
ui.add_enabled_ui(function.is_some(), |ui| { // Toggle showing the settings window
// Toggle integral being enabled or not function.settings_opened.bitxor_assign(
function.integral.bitxor_assign( ui.add(button_area_button("⚙"))
ui.add(button_area_button("∫")) .on_hover_text(match function.settings_opened {
.on_hover_text(match function.integral { true => "Close Settings",
true => "Don't integrate", false => "Open Settings",
false => "Integrate", })
}) .clicked(),
.clicked(), );
); });
});
});
}
// Toggle showing the derivative (even though it's already calculated this option just toggles if it's displayed or not) function.settings_window(ui.ctx());
function.derivative.bitxor_assign( }
ui.add(button_area_button("d/dx"))
.on_hover_text(match function.derivative {
true => "Don't Differentiate",
false => "Differentiate",
})
.clicked(),
);
// Toggle showing the settings window // Remove function if the user requests it
function.settings_opened.bitxor_assign( if let Some(remove_i_unwrap) = remove_i {
ui.add(button_area_button("⚙")) self.functions.remove(remove_i_unwrap);
.on_hover_text(match function.settings_opened { }
true => "Close Settings",
false => "Open Settings",
})
.clicked(),
);
});
});
});
}
function.settings_window(ui.ctx()); let final_hash = self.get_hash();
}
// Remove function if the user requests it initial_hash != final_hash
if let Some(remove_i_unwrap) = remove_i { }
self.functions.remove(remove_i_unwrap);
}
let final_hash = self.get_hash(); /// Create and push new empty function entry
pub fn push_empty(&mut self) {
self.functions.push((
Id::new(random_u64().expect("unable to generate random id")),
FunctionEntry::default(),
));
}
initial_hash != final_hash /// Detect if any functions are using integrals
} pub fn any_using_integral(&self) -> bool {
self.functions.iter().any(|(_, func)| func.integral)
}
/// Create and push new empty function entry #[inline]
pub fn push_empty(&mut self) { pub fn len(&self) -> usize {
self.functions.push(( self.functions.len()
create_id(random_u64().expect("unable to generate random id")), }
FunctionEntry::default(),
));
}
/// Detect if any functions are using integrals #[inline]
pub fn any_using_integral(&self) -> bool { pub fn get_entries_mut(&mut self) -> &mut Functions {
self.functions.iter().any(|(_, func)| func.integral) &mut self.functions
} }
#[inline] #[inline]
pub fn len(&self) -> usize { self.functions.len() } pub fn get_entries(&self) -> &Functions {
&self.functions
#[inline] }
pub fn get_entries_mut(&mut self) -> &mut Functions { &mut self.functions }
#[inline]
pub fn get_entries(&self) -> &Functions { &self.functions }
} }

111
src/lib.rs
View File

@ -1,14 +1,3 @@
#![feature(const_mut_refs)]
#![feature(let_chains)]
#![feature(const_trait_impl)]
#![feature(const_fn_floating_point_arithmetic)]
#![feature(const_assume)]
#![feature(const_option_ext)]
#![feature(const_slice_index)]
#![feature(slice_split_at_unchecked)]
#![feature(inline_const)]
#![feature(const_for)]
#[macro_use] #[macro_use]
extern crate static_assertions; extern crate static_assertions;
@ -21,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()
} }
} }
} }

29
src/main.rs
View File

@ -1,14 +1,3 @@
#![feature(const_mut_refs)]
#![feature(let_chains)]
#![feature(const_trait_impl)]
#![feature(const_fn_floating_point_arithmetic)]
#![feature(const_assume)]
#![feature(const_option_ext)]
#![feature(const_slice_index)]
#![feature(slice_split_at_unchecked)]
#![feature(inline_const)]
#![feature(const_for)]
#[macro_use] #[macro_use]
extern crate static_assertions; extern crate static_assertions;
@ -23,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))),
) )
} }

940
src/math_app.rs
View File

File diff suppressed because it is too large Load Diff

237
src/misc.rs
View File

@ -1,4 +1,4 @@
use egui::Id; 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 { Line::new(self.to_values()) } fn to_line(self) -> Line {
Line::new(self.to_values())
}
#[inline(always)] #[inline(always)]
fn to_points(self) -> Points { Points::new(self.to_values()) } fn to_points(self) -> Points {
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 const 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,
} }
} }
} }
pub const fn create_id(x: u64) -> Id { unsafe { std::mem::transmute::<u64, Id>(x) } }
pub const fn get_u64_id(id: Id) -> u64 { unsafe { std::mem::transmute::<Id, u64>(id) } }
/* /*
/// 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,36 +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 {
unsafe { std::mem::transmute::<Vec<u8>, String>([hashbytes.to_vec(), data.to_vec()].concat()) } let combined_data = [hashbytes.to_vec(), data.to_vec()].concat();
general_purpose::STANDARD.encode(combined_data)
} }
#[allow(dead_code)] #[allow(dead_code)]
pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, &[u8])> { pub fn hashed_storage_read(data: &str) -> Option<(HashBytes, Vec<u8>)> {
// Make sure data is long enough to decode // Decode base64 data
if HASH_LENGTH >= data.len() { let decoded_bytes = general_purpose::STANDARD.decode(data).ok()?;
return None;
}
// Transmute data into slice // Make sure data is long enough to decode
let decoded_1: &[u8] = unsafe { std::mem::transmute::<&str, &[u8]>(data) }; if HASH_LENGTH > decoded_bytes.len() {
return None;
}
// Return hash and decoded data // Split hash and data
Some(( let (hash_bytes, data_bytes) = decoded_bytes.split_at(HASH_LENGTH);
unsafe { *(decoded_1[..HASH_LENGTH].as_ptr() as *const HashBytes) },
&decoded_1[HASH_LENGTH..], // Convert hash bytes to HashBytes
)) let hash: HashBytes = hash_bytes.try_into().ok()?;
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 { c.is_alphanumeric() | VALID_EXTRA_CHARS.contains(&c) } pub fn is_valid_char(c: char) -> bool {
c.is_alphanumeric() | VALID_EXTRA_CHARS.contains(&c)
}

22
src/unicode_helper.rs
View File

@ -2,19 +2,19 @@ use itertools::Itertools;
#[allow(dead_code)] #[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(", ")
+ "]" + "]"
} }

15
src/widgets.rs
View File

@ -3,12 +3,15 @@ use egui::{Id, InnerResponse};
/// Creates an area ontop of a widget with an y offset /// 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))
} }

6
start-server.sh
View File

@ -1,6 +0,0 @@
#!/bin/bash
set -e
bash build.sh "$1"
basic-http-server tmp/

268
tests/autocomplete.rs
View File

@ -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),
]); ]);
} }

415
tests/function.rs
View File

@ -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
View File

@ -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
View File

@ -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);
} }