Add polynomial_interpolation.py; implement ~half.

algorithms/polynomial_interpolation.py
	-Implement roughly half of the Newtonian polynomial
	interpolation algorithm in `interpolate_polynomial_value()`:
	the function currently generates a divided-differences table.
	-Define `test_polynomial_interpolation()` to test
	`interpolate_polynomial_value()`.
Finish polynomial interpolation implementation.

algorithms/polynomial_interpolation.py
	-Complete the definitions of `interpolate_polynomial_value()`
	and `test_polynomial_interpolation()`.
	-Add function and module header docstrings.
Add incomplete animation for polynomial interp.

algorithms/animation.py
	-Add an incomplete module that will produce an animation of
	polynomial interpolation using `polynomial_interpolation.py` and
	`matplotlib`.
Complete first polynomial interpolation animation.

algorithms/animation.py
	-Complete the first polynomial interpolation animation, which
	renders three separate elements: a graph, an increasing number
	of points on said graph, and a set of interpolated points.
Revise first and last interpolation animation.

algorithms/animation.py
	-Make final adjustments to the interpolation animation. Add a
	statement to save the animation to an `mp4`.
	-Add docstrings to `animate()`, `reset_frame()` (renamed from
	`init()`), and `render_frame()` (renamed from `animate()`).
Create `polynomial_interpolation` directory.

algorithms/(polynomial_interpolation, animation).py ->
algorithms/polynomial_interpolation/
	-Move all polynomial interpolation modules into a standalone
	directory, `polynomial_interpolation/`.
Add interpolation gif/mp4 in animation/.

algorithms/polynomial_interpolation/
(animation.py, animation/(interpolation.(gif, mp4)))
	-Create a directory `animation/`, to contain the interpolation
	`mp4` generated by `animation.py` and converted `gif`.
Add an interpolaton animation of sin().

algorithms/polynomial_interpolation/animation/
(interpolation.* -> interpolation1.*)
	-Rename existing animations.

algorithms/polynomial_interpolation/animation/(interpolation.*)
	-Add new animations of the interpolation of `sin()`.
Add an irregular polynomial interp. animation.

algorithms/polynomial_interpolation/(animation.py, animation/*)
	-Add an animation of the interpolation of another, slightly
	irregular polynomial.
Merge branch 'feature/algorithm.polynomial_interpolation' into develop

algorithms/polynomial_interpolation/
	-Implement divided-differences polynomial interpolation
	(Newtown's method).
Implement least-squares estimation.

algorithms/least_squares_estimation/least_squares_estimation.py
	-Implement and document the least-squares estimation algorithm
	in `estimate_coefficients()`.
Add unit-test to least-squares estimation.

algorithms/least_squares_estimation/least_squares_estimation.py
	-Define and document `unit_test()` to test the output of
	`estimate_coefficients()`.
	-Add a `main` block to run `unit_test()`.
Add a visual demo of least-squares estimation.

algorithms/least_squares_estimation/demo.py
	-Add a module to visually demonstrate the creation of a best-fit
	line using `least_squares_estimation.estimate_coefficients()`.
	-Define `demo()`, which creates the demo using `matplotlib`.

algorithms/least_squares_estimation/least_squares_estimation.py
	-Add some brief comments to `estimate_coefficients()`.
Finalize the least-squares estimation demo.

algorithms/least_squares_estimation/demo.py
	-Improve and complete the least-squares estimation demo by
	offsetting the range of the dataset by a small random value
	after it was computed with an arbitrary polynomial, so that the
	points are at least somewhat mathematically similar (and not
	perfectly random, in which case a best-fit curve is pointless).
Minor formatting fix in demo.py.

algorithms/least_squares_estimation/demo.py
	-Break a long statement across two lines.
Merge branch 'feature/algorithms.least_squares_estimation' into develop

algorithms/least_squares_estimation/
	-Implement the least-squares estimation algorithm, and a
	`matplotlib` graphic that demonstrates its use in computing
	the best-fit line for a randomized dataset.
Begin polynomial roots implementation.

algorithms/polynomial_roots/(demo, polynomial_roots).py
	-Begin implementing a polynomial-root calculator.
	-Add skeleton code to `polynomial_roots.py`, and some
	`matplotlib` boilerplate to `demo.py`.
Implement the polynomial root algorithm.

algorithms/polynomial_roots/polynomial_roots.py
	-Implement Newton's polynomial-root computation algorithm.
	-Move parts of the `main` block to `demo.py`, and remove the
	remainder from `polynomial_roots.py`.

algorithms/polynomial_roots/demo.py
	-Use `numpy.linspace()` to create the domain of the plotted
	curve instead of `range()`.
Rm demo.py, move main back to polynomial_roots.py.

algorithms/polynomial_roots/demo.py
	-Remove the `matplotlib` animation, because it can't be used to
	effectively (read: in an interesting way) demonstrate the
	process of root estimation.
	-Move most of the `main` block back to `polynomial_roots.py`.
Fin. the polynomial root algorithm implementation.

algorithms/polynomial_roots/polynomial_roots.py
	-Complete my implementation of the polynomial-root estimation
	algorithm.
	-Add a docstring to `polynomial_root()` and the module header.