@zushah/chalkboard 1.5.0

package/CHANGELOG.md

@@ -0,0 +1,111 @@
+# Chalkboard changelog
+All notable changes of every update of the Chalkboard library are recorded in this file.
+
+## [v1.5.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0) - 12/18/2023
+The seventh release of the Chalkboard library.
+Commits: [`v1.4.0...v1.5.0`](https://github.com/Zushah/Chalkboard/compare/v1.4.0...v1.5.0)
+- Added Chalkboard as an npm package, so now it can be used on the server-side just like the client side
+- Added `comp.function`, `comp.parse`, and `comp.val` to define, parse, and evaluate complex functions
+- Added `calc.dfdz`, `calc.d2fdz2`, and `calc.fzdz` to calculate the first derivatives, second derivatives, and antiderivatives of complex functions
+- Added approximations of functions using Taylor series with `calc.Taylor` and `plot.Taylor`
+- Added `comp.pow` to calculate the exponentiation of a complex number
+- Added `comp.root` to calculate the roots of a complex number
+- Added `comp.invert` (calculates the multiplicative inverse of a complex number) to replace the functionality of `comp.reciprocate`
+- Removed `stat.gte` and `stat.lte` and respectively incorporated their functionalities into `stat.gt` and `stat.lt`
+- Changed `comp.reciprocate` to return the reciprocals of the components of a complex number instead of returning the multiplicative inverse of a complex number
+- Changed `stat.gt` and `stat.lt` to have `includeEnd` parameters which determines whether the conditional they check for is "greater/less than" (input false) or "greater/less than or equal to" (input true)
+- Changed `plot.barplot` and `plot.lineplot` to use the new functionalities of `stat.gt` and `stat.lt` instead of the removed `stat.gte` and `stat.lte`
+- Changed `comp.Re` and `comp.Im` to respectively return the real and imaginary components of complex functions, too, instead of only the real and imaginary components of complex numbers
+- Changed `stat.toObject` to return an object with its properties named based on the array's index instead of the array's element
+- Changed `trig.arctan2` to use `Math.atan` instead of `trig.arctan` to be faster
+- Changed the name of `calc.frdt` to `calc.frds`
+- Changed `plot.function` to accept complex functions as inputs to plot their domain colorings
+- Fixed the error messages in `calc.dfdrt` which were misspelled
+- Fixed `plot.field` to include the upper bounds in its domain
+
+## [v1.4.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.4.0) - 12/11/2023
+The sixth release of the Chalkboard library.
+Commits: [`v1.3.1...v1.4.0`](https://github.com/Zushah/Chalkboard/compare/v1.3.1...v1.4.0)
+- Added many new commands for arrays: creating an array of random numbers, calculating different types of the norm (and the squared norm) of an array, calculating the normalized array, calculating the array that has the numbers that are equal to, greater than (or equal to), less than (or equal to), or some compound inequality of another number or array, calculating the skewness and kurtosis of an array, calculating the different quartiles of an array, and converting an array to a vector, matrix, object, string, or printing it in the console
+- Added `plot.barplot`, `plot.lineplot`, and `plot.scatterplot` to plot arrays of data
+- Added `.constrain` commands for numbers, arrays, complex numbers, quaternions, vectors, and matrices to constrain their values within a range
+- Added `trig.arctan2` to accurately calculate the angle between a vector and the positive x-axis
+- Added `numb.sum` and `numb.mul` for the calculation of specified summation and product formulae
+- Added `.reflect` and `.refract` commands for vectors to calculate reflection and refraction vectors
+- Added `real.pingpong` to calculate the ping-pong function
+- Added `geom.mid` to calculate the midpoint between two multidimensional points
+- Changed all of the `plot` commands to return an array of data containing all of the ordered pairs of plotted points instead of returning a string with details on what was plotted and how
+- Changed `real.parse` to have an optional command to input initializing code before the return function
+- Changed `vec2.ang`, `comp.arg`, and `comp.ln` to use `trig.arctan2` instead of `trig.arctan`
+- Changed `real.Heaviside`, `real.Dirac`, `real.ramp`, and `real.rect` to have parameters for the `edge` (the starting point) and the `scl` (scalar multiplication) of their respective functions
+- Changed `comp.new` and `quat.new` to have a `type` property (like the `.new` commands for vectors) that's always set to `"comp"` and `"quat"`, respectively
+- Changed `geom.dist` and `geom.distsq` to be written with loops instead of array methods
+- Changed `calc.frdt` to also work for three-dimensional (instead of only two-dimensional) vector fields and parametric curves
+- Fixed `calc.dfrdt` which didn't work due to a slight misspelling in an `if()` statement
+
+## [v1.3.1](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.3.1) - 12/04/2023
+The fifth release of the Chalkboard library.
+Commits: [`v1.3.0...v1.3.1`](https://github.com/Zushah/Chalkboard/compare/v1.3.0...v1.3.1)
+- Fixed `matr.translator` which was misspelled
+- Fixed `matr.rotator` which didn't work for two-dimensional rotations and was also misspelled
+- Fixed `calc.grad` which didn't work for vector fields because of another misspelling
+
+## [v1.3.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.3.0) - 12/04/2023
+The fourth release of the Chalkboard library.
+Commits: [`v1.2.0...v1.3.0`](https://github.com/Zushah/Chalkboard/compare/v1.2.0...v1.3.0)
+- Added multivariable calculus, with commands for directional differentiation, multivariable chain rule, gradient (partial differentiation), double gradient (second-order partial differentiation), divergence, curl, double integration, line/surface integration, arc length, surface area, and curvature
+- Added second-order differentiation with `calc.d2fdx2`, unit tangent vectors for parametric curves with `calc.tangent`, unit normal vectors with `calc.normal`, and unit binormal vectors with `calc.binormal`
+- Functions that previously had the `type` property of `"para"` should now be changed to `"curv"`
+- Added `.field` and `.fromField` commmands for vectors which define vector fields and evaluate them at particular vectors, respectively
+- Added `plot.field` and `plot.d2fdx2` to plot vector fields and second-order derivatives, respectively
+- Added `.proj` and `.oproj` commands for vectors which calculate the vector projections and rejections, respectively
+- Added commands for vectors to convert between coordinate systems (`vec2.fromPolar`, `vec3.toSpherical`, etc)
+- Changed `matr.toVector` to have another optional parameter for the row/column of a matrix to define a vector from
+- Added `comp.scl` and `quat.scl`, and changed all of the `.magset` commands to work using their respective `.scl` commands
+- Added a `type` parameter to `stat.mean` to enable the calculation of different types of means: arithmetic, geometric, and harmonic
+- Removed `geom.dist2D` and `geom.dist3D` and replaced them with `geom.dist` and `geom.distsq` which can calculate the distance between any-dimensional points
+- Removed `vec2.rotate2D`, `vec3.rotatex`, `vec3.rotatey`, and `vec3.rotatez` because all vector rotations can be handled with rotation matrices
+- Removed `matr.rotater2D` and `matr.rotater3D` and replaced them with `matr.rotater` which can do both 2D and 3D rotations depending on the number of parameters inputted (one parameter required for 2D rotations, three parameters required for 3D rotations)
+- Removed `real.sqrt` from returning a complex number when the input is negative because it would sometimes cause bugs
+- Changed `real.function`, `real.parse`, `calc.dfdx`, and `calc.fxdx` to work for the new `"mult"` function type for multivariable functions, the new `"curv"` function type for parametric curves, and the new `"surf"` function type for parametric surfaces
+- Changed all `plot` commands so they can now optionally have their opacity changed with the `rgba` parameter (which previously used to only be `rgb`)
+- Changed `numb.Gaussian` to use `for(;;)` instead of `while(typeof x === "undefined")`
+- Changed the name of `calc.average` to `calc.mean`
+- Fixed `matr.invert` returning `NaN` values when `0` is on the diagonal of a matrix, thanks to [@bhavjitChauhan](https://github.com/bhavjitChauhan).
+
+## [v1.2.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.2.0) - 11/27/2023
+The third release of the Chalkboard library.
+Commits: [`v1.1.0...v1.2.0`](https://github.com/Zushah/Chalkboard/compare/v1.1.0...v1.2.0)
+- Added new matrix commands for the trace of a matrix, the row space of a matrix, the column space, and null space, the exponentation, the row Echelon form (Gaussian elimination), solving systems of linear equations, and conversion of a matrix to an object
+- Added `plot.comp`, `plot.vec2`, `plot.vec3`, and `plot.matr` to replace `comp.display`, `vec2.display`, `vec3.display`, and `matr.display`
+- Added `numb.binomial` to calculate binomial coefficients
+- Removed `vec2.fromNumber`, `vec3.angcos`, `vec4.angcos`, and `matr.dimension`
+- Removed all of the `.addScl` (scalar addition) commands for vectors
+- Changed all of the `matr` commands to work for matrices of any and all dimensions (previously there was a four-by-four dimension limit)
+- Changed all of the `.mulScl` (scalar multiplication) commands for vectors and matrices to be renamed as `.scl`
+- Changed `numb.random` to have both of its parameters be optional (no parameters inputted returns a random number between 0 and 1)
+- Changed `numb.Gaussian` to use `while(typeof x === "undefined")` instead of `while(true)`
+- Fixed the `vec2.magset` and `vec3.magset` commands which would return vectors in the wrong dimensions
+
+## [v1.1.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.1.0) - 11/13/2023
+The second release of the Chalkboard library.
+Commits: [`v1.0.0...v1.1.0`](https://github.com/Zushah/Chalkboard/compare/v1.0.0...v1.1.0)
+- Added `numb.prime` to calculate the nth prime number, `numb.nextPrime` to calculate the next prime number, and `numb.primeGap` to calculate the prime gap with an interval
+- Added `numb.factors` to calculate the prime factorization of a number and `numb.divisors` to calculate the divisors of a number
+- Added `numb.Gaussian` to calculate a random number based on a Gaussian distribution
+- Added `.convolution`, `.correlation`, and `.autocorrelation` commands in the `stat`, `calc`, and `plot` categories to calculate and plot the discrete and continuous convolutions, cross-correlations, and autocorrelations of arrays and functions, respectively
+- Added `stat.error` to calculate the standard error of an array
+- Added `matr.cofactor` and `matr.adjugate` to calculate the cofactor and adjugate matrices of a matrix
+- Removed `calc.rOdO` because polar differentation can now be done with `calc.fxdx` instead
+- Changed `calc.fxdx` to work using Simpson's rule instead of the trapezoidal Riemann sum
+- Changed `real.val`, `calc.dfdx`, and `calc.fxdx` to work for all Chalkboard functions regardless of their `type` (before they only worked for `"expl"` functions)
+- Changed `matr.det` and `matr.transpose` to work for all matrices regardless of their dimension
+- Changed `numb.Fibonacci` to have a cache so it works faster
+- Changed the order of the lower and upper values in the `stat.confidenceInterval` return array
+- Changed `plot.function` and `numb.factorial` to be more written slightly more efficiently
+- Changed the name of the `position` parameter in `stat.Gaussian` to `mean`
+- Changed the name of `numb.prime` (the command that checks if a number is prime) to `numb.isPrime`, so parts of `numb.primeArr` and `prime.compositeArr` had to be changed, too
+
+## [v1.0.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.0.0) - 11/06/2023
+The first release of the Chalkboard library.
+Commits: [`v1.0.0...main`](https://github.com/Zushah/Chalkboard/compare/v1.0.0...main)

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Zushah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,134 @@
+<p align="center"><a href="https://www.github.com/Zushah/Chalkboard"><img src="./assets/Chalkboard-logo.png" width="50%"></a></p>
+<p align="center">
+    <a href="https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0"><img src="https://img.shields.io/github/v/release/Zushah/Chalkboard" alt="Latest release"></a>
+    <a href="https://www.codefactor.io/repository/github/zushah/chalkboard"><img src="https://www.codefactor.io/repository/github/zushah/chalkboard/badge" alt="CodeFactor grade"></a>
+    <a href="https://www.npmjs.com/package/@zushah/chalkboard"><img src="https://img.shields.io/badge/node-v20.10.0-limegreen" alt="Node.js support"></a>
+    <a href="https://github.com/Zushah/Chalkboard/blob/main/LICENSE.md"><img src="https://img.shields.io/badge/license-MIT-yellow" alt="MIT License"></a>
+    <a href="https://www.jsdelivr.com/package/gh/Zushah/Chalkboard"><img src="https://data.jsdelivr.com/v1/package/gh/Zushah/Chalkboard/badge" alt="JSDelivr requests"></a> 
+    <br>
+    <a href="https://zushah.github.io/Chalkboard/home.html">https://zushah.github.io/Chalkboard/home.html</a>
+</p>
+
+# Contents
+<ol>
+    <li><a href="#about">About</a></li>
+    <li><a href="#installation">Installation</a></li>
+    <li><a href="#documentation">Documentation</a></li>
+    <li><a href="#getting-started">Getting Started</a></li>
+    <li><a href="#contributing">Contributing</a></li>
+    <li><a href="#acknowledgments">Acknowledgments</a></li>
+    <li><a href="#contact">Contact</a></li>
+</ol>
+
+# About
+The Chalkboard library is a JavaScript namespace that provides a plethora of both practical and abstract mathematical functionalities for its user. It was developed by [Zushah](https://www.github.com/Zushah) during 2022 and 2023 and then [released](https://github.com/Zushah/Chalkboard/releases/tag/v1.0.0) on November 6, 2023. As per the latest release of [v1.5.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0), Chalkboard has 431 different commands. The library is available for regular JavaScript on both the client-side and the server-side as well as [Proccesing.js](https://www.processing.org/) (fully compatible with [Khan Academy](https://www.khanacademy.org/cs/chalkboard/6708642430369792)). Chalkboard's website can be visited [here](https://zushah.github.io/Chalkboard/home.html).
+
+# Installation
+If your JavaScript project is being run on the client-side within a webpage, you can install Chalkboard with this HTML tag:
+```html
+<script type="text/javascript" src="https://cdn.jsdelivr.net/gh/Zushah/Chalkboard@1.5.0/src/Chalkboard.min.js"></script>
+```
+If your JavaScript project is being run on the server-side within the [Node.js](https://nodejs.org/en) environment, you can install Chalkboard with this console command:
+```bash
+npm install @zushah/chalkboard@1.5.0
+```
+Alternatively, you can simply download the [latest release](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0) and put the relevant files in your project's directory.
+
+More methods and details about installing Chalkboard can be read [here](https://zushah.github.io/Chalkboard/installation.html).
+
+# Documentation
+These are all thirteen Chalkboard categories with a brief description of what they're mostly about, and listed in the order they appear in the source code:
+- `numb` - Number-theory-related operations
+- `real` - Real number and real function operations
+- `comp` - Complex number and complex function operations
+- `quat` - Quaternion operations
+- `plot` - Plotting functions, complex numbers, vectors, matrices, and statistical graphs
+- `geom` - Geometric formulae operations
+- `trig` - Trigonometric function operations
+- `stat` - Statistical array operations
+- `vec2` - Two-dimensional vector operations
+- `vec3` - Three-dimensional vector operations
+- `vec4` - Four-dimensional vector operations
+- `matr` - Multidimensional matrix operations
+- `calc` - Several-variable calculus operations
+
+There are also four "global" commands in Chalkboard, which are:
+- `README()` - Prints basic information about Chalkboard in the console
+- `LOGO()` - Draws the Chalkboard logo
+- `PI()` - Computes the number pi
+- `E()` - Computes the number e
+
+The comprehensive Chalkboard documentation can be visited [here](https://zushah.github.io/Chalkboard/documentation.html).
+
+# Getting Started
+After installing Chalkboard into your program, you can immediately get started with using it. Every Chalkboard command begins with typing "Chalkboard" followed by a period, then the name of the category of the command (all categories are listed above in the [documentation](#documentation) section) with another period, and lastly the desired command itself.
+```js
+Chalkboard.category.command(parameters);
+```
+Here is some code that shows off only a few features of Chalkboard:
+```js
+const cb = Chalkboard; // Chalkboard is a nice name but it's also long
+/*
+Note that this code is written on the client-side
+You can write all the same code on the server-side, too, but you would have to replace the line above with:
+const cb = require("@zushah/chalkboard@1.5.0");
+*/
+
+let f = cb.real.function("Math.cos(2 * x)"); // f(x) = cos(2x)
+let dfdx = cb.calc.dfdx(f, 2); // Derivative of f at x = 0
+let fxdx = cb.calc.fxdx(f, 0, 2); // Antiderivative of f from x = 0 to x = 2
+let fourier = cb.calc.Fourier(f, 2); // Fourier transform of f at x = 2
+
+let f = cb.vec3.field("x", "y", "z"); // f(x, y, z) = (x, y, z)
+let r = cb.real.function(["Math.cos(s) * Math.cos(t)", "Math.sin(s) * Math.cos(t)", "Math.sin(t)"], "surf"); // r(s, t) = (cos(s)cos(t), sin(s)cos(t), sin(t))
+let fnds = cb.calc.fnds(f, r, cb.PI(-1/2), cb.PI(1/2), 0, cb.PI(2)); // Flux of the radial vector field through the unit sphere
+
+let primes = cb.numb.primeArr(0, 100); // Array of prime numbers between 0 and 100
+let midPrime = cb.stat.median(primes); // Median number in the primes array
+cb.plot.barplot(primes, cb.stat.array(0, 100, 11), 5, [[0, 0, 0], [0, 0, 255]]); // Barplot of the primes array with a bin size of 10, a scale of 2, a stroke color of black, and a fill color of blue
+
+let z = cb.comp.new(1, 1); // z = 1 + i
+let zsqsqrt = cb.comp.sqrt(cb.comp.sq(z)); // The square root of z squared equals z
+let f = cb.comp.function("a*a - b*b + 1", "2*a*b"); // f(z) = z^2 + 1 for z = a + bi (a complex-valued function)
+cb.plot.function(f); // Plots the domain coloring of f
+
+let r = cb.real.function(["Math.cos(t)", "Math.sin(t)"], "curv"); // r(t) = (cos(t), sin(t))
+cb.plot.xyplane(2); // Draws the Cartesian coordinate plane
+cb.plot.function(r, 2, [255, 0, 0] [0, cb.PI(1/2)]); // Plots r(t) colored red from t = 0 to t = π/2
+
+let a = cb.vec3.new(1, 2, 3); // Vector a = (1, 2, 3)
+let b = cb.vec3.new(4, 5, 6); // Vector b = (4, 5, 6)
+let c = cb.vec3.new(7, 8, 9); // Vector c = (7, 8, 9)
+let axbxc = cb.vec3.vectorTriple(a, b, c); // Triple cross product between a, b, and c
+cb.vec3.print(axbxc); // Prints axbxc in the console
+
+let m = cb.matr.new([0, 1, 1, 1, 1],  // m is a 5x5 matrix
+                    [1, 0, 1, 1, 1],
+                    [1, 1, 0, 1, 1],
+                    [1, 1, 1, 0, 1],
+                    [1, 1, 1, 1, 0]);
+let mi = cb.matr.invert(m); // mi is the inverse of m
+let mmi = cb.matr.mul(m, mi); // mmi is the product of m and mi
+cb.matr.print(mmi); // Prints mmi in the console
+```
+More examples that are more interesting can be seen [here](https://zushah.github.io/Chalkboard/examples.html) with their source code [here](https://github.com/Zushah/Chalkboard/tree/main/examples).
+
+# Contributing
+<ol>
+    <li>Fork Chalkboard's GitHub repository. Make sure the fork is based on the main branch.</li>
+    <li>Make your contributions to your fork. If you're adding new features or modifying the functionalities of old ones, please make sure you do the same for both editions (JavaScript and Processing.js) of the library.</li>
+    <li>When you're done, commit the changes to your fork with a detailed description.</li>
+    <li>Open a pull request. It will be reviewed soon and then merged to the main branch.</li>
+</ol>
+
+The changelog can be read [here](https://github.com/Zushah/Chalkboard/blob/main/CHANGELOG.md).
+
+The Chalkboard library is available under the [MIT License](https://github.com/Zushah/Chalkboard/blob/main/LICENSE.md).
+
+# Acknowledgements
+Thanks to [Bhavjit Chauhan](https://github.com/bhavjitChauhan) for his [contribution](https://www.github.com/Zushah/Chalkboard/pull/1) to [v1.3.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.3.0).\
+Thanks to [G. Yang](https://www.github.com/gyang0) for his [contribution](https://www.github.com/Zushah/zushah.github.io/pull/1) to the [documentation](https://www.github.com/Zushah/zushah.github.io/tree/main/Chalkboard).
+
+# Contact
+[GitHub](https://www.github.com/Zushah)\
+[Khan Academy](https://www.khanacademy.org/profile/zushah77)

package/docs/README.md

@@ -0,0 +1,2 @@
+# Chalkboard documentation
+The documentation for [Chalkboard v1.5.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0) can be visited [here](https://zushah.github.io/Chalkboard/documentation.html/). Its source code is located [here](https://github.com/Zushah/zushah.github.io/blob/main/Chalkboard/documentation.html).

package/examples/README.md

@@ -0,0 +1,12 @@
+# Chalkboard examples
+Six basic programs made by Zushah that utilize [Chalkboard v1.5.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0) are located in this directory.
+
+They can be viewed in action here:
+- [fluid.js](https://zushah.github.io/Chalkboard/examples/fluid.html)
+- [hyperbolics.js](https://zushah.github.io/Chalkboard/examples/hyperbolics.html)
+- [mandelbrot.js](https://zushah.github.io/Chalkboard/examples/mandelbrot.html)
+- [matr-donut.js](https://zushah.github.io/Chalkboard/examples/matr-donut.html)
+- [newton.js](https://zushah.github.io/Chalkboard/examples/newton.html)
+- [quat-donut.js](https://zushah.github.io/Chalkboard/examples/quat-donut.html)
+
+The main webpage for the examples can be visited at the [Chalkboard website](https://zushah.github.io/Chalkboard/examples.html).

package/examples/fluid.js

@@ -0,0 +1,80 @@
+/*
+    The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
+    Version 1.5.0 Example Program: Fluid Flow
+    Authored by Zushah ===> https://www.github.com/Zushah
+*/
+
+// Get the JavaScript Canvas API
+var ctx = document.getElementById("canvas").getContext("2d");
+canvas.width = window.innerWidth;
+canvas.height = window.innerHeight;
+
+var cb = Chalkboard; // Initialize Chalkboard as cb
+
+// Vector field defined as F(x, y) = (-y, -x/(1 + x^2)^2), adapted from "Learning about Hamiltonian Monte Carlo" which can be found here: https://github.com/anvaka/fieldplay/blob/main/Awesome%20Fields.md
+var F = cb.vec2.field("y", "-x / ((1 + x * x) * (1 + x * x))");
+
+// Basic particle system to simulate the fluid flow
+class Particle {
+    constructor() {
+        this.pos = cb.vec2.new(cb.numb.random(-canvas.width / 2, canvas.width / 2), cb.numb.random(-canvas.height / 2, canvas.height / 2)); // Position vector
+        this.vel = cb.vec2.new(0); // Velocity vector
+        this.ppos = this.pos; // Previous position vector
+    }
+    update() {
+        // Update the particle's position and velocity
+        this.vel = cb.vec2.magset(cb.vec2.fromField(F, cb.vec2.scl(this.pos, 1/100)), 5); // Velocity direction depends on the (scaled) vector field, velocity magnitude is set to always be 5
+        this.pos = cb.vec2.add(this.pos, this.vel); // Velocity is added to the position
+    }
+    constrain() {
+        // Constrain the particle position within the canvas
+        // The canvas coordinates are within -width/-height and width/height so that the Cartestian point (0, 0) is in the center of the canvas
+        if(this.pos.x > canvas.width / 2) {
+            this.pos.x = -canvas.width / 2;
+            this.ppos = this.pos;
+        }
+        if(this.pos.x < -canvas.width / 2) {
+            this.pos.x = canvas.width / 2;
+            this.ppos = this.pos;
+        }
+        if(this.pos.y > canvas.height / 2) {
+            this.pos.y = -canvas.height / 2;
+            this.ppos = this.pos;
+        }
+        if(this.pos.y < -canvas.height / 2) {
+            this.pos.y = canvas.height / 2;
+            this.ppos = this.pos;
+        }
+    }
+    draw() {
+        // Draw the particle
+        ctx.strokeStyle = "rgba(0, 0, 255, 0.1)";
+        ctx.lineWidth = 1;
+        ctx.save();
+        ctx.translate(canvas.width / 2, canvas.height / 2);
+        ctx.beginPath();
+        ctx.moveTo(this.pos.x, this.pos.y);
+        ctx.lineTo(this.ppos.x, this.ppos.y);
+        ctx.stroke();
+        ctx.restore();
+        this.ppos = this.pos;
+        this.update();
+        this.constrain();
+    }
+}
+// Create 500 particles in the particles array
+var particles = [];
+for(var i = 0; i < 500; i++) {
+    particles.push(new Particle());
+}
+
+// Draw everything
+ctx.fillStyle = "rgb(0, 0, 0)";
+ctx.fillRect(0, 0, canvas.width, canvas.height);
+function main() {
+    for(var i = 0; i < particles.length; i++) {
+        particles[i].draw();
+    }
+    window.requestAnimationFrame(main);
+}
+window.requestAnimationFrame(main);

package/examples/hyperbolics.js

@@ -0,0 +1,90 @@
+/*
+    The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
+    Version 1.5.0 Example Program: Hyperbolic Functions
+    Authored by Zushah ===> https://www.github.com/Zushah
+*/
+
+// Get the JavaScript Canvas API
+var ctx = document.getElementById("canvas").getContext("2d");
+canvas.width = window.innerWidth;
+canvas.height = window.innerHeight;
+
+var cb = Chalkboard; // Initialize Chalkboard as cb
+
+var theta = 0;
+function main() {
+    ctx.fillStyle = "rgb(255, 255, 255)";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    cb.plot.xyplane(1, [0, 0, 0], [canvas.width / 2, canvas.height / 2], 2);
+
+    // Plot the unit hyperbola with a parametric function (see: https://en.wikipedia.org/wiki/Hyperbola)
+    var f = cb.real.function(["(t * t + 1) / (2 * t)", "(t * t - 1) / (2 * t)"], "curv");
+    cb.plot.function(f, 1, [100, 100, 255], [0, 10], [canvas.width / 2, canvas.height / 2], 4);
+    cb.plot.function(f, 1, [100, 100, 255], [-10, 0], [canvas.width / 2, canvas.height / 2], 4);
+
+    // The two main hyperbolic trigonometric functions, hyperbolic sine (sinh) and hyperbolic cosine (cosh)
+    var x = cb.trig.cosh(theta);
+    var y = cb.trig.sinh(theta);
+
+    // Show the values of all of the hyperbolic trigonometric functions as theta varies
+    ctx.strokeStyle = "rgb(255, 100, 100)";
+    ctx.lineWidth = 4;
+    ctx.save();
+    ctx.translate(canvas.width / 2, canvas.height / 2);
+    ctx.beginPath();
+    ctx.moveTo(x * 100, 0);
+    ctx.lineTo(x * 100, -y * 100);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(0, -y * 100);
+    ctx.lineTo(x * 100, -y * 100);
+    ctx.stroke();
+    ctx.fillStyle = "rgb(0, 0, 0)";
+    ctx.beginPath();
+    ctx.ellipse(x * 100, -y * 100, 5, 5, 0, 0, cb.PI(2));
+    ctx.fill();
+    ctx.restore();
+    ctx.fillStyle = "rgb(0, 0, 0)";
+    ctx.font = "50px Times New Roman";
+    ctx.fillText("x² - y² = 1", 20, 70);
+    ctx.fillText("θ = " + theta.toFixed(2), 20, 120);
+    ctx.fillText("sinh(θ) = " + cb.trig.sinh(theta).toFixed(2), 20, 170);
+    ctx.fillText("cosh(θ) = " + cb.trig.cosh(theta).toFixed(2), 20, 220);
+    ctx.fillText("tanh(θ) = " + cb.trig.tanh(theta).toFixed(2), 20, 270);
+    ctx.fillText("csch(θ) = " + cb.trig.csch(theta).toFixed(2), 20, 320);
+    ctx.fillText("sech(θ) = " + cb.trig.sech(theta).toFixed(2), 20, 370);
+    ctx.fillText("coth(θ) = " + cb.trig.coth(theta).toFixed(2), 20, 420);
+    ctx.fillText("arcsinh(θ) = " + cb.trig.arcsinh(theta).toFixed(2), 20, 470);
+    if(cb.trig.arccosh(theta) !== undefined) {
+        ctx.fillText("arccosh(θ) = " + cb.trig.arccosh(theta).toFixed(2), 20, 520);
+    } else {
+        ctx.fillText("arccosh(θ) = undefined", 20, 520);
+    }
+    if(cb.trig.arctanh(theta) !== undefined) {
+        ctx.fillText("arctanh(θ) = " + cb.trig.arctanh(theta).toFixed(2), 20, 570);
+    } else {
+        ctx.fillText("arctanh(θ) = undefined", 20, 570);
+    }
+    if(cb.trig.arccsch(theta) !== undefined) {
+        ctx.fillText("arccsch(θ) = " + cb.trig.arccsch(theta).toFixed(2), 20, 620);
+    } else {
+        ctx.fillText("arccsch(θ) = undefined", 20, 620);
+    }
+    if(cb.trig.arcsech(theta) !== undefined) {
+        ctx.fillText("arcsech(θ) = " + cb.trig.arcsech(theta).toFixed(2), 20, 670);
+    } else {
+        ctx.fillText("arcsech(θ) = undefined", 20, 670);
+    }
+    if(cb.trig.arccoth(theta) !== undefined) {
+        ctx.fillText("arccoth(θ) = " + cb.trig.arccoth(theta).toFixed(2), 20, 720);
+    } else {
+        ctx.fillText("arccoth(θ) = undefined", 20, 720);
+    }
+    
+    theta += 0.05;
+    if(theta > 2.5) {
+        theta = -2.5;
+    }
+    window.requestAnimationFrame(main);
+}
+window.requestAnimationFrame(main);

package/examples/mandelbrot.js

@@ -0,0 +1,54 @@
+/*
+    The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
+    Version 1.5.0 Example Program: Mandelbrot Set
+    Authored by Zushah ===> https://www.github.com/Zushah
+*/
+
+// Get the JavaScript Canvas API
+var ctx = document.getElementById("canvas").getContext("2d");
+canvas.width = window.innerWidth;
+canvas.height = window.innerHeight;
+var ratio = canvas.width / canvas.height;
+
+var cb = Chalkboard; // Initialize Chalkboard as cb
+
+// The Mandelbrot set will be rendered using an ImageData object from the Canvas API
+var imageData = ctx.createImageData(canvas.width, canvas.height);
+var pixels = imageData.data;
+function main() {
+    for(var x = 0; x < canvas.width; x++) {
+        for(var y = 0; y < canvas.height; y++) {
+            // The complex numbers from the Mandelbrot set's definition (see: lines 33-34), z and c
+            var z = cb.comp.new(cb.numb.map(x, [0, canvas.width], [-2 * ratio, 2 * ratio]), cb.numb.map(y, [0, canvas.height], [-2, 2]));
+            var c = cb.comp.new(cb.numb.map(x, [0, canvas.width], [-2 * ratio, 2 * ratio]), cb.numb.map(y, [0, canvas.height], [-2, 2]));
+            
+            var currIteration = 0;    // The current iteration of the fractal
+            var maxIterations = 100;  // The maximum iterations intended to be evaluated
+            
+            while(currIteration < maxIterations) {
+                // The definition of the Mandelbrot set: f(z) = z^2 + c (see: https://en.wikipedia.org/wiki/Mandelbrot_set)
+                z = cb.comp.add(cb.comp.sq(z), c);
+
+                // Of course we can't keep iterating infinitely, so we'll just round infinity down to 2
+                if(cb.comp.mag(z) > 2) {
+                    break;
+                }
+                currIteration++; // Keep iterating
+            }
+
+            // The fractal will be colored based on how many iterations it's gone through at a point
+            var color = cb.numb.map(cb.real.sqrt(cb.numb.map(currIteration, [0, maxIterations], [0, 1])), [0, 1], [0, 255]);
+            if(currIteration === maxIterations) {
+                color = 0;
+            }
+            var px = (x + y * canvas.width) * 4;
+            pixels[px + 0] = color;
+            pixels[px + 1] = color;
+            pixels[px + 2] = color;
+            pixels[px + 3] = 255;
+        }
+    }
+
+    ctx.putImageData(imageData, 0, 0);
+}
+main();

package/examples/matr-donut.js

@@ -0,0 +1,51 @@
+/*
+    The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
+    Version 1.5.0 Example Program: Matrix Donut
+    Authored by Zushah ===> https://www.github.com/Zushah
+*/
+
+// Get the JavaScript Canvas API
+var ctx = document.getElementById("canvas").getContext("2d");
+canvas.width = window.innerWidth;
+canvas.height = window.innerHeight;
+
+var cb = Chalkboard; // Initialize Chalkboard as cb
+
+// Generate the donut's points with a parametric function (see: https://en.wikipedia.org/wiki/Torus)
+var points = [];
+for(var u = 0; u < cb.PI(2); u += cb.PI(1/16)) {
+    for(var v = 0; v < cb.PI(2); v += cb.PI(1/6)) {
+        var x = (75 + 30 * cb.trig.cos(v)) * cb.trig.cos(u);
+        var y = (75 + 30 * cb.trig.cos(v)) * cb.trig.sin(u);
+        var z = 30 * cb.trig.sin(v);
+        points.push(cb.vec3.new(x, y, z));
+    }
+}
+function main() {
+    ctx.fillStyle = "rgb(255, 255, 255)";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+
+    ctx.save();
+    ctx.translate(canvas.width / 2, canvas.height / 2);
+    ctx.strokeStyle = "rgb(0, 0, 0)";
+    for(var i = 0; i < points.length; i++) {
+        for(var j = 0; j < points.length; j++) {
+            if(cb.vec3.dist(points[i], points[j]) < 25) {
+                // Draw lines between the donut's points to draw the donut
+                cb.geom.line3D(points[i].x, points[i].y, points[i].z, points[j].x, points[j].y, points[j].z);
+            }
+        }
+    }
+    ctx.restore();
+
+    // Make the donut rotate with a rotation matrix
+    var r = cb.matr.rotator(cb.trig.toRad(1), cb.trig.toRad(1), cb.trig.toRad(1));
+    for(var i = 0; i < points.length; i++) {
+        var buffer = cb.vec3.toMatrix(points[i]);      // Create a buffer matrix which has the donut's points
+        var rbuffer = cb.matr.mul(r, buffer);          // Multiply the rotation matrix with the buffer matrix
+        points[i] = cb.matr.toVector(rbuffer, "vec3"); // Reassign the values of the donut's points to the new rotated points
+    }
+
+    window.requestAnimationFrame(main);
+}
+window.requestAnimationFrame(main);

package/examples/newton.js

@@ -0,0 +1,54 @@
+/*
+    The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
+    Version 1.5.0 Example Program: Newton's Method
+    Authored by Zushah ===> https://www.github.com/Zushah
+*/
+
+// Get the JavaScript Canvas API
+var ctx = document.getElementById("canvas").getContext("2d");
+canvas.width = window.innerWidth;
+canvas.height = window.innerHeight;
+
+var cb = Chalkboard; // Initialize Chalkboard as cb
+
+// Random fourth-degree polynomial function
+var c1 = cb.numb.random(-3, 3);
+var c2 = cb.numb.random(-3, 3);
+var c3 = cb.numb.random(-3, 3);
+var c4 = cb.numb.random(-3, 3);
+var c5 = cb.numb.random(-3, 3);
+var f = cb.real.function(c1 + " * x * x * x * x + " + c2 + " * x * x * x + " + c3 + " * x * x + " + c4 + " * x + " + c5);
+
+// Newton's method's solution and tangent line (see: https://en.wikipedia.org/wiki/Newton's_method)
+var root = cb.calc.Newton(f, [-5, 5]);
+var y = cb.real.function(cb.calc.dfdx(f, root) + " * (x - " + root + ") + " + cb.real.val(f, root));
+
+function main() {
+    ctx.fillStyle = "rgb(255, 255, 255)";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    cb.plot.xyplane(1, [0, 0, 0], [canvas.width / 2, canvas.height / 2], 2);
+
+    // Draw the polynomial
+    cb.plot.function(f, 1, [100, 100, 255], [-10, 10], [canvas.width / 2, canvas.height / 2], 4);
+    ctx.fillStyle = "rgb(0, 0, 0)";
+    ctx.font = "50px Times New Roman";
+    ctx.fillText("f(x) = " + c1.toFixed(2) + "x⁴ + " + c2.toFixed(2) + "x³ + " + c3.toFixed(2) + "x² + " + c4.toFixed(2) + "x + " + c5.toFixed(2), 20, 70);
+    
+    // Only draw the solution and the tangent line if the solution is correct
+    if(cb.real.val(f, root).toFixed(1) == 0) {
+        ctx.fillText("y = " + cb.calc.dfdx(f, root).toFixed(2) + "x - " + (cb.calc.dfdx(f, root) * root).toFixed(2), 20, 120);
+        ctx.fillText("A possible root is at x = " + root.toFixed(2), 20, 170);
+        cb.plot.function(y, 1, [255, 100, 100], [-10, 10], [canvas.width / 2, canvas.height / 2], 4);
+        ctx.save();
+        ctx.translate(canvas.width / 2, canvas.height / 2);
+        ctx.beginPath();
+        ctx.fillStyle = "rgb(0, 0, 0)";
+        ctx.ellipse(root * 100, 0, 5, 5, 0, 0, cb.PI(2));
+        ctx.fill();
+        ctx.restore();
+    } else {
+        ctx.fillText("y = " + cb.calc.dfdx(f, root).toFixed(2) + "x - " + (cb.calc.dfdx(f, root) * root + cb.real.val(f, root)).toFixed(2), 20, 120);
+        ctx.fillText("A possible root was not found", 20, 170);
+    }
+}
+main();