partition for vec

Author: kmolan

Cargo.toml

@@ -19,4 +19,8 @@ num-complex = "0.4.6"
 [dev-dependencies]
 rand = "0.8"
 
+[features]
+default = []
+vectors = []
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

README.md

@@ -9,7 +9,7 @@ Rust scientific computing for single and multi-variable calculus
 ## Salient Features
 
 - Written in pure, safe rust
-- no-std with zero heap allocations and no panics
+- no-std friendly with zero heap allocations and no panics
 - Trait-based generic implementation to support floating point and complex numbers
 - Fully documented with code examples
 - Comprehensive suite of tests for full code coverage, including all possible error conditions
@@ -25,9 +25,16 @@ Rust scientific computing for single and multi-variable calculus
   - Approximation of any given equation to a linear or quadratic mode
 
 
-## Table of Contents
+_Note: As of version 0.5.0, the crate structure has changed. In order to accomodate std::Vec, the crate has been partitioned to "core" and "vec". By default, no-std is enabled with zero heap allocations. These modules live in "core". An optional feature "vectors" can be enabled to access modules in "vec" that use std::Vec instead of rust static arrays. For the difference in usage, consult the test examples. To use the vectors feature, paste this in your Cargo.toml:_
+
+```toml
+[dependencies]
+multicalc = {version = "*", features = ["vectors"] }  #Replace "*" with version number
+```
 
 
+## Table of Contents
+
 - [1. Single total derivatives](#1-single-total-derivatives)
 - [2. Single partial derivatives](#2-single-partial-derivatives)
 - [3. Double total derivatives](#3-double-total-derivatives)

src/approximation/linear_approximation.rs …re/approximation/linear_approximation.rssrc/approximation/linear_approximation.rs renamed to src/core/approximation/linear_approximation.rs src/approximation/linear_approximation.rs renamed to src/core/approximation/linear_approximation.rs

@@ -1,5 +1,5 @@
-use crate::numerical_derivative::single_derivative as single_derivative;
-use crate::numerical_derivative::mode as mode;
+use crate::core::numerical_derivative::single_derivative as single_derivative;
+use crate::core::numerical_derivative::mode as mode;
 use crate::utils::error_codes::ErrorCode;
 use num_complex::ComplexFloat;
 
@@ -86,7 +86,7 @@ impl<T: ComplexFloat, const NUM_VARS: usize> LinearApproximationResult<T, NUM_VA
 ///
 ///example function is x + y^2 + z^3, which we want to linearize. First define the function:
 ///```
-///use multicalc::approximation::linear_approximation;
+///use multicalc::core::approximation::linear_approximation;
 /// 
 ///let function_to_approximate = | args: &[f64; 3] | -> f64
 ///{ 

src/approximation/mod.rs src/core/approximation/mod.rssrc/approximation/mod.rs renamed to src/core/approximation/mod.rs

@@ -1,6 +1,6 @@
-use crate::numerical_derivative::mode as mode;
-use crate::numerical_derivative::single_derivative as single_derivative;
-use crate::numerical_derivative::hessian as hessian;
+use crate::core::numerical_derivative::mode as mode;
+use crate::core::numerical_derivative::single_derivative as single_derivative;
+use crate::core::numerical_derivative::hessian as hessian;
 use crate::utils::error_codes::ErrorCode;
 use num_complex::ComplexFloat;
 
@@ -98,7 +98,7 @@ impl<T: ComplexFloat, const NUM_VARS: usize> QuadraticApproximationResult<T, NUM
 ///
 ///example function is e^(x/2) + sin(y) + 2.0*z, which we want to approximate. First define the function:
 ///```
-///use multicalc::approximation::quadratic_approximation;
+///use multicalc::core::approximation::quadratic_approximation;
 /// 
 ///let function_to_approximate = | args: &[f64; 3] | -> f64
 ///{ 

…approximation/quadratic_approximation.rs …approximation/quadratic_approximation.rssrc/approximation/quadratic_approximation.rs renamed to src/core/approximation/quadratic_approximation.rs src/approximation/quadratic_approximation.rs renamed to src/core/approximation/quadratic_approximation.rs

@@ -1,5 +1,5 @@
-use crate::approximation::linear_approximation;
-use crate::approximation::quadratic_approximation;
+use crate::core::approximation::linear_approximation;
+use crate::core::approximation::quadratic_approximation;
 use rand::Rng;
 
 #[test]

src/approximation/test.rs src/core/approximation/test.rssrc/approximation/test.rs renamed to src/core/approximation/test.rs

@@ -0,0 +1,4 @@
+pub mod approximation;
+pub mod numerical_derivative;
+pub mod numerical_integration;
+pub mod vector_field;

src/core/mod.rs

@@ -1,5 +1,5 @@
-use crate::numerical_derivative::single_derivative;
-use crate::numerical_derivative::mode as mode;
+use crate::core::numerical_derivative::single_derivative;
+use crate::core::numerical_derivative::mode as mode;
 use crate::utils::error_codes::ErrorCode;
 use num_complex::ComplexFloat;
 
@@ -19,7 +19,7 @@ use num_complex::ComplexFloat;
 ///// We also need to define the point at which we want to differentiate. Assuming our point x = 5.0
 ///// if we then want to differentiate this function over x with a step size of 0.001, we would use:
 ///
-/// use multicalc::numerical_derivative::double_derivative;
+/// use multicalc::core::numerical_derivative::double_derivative;
 /// 
 /// let val = double_derivative::get_total(&my_func,      //<- our closure                                           
 ///                                         5.0);         //<- point around which we want to differentiate
@@ -40,7 +40,7 @@ use num_complex::ComplexFloat;
 /// //point of interest is x = (5.0 + 2.5i)
 /// let point = num_complex::c64(5.0, 2.5);
 /// 
-/// use multicalc::numerical_derivative::double_derivative;
+/// use multicalc::core::numerical_derivative::double_derivative;
 ///
 /// let val = double_derivative::get_total(&my_func,   //<- our closure                                          
 ///                                        point);     //<- point around which we want to differentiate
@@ -99,7 +99,7 @@ pub fn get_total_custom<T: ComplexFloat, const NUM_VARS: usize>(func: &dyn Fn(&[
 ///
 ///// if we then want to partially differentiate this function first over x then y, for (x, y, z) = (1.0, 2.0, 3.0) with a step size of 0.001, we would use:
 ///
-/// use multicalc::numerical_derivative::double_derivative;
+/// use multicalc::core::numerical_derivative::double_derivative;
 /// 
 /// let val = double_derivative::get_partial(&my_func,   //<- our closure                
 ///                                          &[0, 1],    //<- idx, index of variables we want to differentiate                            
@@ -121,7 +121,7 @@ pub fn get_total_custom<T: ComplexFloat, const NUM_VARS: usize>(func: &dyn Fn(&[
 /// //point of interest is (x, y, z) = (1.0 + 4.0i, 2.0 + 2.5i, 3.0 + 0.0i)
 /// let point = [num_complex::c64(1.0, 4.0), num_complex::c64(2.0, 2.5), num_complex::c64(3.0, 0.0)];
 /// 
-/// use multicalc::numerical_derivative::double_derivative;
+/// use multicalc::core::numerical_derivative::double_derivative;
 ///
 /// let val = double_derivative::get_partial(&my_func,   //<- our closure                
 ///                                          &[0, 1],    //<- idx, index of variables we want to differentiate                            

…umerical_derivative/double_derivative.rs …umerical_derivative/double_derivative.rssrc/numerical_derivative/double_derivative.rs renamed to src/core/numerical_derivative/double_derivative.rs src/numerical_derivative/double_derivative.rs renamed to src/core/numerical_derivative/double_derivative.rs

@@ -1,5 +1,5 @@
-use crate::numerical_derivative::double_derivative as double_derivative;
-use crate::numerical_derivative::mode as mode;
+use crate::core::numerical_derivative::double_derivative as double_derivative;
+use crate::core::numerical_derivative::mode as mode;
 use crate::utils::error_codes::ErrorCode;
 use num_complex::ComplexFloat;
 
@@ -14,7 +14,7 @@ use num_complex::ComplexFloat;
 /// 
 /// assume our function is y*sin(x) + 2*x*e^y. First define the function
 /// ```
-/// use multicalc::numerical_derivative::hessian;
+/// use multicalc::core::numerical_derivative::hessian;
 ///    let my_func = | args: &[f64; 2] | -> f64 
 ///    { 
 ///        return args[1]*args[0].sin() + 2.0*args[0]*args[1].exp();
@@ -27,7 +27,7 @@ use num_complex::ComplexFloat;
 /// 
 /// the above example can also be extended to complex numbers:
 ///```
-/// use multicalc::numerical_derivative::hessian;
+/// use multicalc::core::numerical_derivative::hessian;
 ///    let my_func = | args: &[num_complex::Complex64; 2] | -> num_complex::Complex64 
 ///    { 
 ///        return args[1]*args[0].sin() + 2.0*args[0]*args[1].exp();

src/numerical_derivative/hessian.rs src/core/numerical_derivative/hessian.rssrc/numerical_derivative/hessian.rs renamed to src/core/numerical_derivative/hessian.rs

@@ -1,5 +1,5 @@
-use crate::numerical_derivative::single_derivative;
-use crate::numerical_derivative::mode as mode;
+use crate::core::numerical_derivative::single_derivative;
+use crate::core::numerical_derivative::mode as mode;
 use crate::utils::error_codes::ErrorCode;
 use num_complex::ComplexFloat;
 
@@ -20,7 +20,7 @@ use num_complex::ComplexFloat;
 /// 
 /// assume our function vector is (x*y*z ,  x^2 + y^2). First define both the functions
 /// ```
-/// use multicalc::numerical_derivative::jacobian;
+/// use multicalc::core::numerical_derivative::jacobian;
 ///    let my_func1 = | args: &[f64; 3] | -> f64 
 ///    { 
 ///        return args[0]*args[1]*args[2]; //x*y*z
@@ -40,7 +40,7 @@ use num_complex::ComplexFloat;
 /// 
 /// the above example can also be extended to complex numbers:
 ///```
-/// use multicalc::numerical_derivative::jacobian;
+/// use multicalc::core::numerical_derivative::jacobian;
 ///    let my_func1 = | args: &[num_complex::Complex64; 3] | -> num_complex::Complex64 
 ///    { 
 ///        return args[0]*args[1]*args[2]; //x*y*z