@zushah/chalkboard 1.6.0 → 2.0.0

package/examples/README.md

@@ -1,5 +1,5 @@
 # Chalkboard examples
-Six basic programs made by Zushah that utilize [Chalkboard v1.6.0](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.6.0) are located in this directory.
+Six basic programs made by Zushah that utilize [Chalkboard v2.0.0 al-Khwarizmi](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.0.0) are located in this directory.
 
 They can be viewed in action here:
 - [fluid.js](https://zushah.github.io/Chalkboard/examples/fluid.html)
@@ -9,4 +9,4 @@ They can be viewed in action here:
 - [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).
+The main webpage for the examples can be visited at the [Chalkboard website](https://zushah.github.io/Chalkboard/examples/index.html).

package/examples/fluid.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
-    Version 1.6.0 Example Program: Fluid Flow
+    Version 2.0.0 al-Khwarizmi Example Program: Fluid Flow
     Authored by Zushah ===> https://www.github.com/Zushah
 */
 
@@ -12,36 +12,36 @@ 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))");
+var F = cb.vect.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.pos = cb.vect.random(-canvas.width / 2, canvas.width / 2, 2); // Position vector
+        this.vel = cb.vect.init(0, 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
+        this.vel = cb.vect.magset(cb.vect.fromField(F, cb.vect.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.vect.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) {
+        if (this.pos.x > canvas.width / 2) {
             this.pos.x = -canvas.width / 2;
             this.ppos = this.pos;
         }
-        if(this.pos.x < -canvas.width / 2) {
+        if (this.pos.x < -canvas.width / 2) {
             this.pos.x = canvas.width / 2;
             this.ppos = this.pos;
         }
-        if(this.pos.y > canvas.height / 2) {
+        if (this.pos.y > canvas.height / 2) {
             this.pos.y = -canvas.height / 2;
             this.ppos = this.pos;
         }
-        if(this.pos.y < -canvas.height / 2) {
+        if (this.pos.y < -canvas.height / 2) {
             this.pos.y = canvas.height / 2;
             this.ppos = this.pos;
         }
@@ -64,15 +64,15 @@ class Particle {
 }
 // Create 500 particles in the particles array
 var particles = [];
-for(var i = 0; i < 500; i++) {
+for (var i = 0; i < 500; i++) {
     particles.push(new Particle());
 }
 
 // Draw everything
-ctx.fillStyle = "rgb(0, 0, 0)";
+ctx.fillStyle = "black";
 ctx.fillRect(0, 0, canvas.width, canvas.height);
 function main() {
-    for(var i = 0; i < particles.length; i++) {
+    for (var i = 0; i < particles.length; i++) {
         particles[i].draw();
     }
     window.requestAnimationFrame(main);

package/examples/hyperbolics.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
-    Version 1.6.0 Example Program: Hyperbolic Functions
+    Version 2.0.0 al-Khwarizmi Example Program: Hyperbolic Functions
     Authored by Zushah ===> https://www.github.com/Zushah
 */
 
@@ -13,14 +13,14 @@ var cb = Chalkboard; // Initialize Chalkboard as cb
 
 var theta = 0;
 function main() {
-    ctx.fillStyle = "rgb(255, 255, 255)";
+    ctx.fillStyle = "white";
     ctx.fillRect(0, 0, canvas.width, canvas.height);
     cb.plot.xyplane({lineWidth: 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, {strokeStyle: "rgb(100, 100, 255)", domain: [0, 10], lineWidth: 4});
-    cb.plot.function(f, {strokeStyle: "rgb(100, 100, 255)", domain: [-10, 0], lineWidth: 4});
+    var f = cb.real.define(["(t * t + 1) / (2 * t)", "(t * t - 1) / (2 * t)"], "curv");
+    cb.plot.definition(f, {strokeStyle: "rgb(100, 100, 255)", domain: [0, 10], lineWidth: 4});
+    cb.plot.definition(f, {strokeStyle: "rgb(100, 100, 255)", domain: [-10, 0], lineWidth: 4});
 
     // The two main hyperbolic trigonometric functions, hyperbolic sine (sinh) and hyperbolic cosine (cosh)
     var x = cb.trig.cosh(theta);
@@ -39,12 +39,12 @@ function main() {
     ctx.moveTo(0, -y * 100);
     ctx.lineTo(x * 100, -y * 100);
     ctx.stroke();
-    ctx.fillStyle = "rgb(0, 0, 0)";
+    ctx.fillStyle = "black";
     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.fillStyle = "black";
     ctx.font = "50px Times New Roman";
     ctx.fillText("x² - y² = 1", 20, 70);
     ctx.fillText("θ = " + theta.toFixed(2), 20, 120);
@@ -55,34 +55,34 @@ function main() {
     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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    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) {
+    if (theta > 2.5) {
         theta = -2.5;
     }
     window.requestAnimationFrame(main);

package/examples/mandelbrot.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
-    Version 1.6.0 Example Program: Mandelbrot Set
+    Version 2.0.0 al-Khwarizmi Example Program: Mandelbrot Set
     Authored by Zushah ===> https://www.github.com/Zushah
 */
 
@@ -16,21 +16,21 @@ var cb = Chalkboard; // Initialize Chalkboard as cb
 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++) {
+    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 z = cb.comp.init(cb.numb.map(x, [0, canvas.width], [-2 * ratio, 2 * ratio]), cb.numb.map(y, [0, canvas.height], [-2, 2]));
+            var c = cb.comp.init(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) {
+            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) {
+                if (cb.comp.magsq(z) > 4) {
                     break;
                 }
                 currIteration++; // Keep iterating
@@ -38,7 +38,7 @@ function main() {
 
             // 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) {
+            if (currIteration === maxIterations) {
                 color = 0;
             }
             var px = (x + y * canvas.width) * 4;

package/examples/matr-donut.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
-    Version 1.6.0 Example Program: Matrix Donut
+    Version 2.0.0 al-Khwarizmi Example Program: Matrix Donut
     Authored by Zushah ===> https://www.github.com/Zushah
 */
 
@@ -11,26 +11,30 @@ 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)
+// Generate the donut's points with parametric equations (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)) {
+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));
+        points.push(cb.vect.init(x, y, z));
     }
 }
+
+// Make the donut rotate with a rotation matrix
+var r = cb.matr.rotator(0.01, 0.01, 0.01);
+
 function main() {
-    ctx.fillStyle = "rgb(255, 255, 255)";
+    ctx.fillStyle = "white";
     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) {
+    ctx.strokeStyle = "black";
+    for (var i = 0; i < points.length; i++) {
+        for (var j = 0; j < points.length; j++) {
+            if (cb.vect.distsq(points[i], points[j]) < 625) {
                 // 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);
             }
@@ -38,12 +42,8 @@ function main() {
     }
     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
+    for (var i = 0; i < points.length; i++) {
+        points[i] = cb.matr.mulVector(r, points[i]); // Multiply the rotation matrix with the points' vectors
     }
 
     window.requestAnimationFrame(main);

package/examples/newton.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
-    Version 1.6.0 Example Program: Newton's Method
+    Version 2.0.0 al-Khwarizmi Example Program: Newton's Method
     Authored by Zushah ===> https://www.github.com/Zushah
 */
 
@@ -12,16 +12,12 @@ 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);
+var c = cb.stat.random(-3, 3, 5);
+var f = cb.real.define(c[0] + " * x * x * x * x + " + c[1] + " * x * x * x + " + c[2] + " * x * x + " + c[3] + " * x + " + c[4]);
 
 // 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));
+var y = cb.real.define(cb.calc.dfdx(f, root) + " * (x - " + root + ") + " + cb.real.val(f, root));
 
 function main() {
     ctx.fillStyle = "rgb(255, 255, 255)";
@@ -29,16 +25,16 @@ function main() {
     cb.plot.xyplane({lineWidth: 2});
 
     // Draw the polynomial
-    cb.plot.function(f, {strokeStyle: "rgb(100, 100, 255)", lineWidth: 4});
+    cb.plot.definition(f, {strokeStyle: "rgb(100, 100, 255)", lineWidth: 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);
+    ctx.fillText("f(x) = " + c[0].toFixed(2) + "x⁴ + " + c[1].toFixed(2) + "x³ + " + c[2].toFixed(2) + "x² + " + c[3].toFixed(2) + "x + " + c[4].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) {
+    // 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, {strokeStyle: "rgb(255, 100, 100)", lineWidth: 4});
+        cb.plot.definition(y, {strokeStyle: "rgb(255, 100, 100)", lineWidth: 4});
         ctx.save();
         ctx.translate(canvas.width / 2, canvas.height / 2);
         ctx.beginPath();

package/examples/quat-donut.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library ===> https://www.github.com/Zushah/Chalkboard
-    Version 1.6.0 Example Program: Quaternion Donut
+    Version 2.0.0 al-Khwarizmi Example Program: Quaternion Donut
     Authored by Zushah ===> https://www.github.com/Zushah
 */
 
@@ -11,35 +11,35 @@ 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)
+// Generate the donut's points with parametric equations (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)) {
+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));
+        points.push(cb.vect.init(x, y, z));
     }
 }
 var theta = 0;
 function main() {
-    ctx.fillStyle = "rgb(0, 0, 0)";
+    ctx.fillStyle = "black";
     ctx.fillRect(0, 0, canvas.width, canvas.height);
 
     // Make the donut rotate with a rotation quaternion
-    var r = cb.quat.fromAxis(cb.vec3.normalize(cb.vec3.new(1, 1, 1)), theta);
+    var r = cb.quat.fromAxis(cb.vect.normalize(cb.vect.init(1, 1, 1)), theta);
     var qoints = [];  // We'll say that "qoints" are the new rotated points
-    for(var i = 0; i < points.length; i++) {
+    for (var i = 0; i < points.length; i++) {
         qoints.push(cb.quat.toRotation(r, points[i]));
     }
     theta += cb.trig.toRad(1);
 
     ctx.save();
     ctx.translate(canvas.width / 2, canvas.height / 2);
-    ctx.strokeStyle = "rgb(255, 255, 255)";
-    for(var i = 0; i < qoints.length; i++) {
-        for(var j = 0; j < qoints.length; j++) {
-            if(cb.vec3.dist(qoints[i], qoints[j]) < 25) {
+    ctx.strokeStyle = "white";
+    for (var i = 0; i < qoints.length; i++) {
+        for (var j = 0; j < qoints.length; j++) {
+            if (cb.vect.distsq(qoints[i], qoints[j]) < 625) {
                 // Draw lines between the donut's qoints to draw the donut
                 cb.geom.line3D(qoints[i].x, qoints[i].y, qoints[i].z, qoints[j].x, qoints[j].y, qoints[j].z);
             }

package/package.json

@@ -1,27 +1,56 @@
 {
   "name": "@zushah/chalkboard",
-  "version": "1.6.0",
+  "version": "2.0.0",
   "description": "The Chalkboard library provides a plethora of mathematical functionalities for its user.",
-  "main": "src/Chalkboard.js",
+  "main": "dist/Chalkboard.js",
+  "files": ["dist", "examples", "CHANGELOG.md", "LICENSE.md", "package.json", "README.md"],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc --project tsconfig.json",
+    "eslint": "eslint src/**",
+    "eslint:fix": "eslint --fix src/**",
+    "prettier": "prettier src",
+    "prettier:fix": "prettier --write src",
+    "docs": "typedoc --options typedoc.json"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Zushah/Chalkboard.git"
   },
   "keywords": [
-    "mathematics",
+    "algebra",
+    "calculus",
+    "complex",
+    "geometry",
     "khan-academy",
-    "processing"
+    "mathematics",
+    "number",
+    "plot",
+    "quaternion",
+    "statistics",
+    "tensor",
+    "trigonometry",
+    "typescript",
+    "matrix",
+    "vector"
   ],
   "author": "Zushah",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/Zushah/Chalkboard/issues"
   },
-  "homepage": "https://zushah.github.io/Chalkboard/home.html",
+  "homepage": "https://zushah.github.io/Chalkboard",
   "publishConfig": {
     "access": "public"
+  },
+  "save-prefix": "",
+  "devDependencies": {
+    "@types/node": "20.10.6",
+    "@typescript-eslint/eslint-plugin": "6.17.0",
+    "@typescript-eslint/parser": "6.17.0",
+    "eslint": "8.56.0",
+    "prettier": "3.1.1",
+    "typedoc": "0.25.6",
+    "typedoc-material-theme": "1.0.2",
+    "typescript": "5.3.3"
   }
 }

package/docs/README.md

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