Added readme

readme.md

@@ -0,0 +1,53 @@
+# DifferentialEquations
+
+A library, written in Rust, for integrating ordinary differential equations. For now, this is
+relatively simple, but it does have key features that are needed for orbit propagation, ray tracing,
+and field line tracing:
+
+## Features
+
+- A relatively efficient Dormand Prince 5th(4th) order integration algorithm, which is effective for
+    non-stiff problems
+- A PI-controller for adaptive time stepping
+- The ability to define "callback events" and stop or change the integator or underlying ODE if
+    certain conditions are met (zero crossings)
+- A fourth order interpolator for the Domand Prince algorithm
+
+
+### Future Improvements
+
+- More algorithms
+    - Rosenbrock
+    - Tsit(5)
+    - Runge Kutta Cash Karp
+- Automatic Stiffness Detection
+- Boolean callback eventing
+
+## To Use
+
+For now, here is a simple example of using the propagator to solve a simple system:
+
+```rust
+use nalgebra::Vector3;
+use differential_equations::integrator::dormand_prince::DormandPrince45;
+use differential_equations::controller::PIController;
+use differential_equations::callback::stop;
+use differential_equations::problem::*;
+
+// Define the system
+fn derivative(_t: f64, y: Vector3<f64>) -> Vector3<f64> { y }
+let y0 = Vector3::new(1.0, 1.0, 1.0);
+
+let ode = ODE::new(&derivative, 0.0, 5.0, y0);
+let dp45 = DormandPrince45::new(1e-12_f64, 1e-5_f64);
+let controller = PIController::new(0.17, 0.04, 10.0, 0.2, 0.1, 0.9, 1e-8);
+
+let value_too_high = Callback {
+    event: &|_: f64, y: SVector<f64,3>| { 10.0 - y[0] },
+    effect: &stop,
+};
+
+let mut problem = Problem::new(ode, dp45, controller).with_callback(value_too_high);
+let solution = problem.solve();
+let interpolated_answer = solution.interpolate(8.2);
+```