697 lines
18 KiB
Rust
697 lines
18 KiB
Rust
#![allow(clippy::too_many_arguments)] // Clippy, shut
|
|
|
|
use crate::math_app::AppSettings;
|
|
use crate::misc::*;
|
|
use crate::parsing::{process_func_str, BackingFunction};
|
|
use crate::suggestions::{generate_hint, HintEnum};
|
|
use eframe::{egui, epaint};
|
|
use egui::{
|
|
epaint::text::cursor::Cursor, text::CCursor, text_edit::CursorRange, Key, TextEdit, Widget,
|
|
};
|
|
use egui::{
|
|
plot::{BarChart, PlotUi, Value},
|
|
widgets::plot::Bar,
|
|
};
|
|
use epaint::text::cursor::{PCursor, RCursor};
|
|
use epaint::Color32;
|
|
use std::fmt::{self, Debug};
|
|
|
|
#[cfg(threading)]
|
|
use rayon::iter::ParallelIterator;
|
|
|
|
/// Represents the possible variations of Riemann Sums
|
|
#[derive(PartialEq, Debug, Copy, Clone)]
|
|
pub enum Riemann {
|
|
Left,
|
|
Middle,
|
|
Right,
|
|
}
|
|
|
|
impl fmt::Display for Riemann {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{:?}", self) }
|
|
}
|
|
|
|
lazy_static::lazy_static! {
|
|
/// Represents a "default" instance of `FunctionEntry`
|
|
pub static ref DEFAULT_FUNCTION_ENTRY: FunctionEntry = FunctionEntry::default();
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct AutoComplete {
|
|
pub i: usize,
|
|
pub hint: HintEnum<'static>,
|
|
pub func_str: Option<String>,
|
|
pub changed: bool,
|
|
}
|
|
|
|
impl Default for AutoComplete {
|
|
fn default() -> AutoComplete {
|
|
AutoComplete {
|
|
i: 0,
|
|
hint: HintEnum::None,
|
|
func_str: None,
|
|
changed: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AutoComplete {
|
|
fn changed(&mut self, string: String) {
|
|
if self.func_str != Some(string.clone()) {
|
|
self.changed = true;
|
|
self.func_str = Some(string.clone());
|
|
self.hint = generate_hint(string);
|
|
} else {
|
|
self.changed = false;
|
|
}
|
|
}
|
|
|
|
/// Creates and manages text box and autocompletion of function input
|
|
/// Returns whether or not the function text box is in focus
|
|
fn ui(&mut self, ui: &mut egui::Ui, string: &mut String) -> bool {
|
|
// Put here so these key presses don't interact with other elements
|
|
let enter_pressed = ui
|
|
.input_mut()
|
|
.consume_key(egui::Modifiers::NONE, Key::Enter);
|
|
let tab_pressed = ui.input_mut().consume_key(egui::Modifiers::NONE, Key::Tab);
|
|
|
|
let te_id = ui.make_persistent_id("text_edit_ac".to_string());
|
|
|
|
// update self.autocomplete
|
|
self.changed(string.clone());
|
|
|
|
let mut func_edit = egui::TextEdit::singleline(string)
|
|
.hint_forward(true)
|
|
.lock_focus(true);
|
|
|
|
if self.hint.is_none() {
|
|
func_edit.id(te_id).ui(ui);
|
|
return false;
|
|
}
|
|
|
|
if let Some(single_hint) = self.hint.get_single() {
|
|
let func_edit_2 = func_edit;
|
|
func_edit = func_edit_2.hint_text(&single_hint);
|
|
}
|
|
|
|
let re = func_edit.id(te_id).ui(ui);
|
|
|
|
let func_edit_focus = re.has_focus();
|
|
|
|
// If in focus and right arrow key was pressed, apply hint
|
|
if func_edit_focus {
|
|
let mut push_cursor: bool = false;
|
|
let apply_key = ui.input().key_pressed(Key::ArrowRight) | enter_pressed | tab_pressed;
|
|
|
|
if apply_key && let Some(single_hint) = self.hint.get_single() {
|
|
push_cursor = true;
|
|
*string = string.clone() + &single_hint;
|
|
} else if self.hint.is_multi() {
|
|
let selections = self.hint.ensure_many();
|
|
|
|
let max_i = selections.len() as i16 - 1;
|
|
|
|
let mut i = self.i as i16;
|
|
|
|
if ui.input().key_pressed(Key::ArrowDown) {
|
|
i += 1;
|
|
if i > max_i {
|
|
i = 0;
|
|
}
|
|
} else if ui.input().key_pressed(Key::ArrowUp) {
|
|
i -= 1;
|
|
if 0 > i {
|
|
i = max_i
|
|
}
|
|
}
|
|
|
|
self.i = i as usize;
|
|
|
|
let popup_id = ui.make_persistent_id("autocomplete_popup");
|
|
|
|
let mut clicked = false;
|
|
|
|
egui::popup_below_widget(ui, popup_id, &re, |ui| {
|
|
for (i, candidate) in selections.iter().enumerate() {
|
|
if ui
|
|
.selectable_label(i == self.i, *candidate)
|
|
.clicked()
|
|
{
|
|
clicked = true;
|
|
self.i = i;
|
|
}
|
|
}
|
|
});
|
|
|
|
if clicked | apply_key {
|
|
*string += selections[self.i];
|
|
push_cursor = true;
|
|
|
|
|
|
// don't need this here as it simply won't be display next frame in `math_app.rs`
|
|
// ui.memory().close_popup();
|
|
} else {
|
|
ui.memory().open_popup(popup_id);
|
|
}
|
|
}
|
|
|
|
// Push cursor to end if needed
|
|
if push_cursor {
|
|
let mut state = TextEdit::load_state(ui.ctx(), te_id).unwrap();
|
|
state.set_cursor_range(Some(CursorRange::one(Cursor {
|
|
ccursor: CCursor {
|
|
index: 0,
|
|
prefer_next_row: false,
|
|
},
|
|
rcursor: RCursor { row: 0, column: 0 },
|
|
pcursor: PCursor {
|
|
paragraph: 0,
|
|
offset: 10000,
|
|
prefer_next_row: false,
|
|
},
|
|
})));
|
|
TextEdit::store_state(ui.ctx(), te_id, state);
|
|
}
|
|
}
|
|
func_edit_focus
|
|
}
|
|
}
|
|
|
|
/// `FunctionEntry` is a function that can calculate values, integrals,
|
|
/// derivatives, etc etc
|
|
#[derive(Clone)]
|
|
pub struct FunctionEntry {
|
|
/// The `BackingFunction` instance that is used to generate `f(x)`, `f'(x)`,
|
|
/// and `f''(x)`
|
|
function: BackingFunction,
|
|
|
|
/// Stores a function string (that hasn't been processed via
|
|
/// `process_func_str`) to display to the user
|
|
raw_func_str: String,
|
|
|
|
/// Minimum and Maximum values of what do display
|
|
min_x: f64,
|
|
max_x: f64,
|
|
|
|
/// If calculating/displayingintegrals are enabled
|
|
pub integral: bool,
|
|
|
|
/// If displaying derivatives are enabled (note, they are still calculated
|
|
/// for other purposes)
|
|
pub derivative: bool,
|
|
|
|
back_data: Option<Vec<Value>>,
|
|
integral_data: Option<(Vec<Bar>, f64)>,
|
|
derivative_data: Option<Vec<Value>>,
|
|
extrema_data: Option<Vec<Value>>,
|
|
roots_data: Option<Vec<Value>>,
|
|
|
|
autocomplete: AutoComplete,
|
|
|
|
invalid: bool,
|
|
|
|
test_result: Option<String>,
|
|
}
|
|
|
|
impl Default for FunctionEntry {
|
|
/// Creates default FunctionEntry instance (which is empty)
|
|
fn default() -> FunctionEntry {
|
|
FunctionEntry {
|
|
function: BackingFunction::new(""),
|
|
raw_func_str: String::new(),
|
|
min_x: -1.0,
|
|
max_x: 1.0,
|
|
integral: false,
|
|
derivative: false,
|
|
back_data: None,
|
|
integral_data: None,
|
|
derivative_data: None,
|
|
extrema_data: None,
|
|
roots_data: None,
|
|
autocomplete: AutoComplete::default(),
|
|
invalid: true,
|
|
test_result: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FunctionEntry {
|
|
pub fn get_func_raw(&self) -> String { self.raw_func_str.to_string() }
|
|
|
|
pub fn auto_complete(&mut self, ui: &mut egui::Ui, string: &mut String) -> bool {
|
|
self.autocomplete.ui(ui, string)
|
|
}
|
|
|
|
/// Update function settings
|
|
pub fn update(
|
|
&mut self, raw_func_str: &str, integral: bool, derivative: bool,
|
|
) -> Option<String> {
|
|
if raw_func_str != self.get_func_raw() {
|
|
let processed_func = process_func_str(raw_func_str);
|
|
let output = crate::parsing::test_func(&processed_func);
|
|
self.raw_func_str = raw_func_str.to_string();
|
|
if output.is_some() {
|
|
self.test_result = output.clone();
|
|
self.invalid = true;
|
|
return output;
|
|
}
|
|
self.invalid = false;
|
|
|
|
self.function = BackingFunction::new(&processed_func);
|
|
self.invalidate_whole();
|
|
}
|
|
|
|
if self.invalid {
|
|
return self.test_result.clone();
|
|
}
|
|
|
|
self.derivative = derivative;
|
|
self.integral = integral;
|
|
return None;
|
|
}
|
|
|
|
fn get_sum_func(&self, sum: Riemann) -> FunctionHelper {
|
|
match sum {
|
|
Riemann::Left => {
|
|
FunctionHelper::new(|left_x: f64, _: f64| -> f64 { self.function.get(left_x) })
|
|
}
|
|
Riemann::Right => {
|
|
FunctionHelper::new(|_: f64, right_x: f64| -> f64 { self.function.get(right_x) })
|
|
}
|
|
Riemann::Middle => FunctionHelper::new(|left_x: f64, right_x: f64| -> f64 {
|
|
(self.function.get(left_x) + self.function.get(right_x)) / 2.0
|
|
}),
|
|
}
|
|
}
|
|
|
|
/// Creates and does the math for creating all the rectangles under the
|
|
/// graph
|
|
fn integral_rectangles(
|
|
&self, integral_min_x: &f64, integral_max_x: &f64, sum: &Riemann, integral_num: &usize,
|
|
) -> (Vec<(f64, f64)>, f64) {
|
|
if integral_min_x.is_nan() {
|
|
panic!("integral_min_x is NaN")
|
|
} else if integral_max_x.is_nan() {
|
|
panic!("integral_max_x is NaN")
|
|
}
|
|
|
|
let step = (integral_min_x - integral_max_x).abs() / (*integral_num as f64);
|
|
|
|
let sum_func = self.get_sum_func(*sum);
|
|
|
|
let data2: Vec<(f64, f64)> = dyn_iter(&step_helper(*integral_num, integral_min_x, &step))
|
|
.map(|x| {
|
|
let step_offset = step * x.signum(); // store the offset here so it doesn't have to be calculated multiple times
|
|
let x2: f64 = x + step_offset;
|
|
|
|
let (left_x, right_x) = match x.is_sign_positive() {
|
|
true => (*x, x2),
|
|
false => (x2, *x),
|
|
};
|
|
|
|
let y = sum_func.get(left_x, right_x);
|
|
|
|
(x + (step_offset / 2.0), y)
|
|
})
|
|
.filter(|(_, y)| !y.is_nan())
|
|
.collect();
|
|
|
|
let area = data2.iter().map(|(_, y)| y * step).sum();
|
|
|
|
(data2, area)
|
|
}
|
|
|
|
/// Helps with processing newton's method depending on level of derivative
|
|
fn newtons_method_helper(
|
|
&self, threshold: &f64, derivative_level: usize,
|
|
) -> Option<Vec<Value>> {
|
|
let range = self.min_x..self.max_x;
|
|
let newtons_method_output: Vec<f64> = match derivative_level {
|
|
0 => newtons_method_helper(
|
|
threshold,
|
|
&range,
|
|
self.back_data.as_ref().unwrap(),
|
|
&|x: f64| self.function.get(x),
|
|
&|x: f64| self.function.get_derivative_1(x),
|
|
),
|
|
1 => newtons_method_helper(
|
|
threshold,
|
|
&range,
|
|
self.derivative_data.as_ref().unwrap(),
|
|
&|x: f64| self.function.get_derivative_1(x),
|
|
&|x: f64| self.function.get_derivative_2(x),
|
|
),
|
|
_ => unreachable!(),
|
|
};
|
|
|
|
if newtons_method_output.is_empty() {
|
|
None
|
|
} else {
|
|
Some(
|
|
dyn_iter(&newtons_method_output)
|
|
.map(|x| Value::new(*x, self.function.get(*x)))
|
|
.collect(),
|
|
)
|
|
}
|
|
}
|
|
|
|
/// Does the calculations and stores results in `self`
|
|
pub fn calculate(
|
|
&mut self, min_x: &f64, max_x: &f64, width_changed: bool, settings: &AppSettings,
|
|
) {
|
|
if self.invalid {
|
|
return;
|
|
}
|
|
|
|
let resolution: f64 = settings.plot_width as f64 / (max_x.abs() + min_x.abs());
|
|
let resolution_iter = resolution_helper(&settings.plot_width + 1, min_x, &resolution);
|
|
|
|
// Makes sure proper arguments are passed when integral is enabled
|
|
if self.integral && settings.integral_changed {
|
|
self.invalidate_integral();
|
|
}
|
|
|
|
let mut partial_regen = false;
|
|
let min_max_changed = (min_x != &self.min_x) | (max_x != &self.max_x);
|
|
|
|
let derivative_required = settings.do_extrema | self.derivative;
|
|
|
|
self.min_x = *min_x;
|
|
self.max_x = *max_x;
|
|
if width_changed {
|
|
self.invalidate_back();
|
|
self.invalidate_derivative();
|
|
} else if min_max_changed && self.back_data.is_some() {
|
|
partial_regen = true;
|
|
|
|
let back_cache = self.back_data.as_ref().unwrap();
|
|
|
|
let x_data: SteppedVector = back_cache
|
|
.iter()
|
|
.map(|ele| ele.x)
|
|
.collect::<Vec<f64>>()
|
|
.into();
|
|
|
|
let back_data: Vec<Value> = dyn_iter(&resolution_iter)
|
|
.map(|x| {
|
|
if let Some(i) = x_data.get_index(x) {
|
|
back_cache[i]
|
|
} else {
|
|
Value::new(*x, self.function.get(*x))
|
|
}
|
|
})
|
|
.collect();
|
|
debug_assert_eq!(back_data.len(), settings.plot_width + 1);
|
|
self.back_data = Some(back_data);
|
|
|
|
if derivative_required {
|
|
let derivative_cache = self.derivative_data.as_ref().unwrap();
|
|
let new_derivative_data: Vec<Value> = dyn_iter(&resolution_iter)
|
|
.map(|x| {
|
|
if let Some(i) = x_data.get_index(x) {
|
|
derivative_cache[i]
|
|
} else {
|
|
Value::new(*x, self.function.get_derivative_1(*x))
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
debug_assert_eq!(new_derivative_data.len(), settings.plot_width + 1);
|
|
|
|
self.derivative_data = Some(new_derivative_data);
|
|
} else {
|
|
self.derivative_data = None;
|
|
}
|
|
} else {
|
|
self.invalidate_back();
|
|
self.invalidate_derivative();
|
|
}
|
|
|
|
let threshold: f64 = resolution / 2.0;
|
|
|
|
if !partial_regen {
|
|
if self.back_data.is_none() {
|
|
let data: Vec<Value> = dyn_iter(&resolution_iter)
|
|
.map(|x| Value::new(*x, self.function.get(*x)))
|
|
.collect();
|
|
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
|
|
|
self.back_data = Some(data);
|
|
}
|
|
|
|
if derivative_required && self.derivative_data.is_none() {
|
|
let data: Vec<Value> = dyn_iter(&resolution_iter)
|
|
.map(|x| Value::new(*x, self.function.get_derivative_1(*x)))
|
|
.collect();
|
|
debug_assert_eq!(data.len(), settings.plot_width + 1);
|
|
self.derivative_data = Some(data);
|
|
}
|
|
}
|
|
|
|
if self.integral {
|
|
if self.integral_data.is_none() {
|
|
let (data, area) = self.integral_rectangles(
|
|
&settings.integral_min_x,
|
|
&settings.integral_max_x,
|
|
&settings.riemann_sum,
|
|
&settings.integral_num,
|
|
);
|
|
self.integral_data =
|
|
Some((data.iter().map(|(x, y)| Bar::new(*x, *y)).collect(), area));
|
|
}
|
|
} else {
|
|
self.invalidate_integral();
|
|
}
|
|
|
|
// Calculates extrema
|
|
if settings.do_extrema && (min_max_changed | self.extrema_data.is_none()) {
|
|
self.extrema_data = self.newtons_method_helper(&threshold, 1);
|
|
}
|
|
|
|
// Calculates roots
|
|
if settings.do_roots && (min_max_changed | self.roots_data.is_none()) {
|
|
self.roots_data = self.newtons_method_helper(&threshold, 0);
|
|
}
|
|
}
|
|
|
|
/// Displays the function's output on PlotUI `plot_ui` with settings
|
|
/// `settings`. Returns an `Option<f64>` of the calculated integral
|
|
pub fn display(&self, plot_ui: &mut PlotUi, settings: &AppSettings) -> Option<f64> {
|
|
if self.invalid {
|
|
return None;
|
|
}
|
|
|
|
let derivative_str = self.function.get_derivative_str();
|
|
let step = (settings.integral_min_x - settings.integral_max_x).abs()
|
|
/ (settings.integral_num as f64);
|
|
// Plot back data
|
|
if let Some(back_data) = &self.back_data {
|
|
plot_ui.line(
|
|
back_data
|
|
.clone()
|
|
.to_line()
|
|
.color(Color32::RED)
|
|
.name(self.get_func_raw()),
|
|
);
|
|
}
|
|
|
|
// Plot derivative data
|
|
if self.derivative {
|
|
if let Some(derivative_data) = &self.derivative_data {
|
|
plot_ui.line(
|
|
derivative_data
|
|
.clone()
|
|
.to_line()
|
|
.color(Color32::GREEN)
|
|
.name(derivative_str),
|
|
);
|
|
}
|
|
}
|
|
|
|
// Plot extrema points
|
|
if settings.do_extrema {
|
|
if let Some(extrema_data) = &self.extrema_data {
|
|
plot_ui.points(
|
|
extrema_data
|
|
.clone()
|
|
.to_points()
|
|
.color(Color32::YELLOW)
|
|
.name("Extrema")
|
|
.radius(5.0), // Radius of points of Extrema
|
|
);
|
|
}
|
|
}
|
|
|
|
// Plot roots points
|
|
if settings.do_roots {
|
|
if let Some(roots_data) = &self.roots_data {
|
|
plot_ui.points(
|
|
roots_data
|
|
.clone()
|
|
.to_points()
|
|
.color(Color32::LIGHT_BLUE)
|
|
.name("Root")
|
|
.radius(5.0), // Radius of points of Roots
|
|
);
|
|
}
|
|
}
|
|
|
|
// Plot integral data
|
|
if let Some(integral_data) = &self.integral_data {
|
|
plot_ui.bar_chart(
|
|
BarChart::new(integral_data.0.clone())
|
|
.color(Color32::BLUE)
|
|
.width(step),
|
|
);
|
|
|
|
// return value rounded to 8 decimal places
|
|
Some(crate::misc::decimal_round(integral_data.1, 8))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Invalidate entire cache
|
|
pub fn invalidate_whole(&mut self) {
|
|
self.back_data = None;
|
|
self.integral_data = None;
|
|
self.derivative_data = None;
|
|
self.extrema_data = None;
|
|
self.roots_data = None;
|
|
}
|
|
|
|
/// Invalidate `back` data
|
|
pub fn invalidate_back(&mut self) { self.back_data = None; }
|
|
|
|
/// Invalidate Integral data
|
|
pub fn invalidate_integral(&mut self) { self.integral_data = None; }
|
|
|
|
/// Invalidate Derivative data
|
|
pub fn invalidate_derivative(&mut self) { self.derivative_data = None; }
|
|
|
|
/// Runs asserts to make sure everything is the expected value
|
|
#[cfg(test)]
|
|
pub fn tests(
|
|
&mut self, settings: AppSettings, back_target: Vec<(f64, f64)>,
|
|
derivative_target: Vec<(f64, f64)>, area_target: f64, min_x: f64, max_x: f64,
|
|
) {
|
|
{
|
|
self.calculate(&min_x, &max_x, true, &settings);
|
|
let settings = settings;
|
|
let back_target = back_target;
|
|
assert!(self.back_data.is_some());
|
|
let back_data = self.back_data.as_ref().unwrap().clone();
|
|
assert_eq!(back_data.len(), settings.plot_width + 1);
|
|
let back_vec_tuple = back_data.to_tuple();
|
|
assert_eq!(back_vec_tuple, back_target);
|
|
|
|
assert!(self.integral);
|
|
assert!(self.derivative);
|
|
|
|
assert_eq!(self.roots_data.is_some(), settings.do_roots);
|
|
assert_eq!(self.extrema_data.is_some(), settings.do_extrema);
|
|
assert!(self.derivative_data.is_some());
|
|
assert!(self.integral_data.is_some());
|
|
|
|
assert_eq!(
|
|
self.derivative_data.as_ref().unwrap().to_tuple(),
|
|
derivative_target
|
|
);
|
|
|
|
assert_eq!(self.integral_data.clone().unwrap().1, area_target);
|
|
}
|
|
|
|
{
|
|
self.update("x^3", false, false);
|
|
assert!(!self.integral);
|
|
assert!(!self.derivative);
|
|
|
|
assert!(self.back_data.is_none());
|
|
assert!(self.integral_data.is_none());
|
|
assert!(self.roots_data.is_none());
|
|
assert!(self.extrema_data.is_none());
|
|
assert!(self.derivative_data.is_none());
|
|
|
|
self.calculate(&min_x, &max_x, true, &settings);
|
|
|
|
assert!(self.back_data.is_some());
|
|
assert!(self.integral_data.is_none());
|
|
assert!(self.roots_data.is_none());
|
|
assert!(self.extrema_data.is_none());
|
|
assert!(self.derivative_data.is_none());
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn app_settings_constructor(
|
|
sum: Riemann, integral_min_x: f64, integral_max_x: f64, pixel_width: usize,
|
|
integral_num: usize,
|
|
) -> AppSettings {
|
|
crate::math_app::AppSettings {
|
|
riemann_sum: sum,
|
|
integral_min_x,
|
|
integral_max_x,
|
|
integral_changed: true,
|
|
integral_num,
|
|
do_extrema: false,
|
|
do_roots: false,
|
|
plot_width: pixel_width,
|
|
}
|
|
}
|
|
|
|
static BACK_TARGET: [(f64, f64); 11] = [
|
|
(-1.0, 1.0),
|
|
(-0.8, 0.6400000000000001),
|
|
(-0.6, 0.36),
|
|
(-0.4, 0.16000000000000003),
|
|
(-0.19999999999999996, 0.03999999999999998),
|
|
(0.0, 0.0),
|
|
(0.19999999999999996, 0.03999999999999998),
|
|
(0.3999999999999999, 0.15999999999999992),
|
|
(0.6000000000000001, 0.3600000000000001),
|
|
(0.8, 0.6400000000000001),
|
|
(1.0, 1.0),
|
|
];
|
|
|
|
static DERIVATIVE_TARGET: [(f64, f64); 11] = [
|
|
(-1.0, -2.0),
|
|
(-0.8, -1.6),
|
|
(-0.6, -1.2),
|
|
(-0.4, -0.8),
|
|
(-0.19999999999999996, -0.3999999999999999),
|
|
(0.0, 0.0),
|
|
(0.19999999999999996, 0.3999999999999999),
|
|
(0.3999999999999999, 0.7999999999999998),
|
|
(0.6000000000000001, 1.2000000000000002),
|
|
(0.8, 1.6),
|
|
(1.0, 2.0),
|
|
];
|
|
|
|
fn do_test(sum: Riemann, area_target: f64) {
|
|
let settings = app_settings_constructor(sum, -1.0, 1.0, 10, 10);
|
|
|
|
let mut function = FunctionEntry::default();
|
|
function.update("x^2", true, true);
|
|
|
|
function.tests(
|
|
settings,
|
|
BACK_TARGET.to_vec(),
|
|
DERIVATIVE_TARGET.to_vec(),
|
|
area_target,
|
|
-1.0,
|
|
1.0,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn function_entry_test() {
|
|
do_test(Riemann::Left, 0.9600000000000001);
|
|
do_test(Riemann::Middle, 0.92);
|
|
do_test(Riemann::Right, 0.8800000000000001);
|
|
}
|
|
}
|