@zushah/chalkboard 1.5.0 → 1.7.0

package/src/ChalkboardProcessing.js

@@ -1,17 +1,17 @@
 /*
     The Chalkboard Library
-    Version 1.5.0 released 12/18/2023
+    Version 1.7.0 Descartes released 01/01/2024
     Authored by Zushah ===> https://www.github.com/Zushah
     Available under the MIT License ===> https://www.opensource.org/license/mit/
 
     The Chalkboard library is a JavaScript namespace that provides a plethora of both practical and abstract mathematical functionalities for its user.
 
-    Latest release ===> https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0
-    Documentation ===> https://zushah.github.io/Chalkboard/documentation.html/
+    Repository ===> https://www.github.com/Zushah/Chalkboard
+    Website ===> https://zushah.github.io/Chalkboard/home.html
 */
 var Chalkboard = {
     README: function() {
-        console.log("The Chalkboard Library\nVersion 1.5.0 released 12/18/2023\nAuthored by Zushah ===> https://www.github.com/Zushah\nAvailable under the MIT License ===> https://www.opensource.org/license/mit/\n\nThe Chalkboard library is a JavaScript namespace that provides a plethora of both practical and abstract mathematical functionalities for its user.\n\nLatest release ===> https://www.github.com/Zushah/Chalkboard/releases/tag/v1.5.0\nDocumentation ===> https://zushah.github.io/Chalkboard/documentation.html/");
+        console.log("The Chalkboard Library\nVersion 1.7.0 Descartes released 01/01/2024\nAuthored by Zushah ===> https://www.github.com/Zushah\nAvailable under the MIT License ===> https://www.opensource.org/license/mit/\n\nThe Chalkboard library is a JavaScript namespace that provides a plethora of both practical and abstract mathematical functionalities for its user.\n\nRepository ===> https://www.github.com/Zushah/Chalkboard\nWebsite ===> https://zushah.github.io/Chalkboard/home.html");
     },
     LOGO: function(x, y, s) {
         x = x || width / 2;
@@ -45,11 +45,49 @@ var Chalkboard = {
         exponent = exponent || 1;
         return Math.pow(Math.pow(10, 1 / Math.log(10)), exponent);
     },
+    CONTEXT: "ctx",
+    PARSEPREFIX: "",
     numb: {
         random: function(inf, sup) {
-            inf = inf || 0;
-            sup = sup || 0;
-            return inf + Math.random() * (sup - inf);
+            if(inf === undefined) {
+                inf = 0;
+            }
+            if(sup === undefined) {
+                sup = 1;
+            }
+            return inf + (sup - inf) * Math.random();
+        },
+        exponential: function(l) {
+            if(l === undefined) {
+                l = 1;
+            }
+            return l <= 0 ? 0 : -Math.log(Math.random()) / l;
+        },
+        Gaussian: function(height, mean, deviation) {
+            var u1 = Math.random(), u2 = Math.random();
+            var random = Chalkboard.real.sqrt(-2 * Chalkboard.real.ln(u1)) * Chalkboard.trig.cos(Chalkboard.PI(2) * u2);
+            return random * height * Chalkboard.real.sqrt(deviation) + mean;
+        },
+        Bernoullian: function(p) {
+            if(p === undefined) {
+                p = 0.5;
+            }
+            return Math.random() < p ? 1 : 0;
+        },
+        Poissonian: function(l) {
+            if(l === undefined) {
+                l = 1;
+            }
+            if(l > 0) {
+                var L = Chalkboard.E(-l);
+                var p = 1, k = 0;
+                for(; p > L; ++k) {
+                    p *= Math.random();
+                }
+                return k - 1;
+            } else {
+                return 0;
+            }
         },
         factorial: function(num) {
             if(num >= 0) {
@@ -223,11 +261,23 @@ var Chalkboard = {
             }
         },
         binomial: function(n, k) {
+            if(k < 0 || k > n) {
+                return 0;
+            }
             if(k === 0 || k === n) {
                 return 1;
-            } else {
-                return Chalkboard.numb.binomial(n - 1, k - 1) + Chalkboard.numb.binomial(n - 1, k);
             }
+            if(k === 1 || k === n - 1) {
+                return n;
+            }
+            if(n - k < k) {
+                k = n - k;
+            }
+            var result = n;
+            for(var i = 2; i <= k; i++) {
+                result *= (n - i + 1) / i;
+            }
+            return Math.round(result);
         },
         Fibonacci: function(num) {
             var sequence = [0, 1];
@@ -236,18 +286,39 @@ var Chalkboard = {
             }
             return sequence[num];
         },
-        Gaussian: function(height, mean, deviation) {
-            var u, v, s;
-            for(;;) {
-                u = Chalkboard.numb.random(-1, 1);
-                v = Chalkboard.numb.random(-1, 1);
-                s = u * u + v * v;
-                if(s < 1 && s !== 0) {
-                    break;
+        Goldbach: function(num) {
+            if(num % 2 === 0) {
+                if(num !== 4) {
+                    var a = num / 2, b = num / 2;
+                    if(a % 2 === 0) {
+                        a--;
+                        b++;
+                    }
+                    while(a >= 3) {
+                        if(Chalkboard.numb.isPrime(a) && Chalkboard.numb.isPrime(b)) {
+                            return [a, b];
+                        }
+                        a -= 2;
+                        b += 2;
+                    }
+                    return undefined;
+                } else {
+                    return [2, 2];
                 }
+            } else {
+                return undefined;
+            }
+        },
+        Euler: function(num) {
+            if(num > 0) {
+                var factors = Chalkboard.numb.factors(num);
+                for(var i = 0; i < factors.length; i++) {
+                    num *= (factors[i] - 1) / factors[i];
+                }
+                return num;
+            } else {
+                return undefined;
             }
-            var z = u * Chalkboard.real.sqrt(-2 * Chalkboard.real.ln(s) / s);
-            return z * height * deviation + mean;
         }
     },
     real: {
@@ -255,7 +326,9 @@ var Chalkboard = {
             type = type || "expl";
             if(type === "expl") {
                 return {definition: definition, type: type};
-            }  else if(type === "pola") {
+            } else if(type === "inve") {
+                return {definition: definition, type: type};
+            } else if(type === "pola") {
                 return {definition: definition, type: type};
             } else if(type === "curv") {
                 return definition.length === 2 ? {definition: [definition[0], definition[1]], type: type} : {definition: [definition[0], definition[1], definition[2]], type: type};
@@ -264,17 +337,19 @@ var Chalkboard = {
             } else if(type === "mult") {
                 return {definition: definition, type: type};
             } else {
-                return "TypeError: Parameter \"type\" must be either \"expl\", \"pola\", \"curv\", \"surf\", or \"mult\".";
+                return "TypeError: Parameter \"type\" must be either \"expl\", \"inve\", \"pola\", \"curv\", \"surf\", or \"mult\".";
             }
         },
-        parse: function(str, init) {
-            init = init || '';
-            return Function('"use strict"; ' + init + ' return (' + str + ')')();
+        parse: function(str) {
+            return Function('"use strict"; ' + Chalkboard.PARSEPREFIX + ' return (' + str + ')')();
         },
         val: function(func, val) {
             if(func.type === "expl") {
                 var f = Chalkboard.real.parse("x => " + func.definition);
                 return f(val);
+            } else if(func.type === "inve") {
+                var f = Chalkboard.real.parse("y => " + func.definition);
+                return f(val);
             } else if(func.type === "pola") {
                 var r = Chalkboard.real.parse("O => " + func.definition);
                 return r(val);
@@ -310,7 +385,11 @@ var Chalkboard = {
             }
         },
         pow: function(base, num) {
-            return Math.exp(num * Math.log(base));
+            if(base === 0 && num === 0) {
+                return 1;
+            } else {
+                return Math.exp(num * Math.log(base));
+            }
         },
         log: function(base, num) {
             return Chalkboard.real.ln(num) / Chalkboard.real.ln(base);
@@ -328,7 +407,8 @@ var Chalkboard = {
                 return undefined;
             }
         },
-        nrt: function(num, index) {
+        root: function(num, index) {
+            index = index || 3;
             return Math.exp(Math.log(num) / index);
         },
         tetration: function(base, num) {
@@ -443,14 +523,20 @@ var Chalkboard = {
     },
     comp: {
         new: function(a, b) {
-            return {a: a, b: b, type: "comp"};
+            if(b === undefined) {
+                return {a: a, b: 0, type: "comp"};
+            } else {
+                return {a: a, b: b, type: "comp"};
+            }
+        },
+        copy: function(comp) {
+            return Object.create(Object.getPrototypeOf(comp), Object.getOwnPropertyDescriptors(comp));
         },
         function: function(realDefinition, imagDefinition) {
             return {definition: [realDefinition, imagDefinition], type: "comp"};
         },
-        parse: function(str, init) {
-            init = init || '';
-            return Function('"use strict"; ' + init + ' return (' + str + ')')();
+        parse: function(str) {
+            return Function('"use strict"; ' + Chalkboard.PARSEPREFIX + ' return (' + str + ')')();
         },
         val: function(func, comp) {
             if(func.type === "comp") {
@@ -529,6 +615,18 @@ var Chalkboard = {
         sqrt: function(comp) {
             return Chalkboard.comp.new(Chalkboard.real.sqrt((comp.a + Chalkboard.real.sqrt((comp.a * comp.a) + (comp.b * comp.b))) / 2), Chalkboard.numb.sgn(comp.b) * Chalkboard.real.sqrt((-comp.a + Chalkboard.real.sqrt((comp.a * comp.a) + (comp.b * comp.b))) / 2));
         },
+        root: function(comp, index) {
+            index = index || 3;
+            if(Number.isInteger(index) && index > 0) {
+                var result = [];
+                var r = Chalkboard.comp.mag(comp);
+                var t = Chalkboard.comp.arg(comp);
+                for(var i = 0; i < index; i++) {
+                    result.push(Chalkboard.comp.new(Chalkboard.real.root(r, index) * Chalkboard.trig.cos((t + Chalkboard.PI(2 * i)) / index), Chalkboard.real.root(r, index) * Chalkboard.trig.sin((t + Chalkboard.PI(2 * i)) / index)));
+                }
+                return result;
+            }
+        },
         rotate: function(comp, rad) {
             return Chalkboard.comp.new(Chalkboard.comp.mag(comp) * Chalkboard.trig.cos(Chalkboard.comp.arg(comp) + rad), Chalkboard.comp.mag(comp) * Chalkboard.trig.sin(Chalkboard.comp.arg(comp) + rad));
         },
@@ -538,21 +636,22 @@ var Chalkboard = {
         conjugate: function(comp) {
             return Chalkboard.comp.new(comp.a, -comp.b);
         },
-        root: function(comp, n) {
-            if(Number.isInteger(n) && n > 0) {
-                var result = [];
-                var r = Chalkboard.comp.mag(comp);
-                var t = Chalkboard.comp.arg(comp);
-                for(var i = 0; i < n; i++) {
-                    result.push(Chalkboard.comp.new(Chalkboard.real.nrt(r, n) * Chalkboard.trig.cos((t + Chalkboard.PI(2 * i)) / n), Chalkboard.real.nrt(r, n) * Chalkboard.trig.sin((t + Chalkboard.PI(2 * i)) / n)));
-                }
-                return result;
-            }
-        },
         dist: function(comp_1, comp_2) {
+            if(typeof comp_1 === "number") {
+                comp_1 = Chalkboard.comp.new(comp_1, 0);
+            }
+            if(typeof comp_2 === "number") {
+                comp_2 = Chalkboard.comp.new(comp_2, 0);
+            }
             return Chalkboard.real.sqrt(((comp_2.a - comp_1.a) * (comp_2.a - comp_1.a)) + ((comp_2.b - comp_1.b) * (comp_2.b - comp_1.b)));
         },
         distsq: function(comp_1, comp_2) {
+            if(typeof comp_1 === "number") {
+                comp_1 = Chalkboard.comp.new(comp_1, 0);
+            }
+            if(typeof comp_2 === "number") {
+                comp_2 = Chalkboard.comp.new(comp_2, 0);
+            }
             return ((comp_2.a - comp_1.a) * (comp_2.a - comp_1.a)) + ((comp_2.b - comp_1.b) * (comp_2.b - comp_1.b));
         },
         scl: function(comp, num) {
@@ -562,15 +661,39 @@ var Chalkboard = {
             return Chalkboard.comp.new(Chalkboard.numb.constrain(comp.a, range), Chalkboard.numb.constrain(comp.b, range));
         },
         add: function(comp_1, comp_2) {
+            if(typeof comp_1 === "number") {
+                comp_1 = Chalkboard.comp.new(comp_1, 0);
+            }
+            if(typeof comp_2 === "number") {
+                comp_2 = Chalkboard.comp.new(comp_2, 0);
+            }
             return Chalkboard.comp.new(comp_1.a + comp_2.a, comp_1.b + comp_2.b);
         },
         sub: function(comp_1, comp_2) {
+            if(typeof comp_1 === "number") {
+                comp_1 = Chalkboard.comp.new(comp_1, 0);
+            }
+            if(typeof comp_2 === "number") {
+                comp_2 = Chalkboard.comp.new(comp_2, 0);
+            }
             return Chalkboard.comp.new(comp_1.a - comp_2.a, comp_1.b - comp_2.b);
         },
         mul: function(comp_1, comp_2) {
+            if(typeof comp_1 === "number") {
+                comp_1 = Chalkboard.comp.new(comp_1, 0);
+            }
+            if(typeof comp_2 === "number") {
+                comp_2 = Chalkboard.comp.new(comp_2, 0);
+            }
             return Chalkboard.comp.new((comp_1.a * comp_2.a) - (comp_1.b * comp_2.b), (comp_1.a * comp_2.b) + (comp_1.b * comp_2.a));
         },
         div: function(comp_1, comp_2) {
+            if(typeof comp_1 === "number") {
+                comp_1 = Chalkboard.comp.new(comp_1, 0);
+            }
+            if(typeof comp_2 === "number") {
+                comp_2 = Chalkboard.comp.new(comp_2, 0);
+            }
             return Chalkboard.comp.new(((comp_1.a * comp_2.a) - (comp_1.b * comp_2.b)) / Chalkboard.comp.magsq(comp_2), ((comp_1.a * comp_2.b) + (comp_1.b * comp_2.a)) / Chalkboard.comp.magsq(comp_2));
         },
         toVector: function(comp) {
@@ -592,7 +715,14 @@ var Chalkboard = {
     },
     quat: {
         new: function(a, b, c, d) {
-            return {a: a, b: b, c: c, d: d, type: "quat"};
+            if(b === undefined && c === undefined && d === undefined) {
+                return {a: a, b: 0, c: 0, d: 0, type: "quat"};
+            } else {
+                return {a: a, b: b, c: c, d: d, type: "quat"};
+            }
+        },
+        copy: function(quat) {
+            return Object.create(Object.getPrototypeOf(quat), Object.getOwnPropertyDescriptors(quat));
         },
         random: function(inf, sup) {
             return Chalkboard.quat.new(Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup));
@@ -634,9 +764,21 @@ var Chalkboard = {
             return Chalkboard.quat.new(quat.a, -quat.b, -quat.c, -quat.d);
         },
         dist: function(quat_1, quat_2) {
+            if(typeof quat_1 === "number") {
+                quat_1 = Chalkboard.quat.new(quat_1, 0, 0, 0);
+            }
+            if(typeof quat_2 === "number") {
+                quat_2 = Chalkboard.quat.new(quat_2, 0, 0, 0);
+            }
             return Chalkboard.real.sqrt(((quat_2.a - quat_1.a) * (quat_2.a - quat_1.a)) + ((quat_2.b - quat_1.b) * (quat_2.b - quat_1.b)) + ((quat_2.c - quat_1.c) * (quat_2.c - quat_1.c)) + ((quat_2.d - quat_1.d) * (quat_2.d - quat_1.d)));
         },
         distsq: function(quat_1, quat_2) {
+            if(typeof quat_1 === "number") {
+                quat_1 = Chalkboard.quat.new(quat_1, 0, 0, 0);
+            }
+            if(typeof quat_2 === "number") {
+                quat_2 = Chalkboard.quat.new(quat_2, 0, 0, 0);
+            }
             return ((quat_2.a - quat_1.a) * (quat_2.a - quat_1.a)) + ((quat_2.b - quat_1.b) * (quat_2.b - quat_1.b)) + ((quat_2.c - quat_1.c) * (quat_2.c - quat_1.c)) + ((quat_2.d - quat_1.d) * (quat_2.d - quat_1.d));
         },
         scl: function(quat, num) {
@@ -646,14 +788,41 @@ var Chalkboard = {
             return Chalkboard.quat.new(Chalkboard.numb.constrain(quat.a, range), Chalkboard.numb.constrain(quat.b, range), Chalkboard.numb.constrain(quat.c, range), Chalkboard.numb.constrain(quat.d, range));
         },
         add: function(quat_1, quat_2) {
+            if(typeof quat_1 === "number") {
+                quat_1 = Chalkboard.quat.new(quat_1, 0, 0, 0);
+            }
+            if(typeof quat_2 === "number") {
+                quat_2 = Chalkboard.quat.new(quat_2, 0, 0, 0);
+            }
             return Chalkboard.quat.new(quat_1.a + quat_2.a, quat_1.b + quat_2.b, quat_1.c + quat_2.c, quat_1.d + quat_2.d);
         },
         sub: function(quat_1, quat_2) {
+            if(typeof quat_1 === "number") {
+                quat_1 = Chalkboard.quat.new(quat_1, 0, 0, 0);
+            }
+            if(typeof quat_2 === "number") {
+                quat_2 = Chalkboard.quat.new(quat_2, 0, 0, 0);
+            }
             return Chalkboard.quat.new(quat_1.a - quat_2.a, quat_1.b - quat_2.b, quat_1.c - quat_2.c, quat_1.d - quat_2.d);
         },
         mul: function(quat_1, quat_2) {
+            if(typeof quat_1 === "number") {
+                quat_1 = Chalkboard.quat.new(quat_1, 0, 0, 0);
+            }
+            if(typeof quat_2 === "number") {
+                quat_2 = Chalkboard.quat.new(quat_2, 0, 0, 0);
+            }
             return Chalkboard.quat.new((quat_1.a * quat_2.a) - (quat_1.b * quat_2.b) - (quat_1.c * quat_2.c) - (quat_1.d * quat_2.d), (quat_1.a * quat_2.b) + (quat_1.b * quat_2.a) + (quat_1.c * quat_2.d) - (quat_1.d * quat_2.c), (quat_1.a * quat_2.c) - (quat_1.b * quat_2.d) + (quat_1.c * quat_2.a) + (quat_1.d * quat_2.b), (quat_1.a * quat_2.d) + (quat_1.b * quat_2.c) - (quat_1.c * quat_2.b) + (quat_1.d * quat_2.a));
         },
+        div: function(quat_1, quat_2) {
+            if(typeof quat_1 === "number") {
+                quat_1 = Chalkboard.quat.new(quat_1, 0, 0, 0);
+            }
+            if(typeof quat_2 === "number") {
+                quat_2 = Chalkboard.quat.new(quat_2, 0, 0, 0);
+            }
+            return Chalkboard.quat.new((quat_1.a * quat_2.a + quat_1.b * quat_2.b + quat_1.c * quat_2.c + quat_1.d * quat_2.d) / Chalkboard.quat.magsq(quat_2), (quat_1.b * quat_2.a - quat_1.a * quat_2.b - quat_1.d * quat_2.c + quat_1.c * quat_2.d) / Chalkboard.quat.magsq(quat_2), (quat_1.c * quat_2.a + quat_1.d * quat_2.b - quat_1.a * quat_2.c - quat_1.b * quat_2.d) / Chalkboard.quat.magsq(quat_2), (quat_1.d * quat_2.a - quat_1.c * quat_2.b + quat_1.b * quat_2.c - quat_1.a * quat_2.d) / Chalkboard.quat.magsq(quat_2));
+        },
         fromAxis: function(vec3, rad) {
             return Chalkboard.quat.new(Chalkboard.trig.cos(rad / 2), vec3.x * Chalkboard.trig.sin(rad / 2), vec3.y * Chalkboard.trig.sin(rad / 2), vec3.z * Chalkboard.trig.sin(rad / 2));
         },
@@ -698,85 +867,97 @@ var Chalkboard = {
         }
     },
     plot: {
-        xyplane: function(scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
+        xyplane: function(config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2
+            }).size /= 100;
             pushMatrix();
-            translate(origin[0], origin[1]);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
-            strokeWeight(weight / 4);
-            for(var i = Math.floor(-origin[0] / scl); i <= (width - origin[0]) / scl; i++) {
-                line(i / scl, -origin[1], i / scl, width - origin[1]);
-            }
-            for(var i = Math.floor(-origin[1] / scl); i <= (width - origin[1]) / scl; i++) {
-                line(-origin[0], i / scl, width - origin[0], i / scl);
-            }
-            strokeWeight(weight);
-            line(-origin[0], 0, width - origin[0], 0);
-            line(0, -origin[1], 0, width - origin[1]);
+            translate(config.x, config.y);
+            stroke(config.stroke);
+            strokeWeight(config.strokeWeight / 4);
+            for(var i = Math.floor(-config.x / config.size); i <= (width - config.x) / config.size; i++) {
+                line(i / config.size, -config.y, i / config.size, width - config.y);
+            }
+            for(var i = Math.floor(-config.y / config.size); i <= (width - config.y) / config.size; i++) {
+                line(-config.x, i / config.size, width - config.x, i / config.size);
+            }
+            strokeWeight(config.strokeWeight);
+            line(-config.x, 0, width - config.x, 0);
+            line(0, -config.y, 0, width - config.y);
             popMatrix();
         },
-        rOplane: function(scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
+        rOplane: function(config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2
+            }).size /= 100;
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
-            strokeWeight(weight / 4);
-            for(var i = 0; i <= scl * width / 2; i++) {
-                ellipse(0, 0, 2 * i / scl, 2 * i / scl);
-            }
-            strokeWeight(weight);
-            line(-origin[0], 0, width - origin[0], 0);
-            line(0, -origin[1], 0, width - origin[1]);
+            stroke(config.stroke);
+            strokeWeight(config.strokeWeight / 4);
+            for(var i = 0; i <= config.size * width / 2; i++) {
+                ellipse(0, 0, 2 * i / config.size, 2 * i / config.size);
+            }
+            strokeWeight(config.strokeWeight);
+            line(-config.x, 0, width - config.x, 0);
+            line(0, -config.y, 0, width - config.y);
             popMatrix();
         },
-        function: function(func, scl, rgba, domain, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || func.type === "comp" ? [[-10, 10], [-10, 10]] : [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
+        function: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || (func.type === "comp" ? [[-10, 10], [-10, 10]] : [-10, 10])
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
             if(func.type === "expl") {
                 var f = Chalkboard.real.parse("x => " + func.definition);
-                for(var i = domain[0] / scl; i <= domain[1] / scl; i++) {
-                    vertex(i, -f(i * scl) / scl);
+                for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i++) {
+                    vertex(i, -f(i * config.size) / config.size);
                     data.push([i, f(i)]);
                 }
+            } else if(func.type === "inve") {
+                var f = Chalkboard.real.parse("y => " + func.definition);
+                for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i++) {
+                    vertex(f(i * config.size) / config.size, -i);
+                    data.push([f(i), i]);
+                }
             } else if(func.type === "pola") {
                 var r = Chalkboard.real.parse("O => " + func.definition);
-                for(var i = domain[0] / scl; i < domain[1] / scl; i++) {
-                    vertex(r(i * scl) / scl * Chalkboard.trig.cos(i * scl), -r(i * scl) / scl * Chalkboard.trig.sin(i * scl));
+                for(var i = config.domain[0] / config.size; i < config.domain[1] / config.size; i++) {
+                    vertex(r(i * config.size) / config.size * Chalkboard.trig.cos(i * config.size), -r(i * config.size) / config.size * Chalkboard.trig.sin(i * config.size));
                     data.push([i, r(i)]);
                 }
             } else if(func.type === "curv") {
                 var x = Chalkboard.real.parse("t => " + func.definition[0]),
                     y = Chalkboard.real.parse("t => " + func.definition[1]);
-                for(var i = domain[0] / scl; i < domain[1] / scl; i++) {
-                    vertex(x(i * scl) / scl, -y(i * scl) / scl);
+                for(var i = config.domain[0] / config.size; i < config.domain[1] / config.size; i++) {
+                    vertex(x(i * config.size) / config.size, -y(i * config.size) / config.size);
                     data.push([x(i), y(i)]);
                 }
             } else if(func.type === "comp") {
                 var u = Chalkboard.comp.parse("(a, b) => " + func.definition[0]),
                     v = Chalkboard.comp.parse("(a, b) => " + func.definition[1]);
-                for(var i = domain[0][0] / scl; i <= domain[0][1] / scl; i += 5) {
-                    for(var j = domain[1][0] / scl; j <= domain[1][1] / scl; j += 5) {
-                        var z = Chalkboard.comp.new(u(i * scl, j * scl) / scl, v(i * scl, j * scl) / scl);
+                for(var i = config.domain[0][0] / config.size; i <= config.domain[0][1] / config.size; i += 5) {
+                    for(var j = config.domain[1][0] / config.size; j <= config.domain[1][1] / config.size; j += 5) {
+                        var z = Chalkboard.comp.new(u(i * config.size, j * config.size) / config.size, v(i * config.size, j * config.size) / config.size);
                         noStroke();
                         if(z.a === 0 && z.b === 0) {
                             fill(0, 0, 0);
@@ -792,23 +973,26 @@ var Chalkboard = {
                     }
                 }
             } else {
-                return "TypeError: Property \"type\" of parameter \"func\" must be either \"expl\", \"pola\", \"curv\", or \"comp\".";
+                return "TypeError: Property \"type\" of parameter \"func\" must be either \"expl\", \"inve\", \"pola\", \"curv\", or \"comp\".";
             }
             endShape();
             popMatrix();
             return data;
         },
-        barplot: function(arr, bins, scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [[0, 0, 0], [255, 255, 255]];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
+        barplot: function(arr, bins, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                fill: config.fill || color(255),
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2
+            }).size /= 100;
             pushMatrix();
-            translate(origin[0], origin[1]);
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0][0], rgba[0][1], rgba[0][2]) : color(rgba[0][0], rgba[0][1], rgba[0][2], rgba[0][3]));
-            fill(rgba.length === 3 ? color(rgba[1][0], rgba[1][1], rgba[1][2]) : color(rgba[1][0], rgba[1][1], rgba[1][2], rgba[1][3]));
+            translate(config.x, config.y);
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
+            fill(config.fill);
             var bars = [];
             for(var i = 0; i < bins.length; i++) {
                 if(i === 0) {
@@ -823,25 +1007,27 @@ var Chalkboard = {
             for(var i = 0; i < bars.length; i++) {
                 counts.push(bars[i].length);
             }
-            var x = 0, width = counts.length / (2 * scl);
+            var x = 0, width = counts.length / (2 * config.size);
             for(var i = 0; i < counts.length; i++) {
-                rect(x - width, 0, 1 / scl, -counts[i] / scl);
-                x += 1 / scl;
+                rect(x - width, 0, 1 / config.size, -counts[i] / config.size);
+                x += 1 / config.size;
             }
             popMatrix();
             return bars;
         },
-        lineplot: function(arr, bins, scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
+        lineplot: function(arr, bins, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2
+            }).size /= 100;
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             var verts = [];
             for(var i = 0; i < bins.length; i++) {
                 if(i === 0) {
@@ -858,77 +1044,85 @@ var Chalkboard = {
             }
             beginShape();
             for(var i = 0; i < counts.length; i++) {
-                vertex(i / scl, -counts[i] / scl);
+                vertex(i / config.size, -counts[i] / config.size);
             }
             endShape();
             popMatrix();
             return verts;
         },
-        scatterplot: function(arr1, arr2, scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 5;
+        scatterplot: function(arr1, arr2, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 5
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
-            strokeWeight(weight * 5);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            translate(config.x, config.y);
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             if(arr1.length === arr2.length) {
                 for(var i = 0; i < arr1.length; i++) {
-                    point(arr1[i] / scl - arr1.length / (2 * scl), -arr2[i] / scl + arr1.length / (2 * scl));
+                    point(arr1[i] / config.size - arr1.length / (2 * config.size), -arr2[i] / config.size + arr1.length / (2 * config.size));
                     data.push([arr1[i], arr2[i]]);
                 }
             }
             popMatrix();
             return data;
         },
-        comp: function(comp, scl, origin, weight, rgba) {
-            scl = scl || 1;
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 5;
-            rgba = rgba || [0, 0, 0];
-            scl /= 100;
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
-            strokeWeight(weight * 5);
+        comp: function(comp, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 5
+            }).size /= 100;
+            stroke(config.stroke);
+            strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(origin[0], origin[1]);
-            point(comp.a / scl, -comp.b / scl);
+            translate(config.x, config.y);
+            point(comp.a / config.size, -comp.b / config.size);
             popMatrix();
             noStroke();
             noFill();
             return [[comp.a], [comp.b]];
         },
-        vec2: function(vec2, scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 5;
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
-            strokeWeight(weight);
+        vec2: function(vec2, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 5
+            }).size /= 100;
+            stroke(config.stroke);
+            strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(origin[0], origin[1]);
-            line(0, 0, vec2.x / scl, -vec2.y / scl);
+            translate(config.x, config.y);
+            line(0, 0, vec2.x / config.size, -vec2.y / config.size);
             popMatrix();
             return [[vec2.x], [vec2.y]];
         },
-        field: function(vec2field, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [[-10, 10], [-10, 10]];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 5;
-            res = res || 25;
+        field: function(vec2field, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 5,
+                domain: config.domain || [[-10, 10], [-10, 10]],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
-            strokeWeight(weight);
+            stroke(config.stroke);
+            strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(origin[0], origin[1]);
-            for(var i = domain[0][0] / scl; i <= domain[0][1] / scl; i += res) {
-                for(var j = domain[1][0] / scl; j <= domain[1][1] / scl; j += res) {
+            translate(config.x, config.y);
+            for(var i = config.domain[0][0] / config.size; i <= config.domain[0][1] / config.size; i += config.res) {
+                for(var j = config.domain[1][0] / config.size; j <= config.domain[1][1] / config.size; j += config.res) {
                     var v = Chalkboard.vec2.fromField(vec2field, Chalkboard.vec2.new(i, j));
                     line(i, j, i + v.x, j + v.y);
                     data.push([i + v.x, j + v.y]);
@@ -937,230 +1131,258 @@ var Chalkboard = {
             popMatrix();
             return data;
         },
-        vec3: function(vec3, scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 5;
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
-            strokeWeight(weight);
+        vec3: function(vec3, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 5
+            }).size /= 100;
+            stroke(config.stroke);
+            strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(origin[0], origin[1]);
-            line(0, 0, (vec3.x / scl) / (vec3.z * 0.25 + 1), (-vec3.y / scl) / (vec3.z * 0.25 + 1));
+            translate(config.x, config.y);
+            line(0, 0, (vec3.x / config.size) / (vec3.z * 0.25 + 1), (-vec3.y / config.size) / (vec3.z * 0.25 + 1));
             popMatrix();
             return [[vec3.x], [vec3.y], [vec3.z]];
         },
-        matr: function(matr, scl, rgba, origin, weight) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            var plotposx = Chalkboard.vec2.new(matr[0][0], matr[1][0]);
-            var plotnegx = Chalkboard.vec2.new(-matr[0][0], -matr[1][0]);
-            var plotposy = Chalkboard.vec2.new(matr[0][1], matr[1][1]);
-            var plotnegy = Chalkboard.vec2.new(-matr[0][1], -matr[1][1]);
-            for(var i = -10; i <= 10; i++) {
-                Chalkboard.vec2.plot(plotposx, scl, rgba, [origin[0], origin[1] + (i / scl) * matr[1][1]], weight / 4);
-                Chalkboard.vec2.plot(plotnegx, scl, rgba, [origin[0], origin[1] + (i / scl) * matr[1][1]], weight / 4);
-                Chalkboard.vec2.plot(plotposy, scl, rgba, [origin[0] + (i / scl) * matr[0][0], origin[1]], weight / 4);
-                Chalkboard.vec2.plot(plotnegy, scl, rgba, [origin[0] + (i / scl) * matr[0][0], origin[1]], weight / 4);
-            }
-            var plotposaxisx = Chalkboard.vec2.new(matr[0][0], matr[1][0]);
-            var plotnegaxisx = Chalkboard.vec2.new(-matr[0][0], -matr[1][0]);
-            var plotposaxisy = Chalkboard.vec2.new(matr[0][1], matr[1][1]);
-            var plotnegaxisy = Chalkboard.vec2.new(-matr[0][1], -matr[1][1]);
-            Chalkboard.vec2.plot(plotposaxisx, scl, rgba, origin, weight);
-            Chalkboard.vec2.plot(plotnegaxisx, scl, rgba, origin, weight);
-            Chalkboard.vec2.plot(plotposaxisy, scl, rgba, origin, weight);
-            Chalkboard.vec2.plot(plotnegaxisy, scl, rgba, origin, weight);
+        matr: function(matr, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10]
+            }).size /= 100;
+            for(var i = config.domain[0]; i <= config.domain[1]; i++) {
+                Chalkboard.plot.vec2(Chalkboard.vec2.new(matr[0][0], matr[1][0]), {x: config.x, y: config.y + (i / config.size) * matr[1][1], size: config.size, stroke: config.stroke, strokeWeight: config.strokeWeight / 4});
+                Chalkboard.plot.vec2(Chalkboard.vec2.new(-matr[0][0], -matr[1][0]), {x: config.x, y: config.y + (i / config.size) * matr[1][1], size: config.size, stroke: config.stroke, strokeWeight: config.strokeWeight / 4});
+                Chalkboard.plot.vec2(Chalkboard.vec2.new(matr[0][1], matr[1][1]), {x: config.x + (i / config.size) * matr[0][0], y: config.y, size: config.size, stroke: config.stroke, strokeWeight: config.strokeWeight / 4});
+                Chalkboard.plot.vec2(Chalkboard.vec2.new(-matr[0][1], -matr[1][1]), {x: config.x + (i / config.size) * matr[0][0], y: config.y, size: config.size, stroke: config.stroke, strokeWeight: config.strokeWeight / 4});
+            }
+            Chalkboard.plot.vec2(Chalkboard.vec2.new(matr[0][0], matr[1][0]), config);
+            Chalkboard.plot.vec2(Chalkboard.vec2.new(-matr[0][0], -matr[1][0]), config);
+            Chalkboard.plot.vec2(Chalkboard.vec2.new(matr[0][1], matr[1][1]), config);
+            Chalkboard.plot.vec2(Chalkboard.vec2.new(-matr[0][1], -matr[1][1]), config);
             return matr;
         },
-        dfdx: function(func, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        dfdx: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.dfdx(func, i * scl) / scl);
-                data.push([i, Chalkboard.calc.dfdx(func, i)]);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                if(func.type === "expl") {
+                    vertex(i, -Chalkboard.calc.dfdx(func, i * config.size) / config.size);
+                    data.push([i, Chalkboard.calc.dfdx(func, i)]);
+                } else if(func.type === "inve") {
+                    vertex(Chalkboard.calc.dfdx(func, i * config.size) / config.size, -i);
+                    data.push([Chalkboard.calc.dfdx(func, i), i]);
+                }
             }
             endShape();
             popMatrix();
             return data;
         },
-        d2fdx2: function(func, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        d2fdx2: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.d2fdx2(func, i * scl) / scl);
-                data.push([i, Chalkboard.calc.d2fdx2(func, i)]);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                if(func.type === "expl") {
+                    vertex(i, -Chalkboard.calc.d2fdx2(func, i * config.size) / config.size);
+                    data.push([i, Chalkboard.calc.d2fdx2(func, i)]);
+                } else if(func.type === "inve") {
+                    vertex(Chalkboard.calc.d2fdx2(func, i * config.size) / config.size, -i);
+                    data.push([Chalkboard.calc.d2fdx2(func, i), i]);
+                }
             }
             endShape();
             popMatrix();
             return data;
         },
-        fxdx: function(func, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        fxdx: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.fxdx(func, 0, i * scl) / scl);
-                data.push([i, Chalkboard.calc.fxdx(func, 0, i)]);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                if(func.type === "expl") {
+                    vertex(i, -Chalkboard.calc.fxdx(func, 0, i * config.size) / config.size);
+                    data.push([i, Chalkboard.calc.fxdx(func, 0, i)]);
+                } else if(func.type === "inve") {
+                    vertex(Chalkboard.calc.fxdx(func, 0, i * config.size) / config.size, -i);
+                    data.push([Chalkboard.calc.fxdx(func, 0, i), i]);
+                }
             }
             endShape();
             popMatrix();
             return data;
         },
-        convolution: function(func_1, func_2, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        convolution: function(func_1, func_2, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.convolution(func_1, func_2, i * scl) / scl);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                vertex(i, -Chalkboard.calc.convolution(func_1, func_2, i * config.size) / config.size);
                 data.push([i, Chalkboard.calc.convolution(func_1, func_2, i)]);
             }
             endShape();
             popMatrix();
             return data;
         },
-        correlation: function(func_1, func_2, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        correlation: function(func_1, func_2, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.correlation(func_1, func_2, i * scl) / scl);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                vertex(i, -Chalkboard.calc.correlation(func_1, func_2, i * config.size) / config.size);
                 data.push([i, Chalkboard.calc.correlation(func_1, func_2, i)]);
             }
             endShape();
             popMatrix();
             return data;
         },
-        autocorrelation: function(func, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        autocorrelation: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.autocorrelation(func, i * scl) / scl);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                vertex(i, -Chalkboard.calc.autocorrelation(func, i * config.size) / config.size);
                 data.push([i, Chalkboard.calc.autocorrelation(func, i)]);
             }
             endShape();
             popMatrix();
             return data;
         },
-        Taylor: function(func, n, a, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        Taylor: function(func, n, a, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.Taylor(func, i * scl, n, a) / scl);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                vertex(i, -Chalkboard.calc.Taylor(func, i * config.size, n, a) / config.size);
                 data.push([i, Chalkboard.calc.Taylor(func, i, n, a)]);
             }
             endShape();
             popMatrix();
             return data;
         },
-        Laplace: function(func, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        Laplace: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            if(domain[0] >= 0) {
-                for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                    vertex(i, -Chalkboard.calc.Laplace(func, i * scl) / scl);
+            if(config.domain[0] >= 0) {
+                for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                    vertex(i, -Chalkboard.calc.Laplace(func, i * config.size) / config.size);
                     data.push([i, Chalkboard.calc.Laplace(func, i)]);
                 }
             } else {
-                for(var i = 0; i <= domain[1] / scl; i += res) {
-                    vertex(i, -Chalkboard.calc.Laplace(func, i * scl) / scl);
+                for(var i = 0; i <= config.domain[1] / config.size; i += config.res) {
+                    vertex(i, -Chalkboard.calc.Laplace(func, i * config.size) / config.size);
                     data.push([i, Chalkboard.calc.Laplace(func, i)]);
                 }
             }
@@ -1168,23 +1390,25 @@ var Chalkboard = {
             popMatrix();
             return data;
         },
-        Fourier: function(func, scl, rgba, domain, origin, weight, res) {
-            scl = scl || 1;
-            scl /= 100;
-            rgba = rgba || [0, 0, 0];
-            domain = domain || [-10, 10];
-            origin = origin || [width / 2, height / 2];
-            weight = weight || 2;
-            res = res || 25;
+        Fourier: function(func, config) {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
+                size: config.size || 1,
+                stroke: config.stroke || color(0),
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
+                res: config.res || 25
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(origin[0], origin[1]);
+            translate(config.x, config.y);
             noFill();
-            strokeWeight(weight);
-            stroke(rgba.length === 3 ? color(rgba[0], rgba[1], rgba[2]) : color(rgba[0], rgba[1], rgba[2], rgba[3]));
+            strokeWeight(config.strokeWeight);
+            stroke(config.stroke);
             beginShape();
-            for(var i = domain[0] / scl; i <= domain[1] / scl; i += res) {
-                vertex(i, -Chalkboard.calc.Fourier(func, i * scl) / scl);
+            for(var i = config.domain[0] / config.size; i <= config.domain[1] / config.size; i += config.res) {
+                vertex(i, -Chalkboard.calc.Fourier(func, i * config.size) / config.size);
                 data.push([i, Chalkboard.calc.Fourier(func, i)]);
             }
             endShape();
@@ -1516,6 +1740,16 @@ var Chalkboard = {
             }
             return result;
         },
+        shuffle: function(arr) {
+            var index, temp, rindex;
+            for(index = arr.length - 1; index > 0; index--) {
+                rindex = Math.floor(Chalkboard.numb.random(0, index + 1));
+                temp = arr[index];
+                arr[index] = arr[rindex];
+                arr[rindex] = temp;
+            }
+            return arr;
+        },
         norm: function(arr, type) {
             type = type || "L2";
             var result = 0;
@@ -1589,7 +1823,7 @@ var Chalkboard = {
         },
         eq: function(arr, arrORnum) {
             var result = [];
-            if(arrORnum.constructor === Array) {
+            if(Array.isArray(arrORnum)) {
                 if(arr.length === arrORnum.length) {
                     for(var i = 0; i < arr.length; i++) {
                         if(arr[i] === arrORnum[i]) {
@@ -1610,7 +1844,7 @@ var Chalkboard = {
             includeInf = includeInf || false;
             includeSup = includeSup || false;
             var result = [];
-            if(inf.constructor === Array && sup.constructor === Array) {
+            if(Array.isArray(inf) && Array.isArray(sup)) {
                 if(arr.length === inf.length && arr.length === sup.length) {
                     for(var i = 0; i < arr.length; i++) {
                         if(includeInf) {
@@ -1666,7 +1900,7 @@ var Chalkboard = {
         lt: function(arr, arrORnum, includeEnd) {
             includeEnd = includeEnd || false;
             var result = [];
-            if(arrORnum.constructor === Array) {
+            if(Array.isArray(arrORnum)) {
                 if(arr.length === arrORnum.length) {
                     for(var i = 0; i < arr.length; i++) {
                         if(includeEnd) {
@@ -1698,7 +1932,7 @@ var Chalkboard = {
         gt: function(arr, arrORnum, includeEnd) {
             includeEnd = includeEnd || false;
             var result = [];
-            if(arrORnum.constructor === Array) {
+            if(Array.isArray(arrORnum)) {
                 if(arr.length === arrORnum.length) {
                     for(var i = 0; i < arr.length; i++) {
                         if(includeEnd) {
@@ -1727,6 +1961,23 @@ var Chalkboard = {
             }
             return result;
         },
+        subsets: function(arr) {
+            var result = [[]];
+            arr.sort();
+            for(var i = 0; i < arr.length; i++) {
+                if(i === 0 || arr[i] !== arr[i - 1]) {
+                    var curr = arr[i];
+                    var subsetsWithCurr = [];
+                    for(var j = 0; j < result.length; j++) {
+                        var subset = result[j].slice();
+                        subset.push(curr);
+                        subsetsWithCurr.push(subset);
+                    }
+                    result = result.concat(subsetsWithCurr);
+                }
+            }
+            return result;
+        },
         max: function(arr) {
             var max = arr[0];
             for(var i = 0; i < arr.length; i++) {
@@ -1760,7 +2011,7 @@ var Chalkboard = {
                 for(var i = 0; i < arr.length; i++) {
                     result *= arr[i];
                 }
-                return Chalkboard.real.nrt(Math.abs(result), arr.length);
+                return Chalkboard.real.root(Math.abs(result), arr.length);
             } else if(type === "harmonic") {
                 for(var i = 0; i < arr.length; i++) {
                     result += 1 / arr[i];
@@ -1925,13 +2176,93 @@ var Chalkboard = {
         Gaussian: function(height, mean, deviation) {
             return Chalkboard.real.function(height.toString() + " * Math.exp(-((x - " + mean.toString() + ") * (x - " + mean.toString() + ")) / (2 * " + deviation.toString() + " * " + deviation.toString() + "))");
         },
-        toVector: function(arr, type) {
+        regression: function(data, type, degree) {
+            type = type || "linear";
+            degree = degree || 2;
+            if(type === "linear") {
+                var x = 0, y = 0;
+                var xx = 0, xy = 0;
+                for(var i = 0; i < data.length; i++) {
+                    x += data[i][0];
+                    y += data[i][1];
+                    xx += data[i][0] * data[i][0];
+                    xy += data[i][0] * data[i][1];
+                }
+                var a = (data.length * xy - x * y) / (data.length * xx - x * x),
+                    b = (y / data.length) - (a * x) / data.length;
+                return Chalkboard.real.function(a + " * x + " + b);
+            } else if(type === "polynomial") {
+                var A = Chalkboard.matr.new();
+                for(var i = 0; i < data.length; i++) {
+                    A.push([]);
+                    for(var j = 0; j <= degree; j++) {
+                        A[i].push(Chalkboard.real.pow(data[i][0], j));
+                    }
+                }
+                var AT = Chalkboard.matr.transpose(A);
+                var B = Chalkboard.matr.new();
+                for(var i = 0; i < data.length; i++) {
+                    B.push([data[i][1]]);
+                }
+                var ATA = Chalkboard.matr.mul(AT, A);
+                var ATAI = Chalkboard.matr.invert(ATA);
+                var x = Chalkboard.matr.mul(Chalkboard.matr.mul(ATAI, AT), B);
+                var coeff = [];
+                for(var i = 0; i < x.length; i++) {
+                    coeff.push(x[i][0]);
+                }
+                var f = coeff[0].toString() + " + " + coeff[1].toString() + " * x";
+                for(var i = 2; i <= degree; i++) {
+                    f += " + " + coeff[i].toString() + " * Math.pow(x, " + i + ")";
+                }
+                return Chalkboard.real.function(f);
+            } else if(type === "power") {
+                var arr = [0, 0, 0, 0];
+                for(var i = 0; i < data.length; i++) {
+                    arr[0] += Chalkboard.real.ln(data[i][0]);
+                    arr[1] += data[i][1] * Chalkboard.real.ln(data[i][0]);
+                    arr[2] += data[i][1];
+                    arr[3] += Chalkboard.real.ln(data[i][0]) * Chalkboard.real.ln(data[i][0]);
+                }
+                var a = Chalkboard.E((arr[2] - ((data.length * arr[1] - arr[2] * arr[0]) / (data.length * arr[3] - arr[0] * arr[0])) * arr[0]) / data.length),
+                    b = (data.length * arr[1] - arr[2] * arr[0]) / (data.length * arr[3] - arr[0] * arr[0]);
+                return Chalkboard.real.function(a + " * Math.pow(x, " + b + ")");
+            } else if(type === "exponential") {
+                var arr = [0, 0, 0, 0, 0, 0];
+                for(var i = 0; i < data.length; i++) {
+                    arr[0] += data[i][0];
+                    arr[1] += data[i][1];
+                    arr[2] += data[i][0] * data[i][0] * data[i][1];
+                    arr[3] += data[i][1] * Chalkboard.real.ln(data[i][1]);
+                    arr[4] += data[i][0] & data[i][1] * Chalkboard.real.ln(data[i][1]);
+                    arr[5] += data[i][0] * data[i][1];
+                }
+                var a = Chalkboard.E((arr[2] * arr[3] - arr[5] * arr[4]) / (arr[1] * arr[2] - arr[5] * arr[5])),
+                    b = (arr[1] * arr[4] - arr[5] * arr[3]) / (arr[1] * arr[2] - arr[5] * arr[5]);
+                return Chalkboard.real.function(a + "* Math.exp(" + b + " * x)");
+            } else if(type === "logarithmic") {
+                var arr = [0, 0, 0, 0];
+                for(var i = 0; i < data.length; i++) {
+                    arr[0] += Chalkboard.real.ln(data[i][0]);
+                    arr[1] += data[i][1] * Chalkboard.real.ln(data[i][0]);
+                    arr[2] += data[i][1];
+                    arr[3] += Chalkboard.real.ln(data[i][0]) * Chalkboard.real.ln(data[i][0]);
+                }
+                var a = (arr[2] - ((data.length * arr[1] - arr[2] * arr[0]) / (data.length * arr[3] - arr[0] * arr[0])) * arr[0]) / data.length,
+                    b = (data.length * arr[1] - arr[2] * arr[0]) / (data.length * arr[3] - arr[0] * arr[0]);
+                return Chalkboard.real.function(a + " + " + b + " * Math.log(x)");
+            } else {
+                return "TypeError: Parameter \"type\" must be either \"linear\", \"polynomial\", \"power\", \"exponential\", or \"logarithmic\".";
+            }
+        },
+        toVector: function(arr, type, index) {
+            if(index === undefined) { index = 0; }
             if(type === "vec2") {
-                return Chalkboard.vec2.new(arr[0], arr[1]);
+                return Chalkboard.vec2.new(arr[index], arr[index + 1]);
             } else if(type === "vec3") {
-                return Chalkboard.vec3.new(arr[0], arr[1], arr[2]);
+                return Chalkboard.vec3.new(arr[index], arr[index + 1], arr[index + 2]);
             } else if(type === "vec4") {
-                return Chalkboard.vec4.new(arr[0], arr[1], arr[2], arr[3]);
+                return Chalkboard.vec4.new(arr[index], arr[index + 1], arr[index + 2], arr[index + 3]);
             } else {
                 return "TypeError: Parameter \"type\" should be \"vec2\", \"vec3\", or \"vec4\".";
             }
@@ -1952,6 +2283,12 @@ var Chalkboard = {
             }
             return result;
         },
+        toTensor: function(arr, size) {
+            if(!Array.isArray(size)) {
+                size = Array.from(arguments).slice(1);
+            }
+            return Chalkboard.tens.resize(arr, size);
+        },
         toObject: function(arr) {
             var result = {};
             for(var i = 0; i < arr.length; i++) {
@@ -1974,6 +2311,9 @@ var Chalkboard = {
                 return {x: x, y: y, type: "vec2"};
             }
         },
+        copy: function(vec2) {
+            return Object.create(Object.getPrototypeOf(vec2), Object.getOwnPropertyDescriptors(vec2));
+        },
         random: function(inf, sup) {
             return Chalkboard.vec2.new(Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup));
         },
@@ -2118,6 +2458,9 @@ var Chalkboard = {
                 return {x: x, y: y, z: z, type: "vec3"};
             }
         },
+        copy: function(vec3) {
+            return Object.create(Object.getPrototypeOf(vec3), Object.getOwnPropertyDescriptors(vec3));
+        },
         random: function(inf, sup) {
             return Chalkboard.vec3.new(Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup));
         },
@@ -2269,6 +2612,9 @@ var Chalkboard = {
                 return {x: x, y: y, z: z, w: w, type: "vec4"};
             }
         },
+        copy: function(vec4) {
+            return Object.create(Object.getPrototypeOf(vec4), Object.getOwnPropertyDescriptors(vec4));
+        },
         random: function(inf, sup) {
             return Chalkboard.vec4.new(Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup), Chalkboard.numb.random(inf, sup));
         },
@@ -2403,7 +2749,23 @@ var Chalkboard = {
     },
     matr: {
         new: function(matrix) {
-            return Array.from(arguments);
+            if(arguments.length === 0) {
+                return [];
+            } else if(Array.isArray(matrix) && Array.isArray(matrix[0])) {
+                return matrix;
+            } else {
+                return Array.from(arguments);
+            }
+        },
+        copy: function(matr) {
+            var result = Chalkboard.matr.new();
+            for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
+                result.push([]);
+                for(var j = 0; j < Chalkboard.matr.cols(matr); j++) {
+                    result[i].push(matr[i][j]);
+                }
+            }
+            return result;
         },
         rows: function(matr) {
             return matr.length;
@@ -2411,12 +2773,75 @@ var Chalkboard = {
         cols: function(matr) {
             return matr[0].length;
         },
-        empty: function(dimension) {
-            if(Number.isInteger(dimension) && dimension > 0) {
+        resize: function(matr, rows, cols) {
+            if(cols === undefined) {
+                cols = rows;
+            }
+            var result = Chalkboard.matr.new();
+            var flat = Chalkboard.matr.toArray(matr);
+            var index = 0;
+            for(var i = 0; i < rows; i++) {
+                result.push([]);
+                for(var j = 0; j < cols; j++) {
+                    result[i].push(index < flat.length ? flat[index++] : 0);
+                }
+            }
+            return result;
+        },
+        push: function(matr, type, rowORcol, elements) {
+            rowORcol -= 1;
+            if(type === "row") {
+                matr.splice(rowORcol, 0, elements);
+                return matr;
+            } else if(type === "col") {
+                for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
+                    matr[i].splice(rowORcol, 0, elements[i]);
+                }
+                return matr;
+            } else {
+                return "TypeError: Parameter \"type\" must be either \"row\" or \"col\".";
+            }
+        },
+        pull: function(matr, type, rowORcol) {
+            rowORcol -= 1;
+            if(type === "row") {
+                matr.splice(rowORcol, 1);
+                return matr;
+            } else if(type === "col") {
+                for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
+                    matr[i].splice(rowORcol, 1);
+                }
+                return matr;
+            } else {
+                return "TypeError: Parameter \"type\" must be either \"row\" or \"col\".";
+            }
+        },
+        fill: function(element, rows, cols) {
+            if(cols === undefined) {
+                cols = rows;
+            }
+            if(Number.isInteger(rows) && Number.isInteger(cols) && rows > 0 && cols > 0) {
                 var result = Chalkboard.matr.new();
-                for(var i = 0; i < dimension; i++) {
+                for(var i = 0; i < rows; i++) {
                     result.push([]);
-                    for(var j = 0; j < dimension; j++) {
+                    for(var j = 0; j < cols; j++) {
+                        result[i].push(element);
+                    }
+                }
+                return result;
+            } else {
+                return undefined;
+            }
+        },
+        empty: function(rows, cols) {
+            if(cols === undefined) {
+                cols = rows;
+            }
+            if(Number.isInteger(rows) && Number.isInteger(cols) && rows > 0 && cols > 0) {
+                var result = Chalkboard.matr.new();
+                for(var i = 0; i < rows; i++) {
+                    result.push([]);
+                    for(var j = 0; j < cols; j++) {
                         result[i].push(null);
                     }
                 }
@@ -2425,11 +2850,11 @@ var Chalkboard = {
                 return undefined;
             }
         },
-        identity: function(dimension) {
-            if(Number.isInteger(dimension) && dimension > 0) {
+        identity: function(size) {
+            if(Number.isInteger(size) && size > 0) {
                 var result = Chalkboard.matr.new();
-                for(var i = 0; i < dimension; i++) {
-                    result.push(Array(dimension).fill(0));
+                for(var i = 0; i < size; i++) {
+                    result.push(Array(size).fill(0));
                     result[i][i] = 1;
                 }
                 return result;
@@ -2437,14 +2862,30 @@ var Chalkboard = {
                 return undefined;
             }
         },
-        random: function(dimension, inf, sup) {
-            if(Number.isInteger(dimension) && dimension > 0) {
-                inf = inf || 0;
-                sup = sup || 1;
+        exchange: function(size) {
+            if(Number.isInteger(size) && size > 0) {
+                var result = Chalkboard.matr.fill(0, size, size);
+                for(var i = 0; i < size; i++) {
+                    for(var j = 0; j < size; j++) {
+                        if(i + j === size - 1) {
+                            result[i][j] = 1;
+                        }
+                    }
+                }
+                return result;
+            } else {
+                return undefined;
+            }
+        },
+        random: function(inf, sup, rows, cols) {
+            if(cols === undefined) {
+                cols = rows;
+            }
+            if(Number.isInteger(rows) && Number.isInteger(cols) && rows > 0 && cols > 0) {
                 var result = Chalkboard.matr.new();
-                for(var i = 0; i < dimension; i++) {
+                for(var i = 0; i < rows; i++) {
                     result.push([]);
-                    for(var j = 0; j < dimension; j++) {
+                    for(var j = 0; j < cols; j++) {
                         result[i].push(Chalkboard.numb.random(inf, sup));
                     }
                 }
@@ -2453,8 +2894,75 @@ var Chalkboard = {
                 return undefined;
             }
         },
+        shift: function(size, shiftAmount) {
+            shiftAmount = shiftAmount || 1;
+            if(Number.isInteger(size) && size > 0) {
+                var result = Chalkboard.matr.fill(0, size, size);
+                for(var i = 0; i < size; i++) {
+                    for(var j = 0; j < size; j++) {
+                        result[i][j] = Chalkboard.numb.Kronecker(i + shiftAmount, j);
+                    }
+                }
+                return result;
+            } else {
+                return undefined;
+            }
+        },
+        binomial: function(size, type) {
+            type = type || "lower";
+            if(Number.isInteger(size) && size > 0) {
+                var result = Chalkboard.matr.new();
+                for(var i = 0; i < size; i++) {
+                    result.push([]);
+                    for(var j = 0; j < size; j++) {
+                        if(type === "lower") {
+                            result[i].push(Chalkboard.numb.binomial(i, j));
+                        } else if(type === "upper") {
+                            result[i].push(Chalkboard.numb.binomial(j, i));
+                        }
+                    }
+                }
+                if(type === "symmetric") {
+                    return Chalkboard.matr.mul(Chalkboard.matr.binomial(size, "lower"), Chalkboard.matr.binomial(size, "upper"));
+                } else if(type !== "lower" && type !== "upper") {
+                    return "TypeError: Parameter \"type\" must be either \"lower\", \"upper\", or \"symmetric\".";
+                } else {
+                    return result;
+                }
+            } else {
+                return undefined;
+            }
+        },
+        Hilbert: function(size) {
+            if(Number.isInteger(size) && size > 0) {
+                var result = Chalkboard.matr.new();
+                for(var i = 0; i < size; i++) {
+                    result.push([]);
+                    for(var j = 0; j < size; j++) {
+                        result[i].push(1 / (i + j + 1));
+                    }
+                }
+                return result;
+            } else {
+                return undefined;
+            }
+        },
+        Lehmer: function(size) {
+            if(Number.isInteger(size) && size > 0) {
+                var result = Chalkboard.matr.new();
+                for(var i = 0; i < size; i++) {
+                    result.push([]);
+                    for(var j = 0; j < size; j++) {
+                        result[i].push(Math.min(i + 1, j + 1) / Math.max(i + 1, j + 1));
+                    }
+                }
+                return result;
+            } else {
+                return undefined;
+            }
+        },
         cofactor: function(matr, row, col) {
-            return matr.slice(0, row - 1).concat(matr.slice(row)).map(function (row) {
+            return matr.slice(0, row - 1).concat(matr.slice(row)).map(function(row) {
                 return row.slice(0, col - 1).concat(row.slice(col));
             });
         },
@@ -2491,15 +2999,15 @@ var Chalkboard = {
             }
         },
         rank: function(matr) {
-            return Chalkboard.matr.reduce(matr).filter(function (row) {
-                return row.some(function (element) {
+            return Chalkboard.matr.reduce(matr).filter(function(row) {
+                return row.some(function(element) {
                     return element !== 0;
                 });
             }).length;
         },
         rowspace: function(matr) {
-            return Chalkboard.matr.reduce(matr).filter(function (row) {
-                return row.some(function (element) {
+            return Chalkboard.matr.reduce(matr).filter(function(row) {
+                return row.some(function(element) {
                     return element !== 0;
                 });
             });
@@ -2508,15 +3016,15 @@ var Chalkboard = {
             return Chalkboard.matr.transpose(Chalkboard.matr.rowspace(Chalkboard.matr.transpose(matr)));
         },
         nullspace: function(matr) {
-            var augmented = matr.map(function (row) {
+            var augmented = matr.map(function(row) {
                 return row.slice().concat(Array(Chalkboard.matr.rows(matr)).fill(0));
             });
             var reduced = Chalkboard.matr.reduce(augmented);
-            return reduced.filter(function (row) {
-                return row.slice(0, Chalkboard.matr.rows(matr)).every(function (element) {
+            return reduced.filter(function(row) {
+                return row.slice(0, Chalkboard.matr.rows(matr)).every(function(element) {
                     return element === 0;
                 });
-            }).map(function (row) {
+            }).map(function(row) {
                 return row.slice(Chalkboard.matr.rows(matr));
             });
         },
@@ -2572,6 +3080,78 @@ var Chalkboard = {
                 return undefined;
             }
         },
+        LUdecomp: function(matr) {
+            if(Chalkboard.matr.rows(matr) === Chalkboard.matr.cols(matr)) {
+                var L = Chalkboard.matr.identity(Chalkboard.matr.rows(matr)),
+                    U = Chalkboard.matr.fill(0, Chalkboard.matr.rows(matr));
+                for(var j = 0; j < Chalkboard.matr.cols(matr); j++) {
+                    for(var i = 0; i <= j; i++) {
+                        var sum = 0;
+                        for(var k = 0; k < i; k++) {
+                            sum += L[i][k] * U[k][j];
+                        }
+                        U[i][j] = matr[i][j] - sum;
+                    }
+                    for(var i = j + 1; i < Chalkboard.matr.rows(matr); i++) {
+                        var sum = 0;
+                        for(var k = 0; k < j; k++) {
+                            sum += L[i][k] * U[k][j];
+                        }
+                        L[i][j] = (matr[i][j] - sum) / U[j][j];
+                    }
+                }
+                return {L: L, U: U};
+            } else {
+                return undefined;
+            }
+        },
+        QRdecomp: function(matr) {
+            var Q = Chalkboard.matr.identity(Chalkboard.matr.rows(matr)),
+                R = Chalkboard.matr.copy(matr);
+            for(var j = 0; j < Math.min(Chalkboard.matr.rows(matr), Chalkboard.matr.cols(matr)) - (Chalkboard.matr.rows(matr) > Chalkboard.matr.cols(matr) ? 0 : 1); j++) {
+                var norm = 0;
+                for(var i = j; i < Chalkboard.matr.rows(matr); i++) {
+                    norm += R[i][j] * R[i][j];
+                }
+                norm = Chalkboard.real.sqrt(norm);
+                var v = [];
+                v[0] = norm - R[j][j];
+                var normalizer = v[0] * v[0];
+                for(var i = 1; i < Chalkboard.matr.rows(matr) - j; i++) {
+                    v[i] = -R[i + j][j];
+                    normalizer += v[i] * v[i];
+                }
+                normalizer = 1 / Chalkboard.real.sqrt(normalizer);
+                for(var i = 0; i < v.length; i++) {
+                    v[i] *= normalizer;
+                }
+                R[j][j] = norm;
+                for(var i = j + 1; i < Chalkboard.matr.rows(R); i++) {
+                    R[i][j] = 0;
+                }
+                for(var k = j + 1; k < Chalkboard.matr.cols(R); k++) {
+                    var dot = 0;
+                    for(var i = 0; i < v.length; i++) {
+                        dot += v[i] * R[i + j][k];
+                    }
+                    dot *= 2;
+                    for(var i = 0; i < v.length; i++) {
+                        R[i + j][k] -= dot * v[i];
+                    }
+                }
+                for(var k = 0; k < Chalkboard.matr.cols(Q); k++) {
+                    var dot = 0;
+                    for(var i = 0; i < v.length; i++) {
+                        dot += v[i] * Q[k][i + j];
+                    }
+                    dot *= 2;
+                    for(var i = 0; i < v.length; i++) {
+                        Q[k][i + j] -= dot * v[i];
+                    }
+                }
+            }
+            return {Q: Q, R: R};
+        },
         zero: function(matr) {
             var result = Chalkboard.matr.new();
             for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
@@ -2672,6 +3252,28 @@ var Chalkboard = {
             }
             return result;
         },
+        concat: function(matr_1, matr_2, type) {
+            type = type || "row";
+            if(type === "row") {
+                if(Chalkboard.matr.rows(matr_1) === Chalkboard.matr.rows(matr_2)) {
+                    return Chalkboard.matr.new(matr_1.concat(matr_2));
+                } else {
+                    return undefined;
+                }
+            } else if(type === "col") {
+                if(Chalkboard.matr.cols(matr_1) === Chalkboard.matr.cols(matr_2)) {
+                    var result = Chalkboard.matr.new();
+                    for(var i = 0; i < Chalkboard.matr.rows(matr_1); i++) {
+                        result.push(matr_1[i].concat(matr_2[i]));
+                    }
+                    return result;
+                } else {
+                    return undefined;
+                }
+            } else {
+                return "TypeError: Parameter \"type\" should be either \"row\" or \"col\".";
+            }
+        },
         add: function(matr_1, matr_2) {
             if(Chalkboard.matr.rows(matr_1) === Chalkboard.matr.rows(matr_2) && Chalkboard.matr.cols(matr_1) === Chalkboard.matr.cols(matr_2)) {
                 var result = Chalkboard.matr.new();
@@ -2717,6 +3319,29 @@ var Chalkboard = {
                 return undefined;
             }
         },
+        mulvec: function(matr, vec) {
+            if(vec.type === "vec2") {
+                if(Chalkboard.matr.rows(matr) === 2) {
+                    return Chalkboard.matr.toVector(Chalkboard.matr.mul(matr, Chalkboard.vec2.toMatrix(vec)), "vec2");
+                } else {
+                    return Chalkboard.matr.mul(matr, Chalkboard.vec2.toMatrix(vec));
+                }
+            } else if(vec.type === "vec3") {
+                if(Chalkboard.matr.rows(matr) === 3) {
+                    return Chalkboard.matr.toVector(Chalkboard.matr.mul(matr, Chalkboard.vec3.toMatrix(vec)), "vec3");
+                } else {
+                    return Chalkboard.matr.mul(matr, Chalkboard.vec2.toMatrix(vec));
+                }
+            } else if(vec.type === "vec4") {
+                if(Chalkboard.matr.rows(matr) === 4) {
+                    return Chalkboard.matr.toVector(Chalkboard.matr.mul(matr, Chalkboard.vec4.toMatrix(vec)), "vec4");
+                } else {
+                    return Chalkboard.matr.mul(matr, Chalkboard.vec2.toMatrix(vec));
+                }
+            } else {
+                return "TypeError: Parameter \"vec\" should be \"vec2\", \"vec3\", or \"vec4\".";
+            }
+        },
         pow: function(matr, num) {
             if(Chalkboard.matr.rows(matr) === Chalkboard.matr.cols(matr)) {
                 if(Number.isInteger(num) && num >= 0) {
@@ -2736,6 +3361,29 @@ var Chalkboard = {
                 return undefined;
             }
         },
+        addKronecker: function(matr_1, matr_2) {
+            if(Chalkboard.matr.rows(matr_1) === Chalkboard.matr.cols(matr_1) && Chalkboard.matr.rows(matr_2) === Chalkboard.matr.cols(matr_2)) {
+                return Chalkboard.matr.add(Chalkboard.matr.mulKronecker(matr_1, Chalkboard.matr.identity(Chalkboard.matr.rows(matr_1))), Chalkboard.matr.mulKronecker(Chalkboard.matr.identity(Chalkboard.matr.rows(matr_2)), matr_2));
+            } else {
+                return undefined;
+            }
+        },
+        mulKronecker: function(matr_1, matr_2) {
+            var result = Chalkboard.matr.new();
+            for(var i = 0; i < Chalkboard.matr.rows(matr_1); i++) {
+                for(var j = 0; j < Chalkboard.matr.cols(matr_1); j++) {
+                    for(var k = 0; k < Chalkboard.matr.rows(matr_2); k++) {
+                        for(var l = 0; l < Chalkboard.matr.cols(matr_2); l++) {
+                            if(!result[i * Chalkboard.matr.rows(matr_2) + k]) {
+                                result[i * Chalkboard.matr.rows(matr_2) + k] = [];
+                            }
+                            result[i * Chalkboard.matr.rows(matr_2) + k][j * Chalkboard.matr.cols(matr_2) + l] = matr_1[i][j] * matr_2[k][l];
+                        }
+                    }
+                }
+            }
+            return result;
+        },
         reduce: function(matr) {
             var lead = 0;
             for(var row = 0; row < Chalkboard.matr.rows(matr); row++) {
@@ -2819,6 +3467,12 @@ var Chalkboard = {
                 return "TypeError: Parameter \"vec\" should be \"vec2\", \"vec3\", or \"vec4\".";
             }
         },
+        toTensor: function(matr, size) {
+            if(!Array.isArray(size)) {
+                size = Array.from(arguments).slice(1);
+            }
+            return Chalkboard.tens.resize(matr, size);
+        },
         toArray: function(matr) {
             var result = [];
             for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
@@ -2828,6 +3482,16 @@ var Chalkboard = {
             }
             return result;
         },
+        toObject: function(matr) {
+            var result = {};
+            for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
+                result["i" + (i + 1)] = {};
+                for(var j = 0; j < Chalkboard.matr.cols(matr); j++) {
+                    result["i" + (i + 1)]["j" + (j + 1)] = matr[i][j];
+                }
+            }
+            return result;
+        },
         toString: function(matr) {
             var result = "";
             for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
@@ -2839,18 +3503,369 @@ var Chalkboard = {
             }
             return result;
         },
-        toObject: function(matr) {
-            var result = {};
-            for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
-                result["i" + (i + 1)] = {};
-                for(var j = 0; j < Chalkboard.matr.cols(matr); j++) {
-                    result["i" + (i + 1)]["j" + (j + 1)] = matr[i][j];
+        print: function(matr) {
+            console.log(Chalkboard.matr.toString(matr));
+        }
+    },
+    tens: {
+        new: function(tensor) {
+            if(arguments.length === 0) {
+                return [];
+            } else if(arguments.length === 1 && Array.isArray(arguments[0])) {
+                tensor = arguments[0];
+            } else {
+                tensor = Array.from(arguments);
+            }
+            var newNDArray = function(arr) {
+                return arr.map(function(subarr) {
+                    if(Array.isArray(subarr)) {
+                        return newNDArray(subarr);
+                    } else {
+                        return subarr;
+                    }
+                });
+            };
+            return newNDArray(tensor);
+        },
+        copy: function(tens) {
+            if(Array.isArray(tens)) {
+                var result = Chalkboard.tens.new();
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.copy(tens[i]);
                 }
+                return result;
+            } else {
+                return tens;
             }
+        },
+        rank: function(tens) {
+            if(Array.isArray(tens)) {
+                var result = 0;
+                for(var i = 0; i < tens.length; i++) {
+                    result = Math.max(result, Chalkboard.tens.rank(tens[i]));
+                }
+                return result + 1;
+            } else {
+                return 0;
+            }
+        },
+        size: function(tens) {
+            if(Array.isArray(tens)) {
+                var result = [tens.length];
+                if(Array.isArray(tens[0])) {
+                    result = result.concat(Chalkboard.tens.size(tens[0]));
+                }
+                return result;
+            } else {
+                return [];
+            }
+        },
+        resize: function(tens, size) {
+            if(!Array.isArray(size)) {
+                size = Array.from(arguments).slice(1);
+            }
+            var result = Chalkboard.tens.fill(0, size);
+            var refill = function(arr1, arr2) {
+                for(var i = 0; i < arr2.length; i++) {
+                    if(Array.isArray(arr2[i])) {
+                        refill(arr1, arr2[i]);
+                    } else {
+                        arr2[i] = arr1.length > 0 ? arr1.shift() : 0;
+                    }
+                }
+            };
+            refill(Chalkboard.tens.toArray(tens), result);
             return result;
         },
-        print: function(matr) {
-            console.log(Chalkboard.matr.toString(matr));
+        push: function(tens, rank, index, elements) {
+            if(rank === 0) {
+                tens.splice(index, 0, elements);
+                return tens;
+            } else {
+                for(var i = 0; i < tens.length; i++) {
+                    Chalkboard.tens.push(tens[i], rank - 1, index, elements[i]);
+                }
+                return tens;
+            }
+        },
+        pull: function(tens, rank, index) {
+            if(rank === 0) {
+                tens.splice(index, 1);
+                return tens;
+            } else {
+                for(var i = 0; i < tens.length; i++) {
+                    Chalkboard.tens.pull(tens[i], rank - 1, index);
+                }
+                return tens;
+            }
+        },
+        fill: function(element, size) {
+            if(!Array.isArray(size)) {
+                size = Array.from(arguments).slice(1);
+            }
+            var newNDArray = function(size) {
+                if(size.length === 0) {
+                    return element;
+                }
+                var curr = size[0];
+                var rest = size.slice(1);
+                var result = [];
+                for(var i = 0; i < curr; i++) {
+                    result[i] = newNDArray(rest);
+                }
+                return result;
+            }
+            return newNDArray(size);
+        },
+        empty: function(size) {
+            if(!Array.isArray(size)) {
+                size = Array.from(arguments);
+            }
+            var newNDArray = function(size) {
+                if(size.length === 0) {
+                    return null;
+                }
+                var curr = size[0];
+                var rest = size.slice(1);
+                var result = [];
+                for(var i = 0; i < curr; i++) {
+                    result[i] = newNDArray(rest);
+                }
+                return result;
+            }
+            return newNDArray(size);
+        },
+        random: function(inf, sup, size) {
+            if(!Array.isArray(size)) {
+                size = Array.from(arguments).slice(2);
+            }
+            var newNDArray = function(size) {
+                if(size.length === 0) {
+                    return Chalkboard.numb.random(inf, sup);
+                }
+                var curr = size[0];
+                var rest = size.slice(1);
+                var result = [];
+                for(var i = 0; i < curr; i++) {
+                    result[i] = newNDArray(rest);
+                }
+                return result;
+            }
+            return newNDArray(size);
+        },
+        contract: function(tens) {
+            if(Chalkboard.tens.rank(tens) > 2) {
+                return Chalkboard.tens.resize(tens, Chalkboard.tens.size(tens)[0], Chalkboard.tens.size(tens).slice(1).reduce(function(a, b) { return a * b; }) / Chalkboard.tens.size(tens)[0]);
+            } else if(Chalkboard.tens.rank(tens) === 2) {
+                return Chalkboard.matr.trace(tens);
+            }
+        },
+        transpose: function(tens) {
+            return Chalkboard.tens.resize(tens, Chalkboard.tens.size(tens).reverse());
+        },
+        zero: function(tens) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.zero(tens[i]);
+                }
+                return result;
+            } else {
+                return 0;
+            }
+        },
+        negate: function(tens) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.negate(tens[i]);
+                }
+                return result;
+            } else {
+                return -tens;
+            }
+        },
+        reciprocate: function(tens) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.reciprocate(tens[i]);
+                }
+                return result;
+            } else {
+                return 1 / tens;
+            }
+        },
+        absolute: function(tens) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.absolute(tens[i]);
+                }
+                return result;
+            } else {
+                return Math.abs(tens);
+            }
+        },
+        round: function(tens) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.round(tens[i]);
+                }
+                return result;
+            } else {
+                return Math.round(tens);
+            }
+        },
+        scl: function(tens, num) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.scl(tens[i], num);
+                }
+                return result;
+            } else {
+                return tens * num;
+            }
+        },
+        constrain: function(tens, range) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens)) {
+                for(var i = 0; i < tens.length; i++) {
+                    result[i] = Chalkboard.tens.constrain(tens[i], range);
+                }
+                return result;
+            } else {
+                return Chalkboard.numb.constrain(tens, range);
+            }
+        },
+        concat: function(tens_1, tens_2, rank) {
+            rank = rank || 1;
+            var concatAtRank = function(arr1, arr2, currentRank) {
+                if(currentRank === rank) {
+                    return Chalkboard.tens.new(arr1.concat(arr2));
+                }
+                return arr1.map(function(element, index) {
+                    return concatAtRank(element, arr2[index], currentRank);
+                });
+            }
+            return concatAtRank(tens_1, tens_2, 1);
+        },
+        add: function(tens_1, tens_2) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens_1) && Array.isArray(tens_2)) {
+                for(var i = 0; i < Math.max(tens_1.length, tens_2.length); i++) {
+                    result[i] = Chalkboard.tens.add(tens_1[i] !== undefined ? tens_1[i] : 0, tens_2[i] !== undefined ? tens_2[i] : 0);
+                }
+                return result;
+            } else {
+                return tens_1 + tens_2;
+            }
+        },
+        sub: function(tens_1, tens_2) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens_1) && Array.isArray(tens_2)) {
+                for(var i = 0; i < Math.max(tens_1.length, tens_2.length); i++) {
+                    result[i] = Chalkboard.tens.sub(tens_1[i] !== undefined ? tens_1[i] : 0, tens_2[i] !== undefined ? tens_2[i] : 0);
+                }
+                return result;
+            } else {
+                return tens_1 - tens_2;
+            }
+        },
+        mul: function(tens_1, tens_2) {
+            var result = Chalkboard.tens.new();
+            if(Array.isArray(tens_1) && Array.isArray(tens_2)) {
+                for(var i = 0; i < tens_1.length; i++) {
+                    var subarr = Chalkboard.tens.new();
+                    for(var j = 0; j < tens_2.length; j++) {
+                        subarr[j] = Chalkboard.tens.mul(tens_1[i], tens_2[j]);
+                    }
+                    result.push(subarr);
+                }
+                return result;
+            } else {
+                return tens_1 * tens_2;
+            }
+        },
+        toVector: function(tens, type, index) {
+            if(index === undefined) { index = 0; }
+            var arr = Chalkboard.tens.toArray(tens);
+            if(type === "vec2") {
+                return Chalkboard.vec2.new(arr[index], arr[index + 1]);
+            } else if(type === "vec3") {
+                return Chalkboard.vec3.new(arr[index], arr[index + 1], arr[index + 2]);
+            } else if(type === "vec4") {
+                return Chalkboard.vec4.new(arr[index], arr[index + 1], arr[index + 2], arr[index + 3]);
+            } else {
+                return "TypeError: Parameter \"type\" should be \"vec2\", \"vec3\", or \"vec4\".";
+            }
+        },
+        toMatrix: function(tens) {
+            var result = Chalkboard.matr.new();
+            var flatten = function(tens, result) {
+                for(var i = 0; i < tens.length; i++) {
+                    if(Array.isArray(tens[i])) {
+                        flatten(tens[i], result);
+                    } else {
+                        result.push(tens[i]);
+                    }
+                }
+            }
+            var matr = Chalkboard.matr.new();
+            flatten(tens, matr);
+            var rows = tens.length || 1;
+            for(var j = 0; j < rows; j++) {
+                result.push(matr.slice(j * matr.length / rows, (j + 1) * matr.length / rows));
+            }
+            return result;
+        },
+        toArray: function(tens) {
+            var result = [];
+            var flatten = function(tens) {
+                for(var i = 0; i < tens.length; i++) {
+                    if(Array.isArray(tens[i])) {
+                        flatten(tens[i]);
+                    } else {
+                        result.push(tens[i]);
+                    }
+                }
+            }
+            flatten(tens);
+            return result;
+        },
+        toObject: function(tens) {
+            if(Array.isArray(tens)) {
+                var result = {};
+                for(var i = 0; i < tens.length; i++) {
+                    result["_" + (i + 1)] = Chalkboard.tens.toObject(tens[i]);
+                }
+                return result;
+            } else {
+                return tens;
+            }
+        },
+        toString: function(tens, indentation) {
+            if(indentation === undefined) { indentation = 0; }
+            if(Array.isArray(tens[0])) {
+                var result = "\t".repeat(indentation) + "[\n";
+                for(var i = 0; i < tens.length; i++) {
+                    result += Chalkboard.tens.toString(tens[i], indentation + 1);
+                }
+                result += "\t".repeat(indentation) + "]\n";
+                return result;
+            } else {
+                var result = "\t".repeat(indentation) + "[ ";
+                for(var i = 0; i < tens.length; i++) {
+                    result += tens[i].toString() + " ";
+                }
+                result += "]\n";
+                return result;
+            }
+        },
+        print: function(tens) {
+            return console.log(Chalkboard.tens.toString(tens));
         }
     },
     calc: {
@@ -2888,6 +3903,9 @@ var Chalkboard = {
             if(func.type === "expl") {
                 var f = Chalkboard.real.parse("x => " + func.definition);
                 return (f(val + h) - f(val)) / h;
+            } else if(func.type === "inve") {
+                var f = Chalkboard.real.parse("y => " + func.definition);
+                return (f(val + h) - f(val)) / h;
             } else if(func.type === "pola") {
                 var r = Chalkboard.real.parse("O => " + func.definition);
                 return (r(val + h) - r(val)) / h;
@@ -2903,7 +3921,7 @@ var Chalkboard = {
                     return Chalkboard.vec3.new((x(val + h) - x(val)) / h, (y(val + h) - y(val)) / h, (z(val + h) - z(val)) / h);
                 }
             } else {
-                return "TypeError: Parameter \"func\" must be of type \"expl\", \"pola\", or \"curv\".";
+                return "TypeError: Parameter \"func\" must be of type \"expl\", \"inve\", \"pola\", or \"curv\".";
             }
         },
         d2fdx2: function(func, val) {
@@ -2911,6 +3929,9 @@ var Chalkboard = {
             if(func.type === "expl") {
                 var f = Chalkboard.real.parse("x => " + func.definition);
                 return (f(val + h) - 2 * f(val) + f(val - h)) / (h * h);
+            } else if(func.type === "inve") {
+                var f = Chalkboard.real.parse("y => " + func.definition);
+                return (f(val + h) - 2 * f(val) + f(val - h)) / (h * h);
             } else if(func.type === "pola") {
                 var r = Chalkboard.real.parse("O => " + func.definition);
                 return (r(val + h) - 2 * r(val) + r(val - h)) / (h * h);
@@ -2926,7 +3947,7 @@ var Chalkboard = {
                     return Chalkboard.vec3.new((x(val + h) - 2 * x(val) + x(val - h)) / (h * h), (y(val + h) - 2 * y(val) + y(val - h)) / (h * h), (z(val + h) - 2 * z(val) + z(val - h)) / (h * h));
                 }
             } else {
-                return "TypeError: Parameter \"func\" must be of type \"expl\", \"pola\", or \"curv\".";
+                return "TypeError: Parameter \"func\" must be of type \"expl\", \"inve\", \"pola\", or \"curv\".";
             }
         },
         tangent: function(func, val) {
@@ -3181,7 +4202,7 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"comp\".";
             }
         },
-        df2dz2: function(func, comp) {
+        d2fdz2: function(func, comp) {
             var h = 0.00001;
             if(func.type === "comp") {
                 var u = Chalkboard.comp.parse("(a, b) => " + func.definition[0]),
@@ -3195,59 +4216,61 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"comp\".";
             }
         },
-        fxdx: function(func, a, b) {
-            if(func.type === "expl" || func.type === "pola") {
+        fxdx: function(func, inf, sup) {
+            if(func.type === "expl" || func.type === "inve" || func.type === "pola") {
                 var f;
                 if(func.type === "expl") {
                     f = Chalkboard.real.parse("x => " + func.definition);
+                } else if(func.type === "inve") {
+                    f = Chalkboard.real.parse("y => " + func.definition);
                 } else if(func.type === "pola") {
                     f = Chalkboard.real.parse("O => " + "((" + func.definition + ") * (" + func.definition + ")) / 2");
                 }
-                var fx = f(a) + f(b);
-                var dx = (b - a) / 1000000;
+                var fx = f(inf) + f(sup);
+                var dx = (sup - inf) / 1000000;
                 for(var i = 1; i < 1000000; i++) {
-                    fx += i % 2 === 0 ? 2 * f(a + i * dx) : 4 * f(a + i * dx);
+                    fx += i % 2 === 0 ? 2 * f(inf + i * dx) : 4 * f(inf + i * dx);
                 }
                 return (fx * dx) / 3;
             } else if(func.type === "curv") {
                 if(func.definition.length === 2) {
                     var x = Chalkboard.real.parse("t => " + func.definition[0]),
                         y = Chalkboard.real.parse("t => " + func.definition[1]);
-                    var xt = x(a) + x(b),
-                        yt = y(a) + y(b);
-                    var dt = (b - a) / 1000000;
+                    var xt = x(inf) + x(sup),
+                        yt = y(inf) + y(sup);
+                    var dt = (sup - inf) / 1000000;
                     for(var i = 1; i < 1000000; i++) {
-                        xt += i % 2 === 0 ? 2 * x(a + i * dt) : 4 * x(a + i * dt);
-                        yt += i % 2 === 0 ? 2 * y(a + i * dt) : 4 * y(a + i * dt);
+                        xt += i % 2 === 0 ? 2 * x(inf + i * dt) : 4 * x(inf + i * dt);
+                        yt += i % 2 === 0 ? 2 * y(sup + i * dt) : 4 * y(sup + i * dt);
                     }
                     return Chalkboard.vec2.new((xt * dt) / 3, (yt * dt) / 3);
                 } else if(func.definition.length === 3) {
                     var x = Chalkboard.real.parse("t => " + func.definition[0]),
                         y = Chalkboard.real.parse("t => " + func.definition[1]),
                         z = Chalkboard.real.parse("t => " + func.definition[2]);
-                    var xt = x(a) + x(b),
-                        yt = y(a) + y(b),
-                        zt = z(a) + z(b);
-                    var dt = (b - a) / 1000000;
+                    var xt = x(inf) + x(sup),
+                        yt = y(inf) + y(sup),
+                        zt = z(inf) + z(sup);
+                    var dt = (sup - inf) / 1000000;
                     for(var i = 1; i < 1000000; i++) {
-                        xt += i % 2 === 0 ? 2 * x(a + i * dt) : 4 * x(a + i * dt);
-                        yt += i % 2 === 0 ? 2 * y(a + i * dt) : 4 * y(a + i * dt);
-                        zt += i % 2 === 0 ? 2 * z(a + i * dt) : 4 * z(a + i * dt);
+                        xt += i % 2 === 0 ? 2 * x(inf + i * dt) : 4 * x(inf + i * dt);
+                        yt += i % 2 === 0 ? 2 * y(inf + i * dt) : 4 * y(inf + i * dt);
+                        zt += i % 2 === 0 ? 2 * z(inf + i * dt) : 4 * z(inf + i * dt);
                     }
                     return Chalkboard.vec3.new((xt * dt) / 3, (yt * dt) / 3, (zt * dt) / 3);
                 }
             } else {
-                return "TypeError: Parameter \"func\" must be of type \"expl\", \"pola\", or \"curv\".";
+                return "TypeError: Parameter \"func\" must be of type \"expl\", \"inve\", \"pola\", or \"curv\".";
             }
         },
-        fxydxdy: function(func, a, b, c, d) {
+        fxydxdy: function(func, xinf, xsup, yinf, ysup) {
             if(func.type === "mult") {
                 var f = Chalkboard.real.parse("(x, y) => " + func.definition);
                 var result = 0;
-                var dx = (b - a) / 10000,
-                    dy = (d - c) / 10000;
-                for(var x = a; x <= b; x += dx) {
-                    for(var y = c; y <= d; y += dy) {
+                var dx = (xsup - xinf) / 10000,
+                    dy = (ysup - yinf) / 10000;
+                for(var x = xinf; x <= xsup; x += dx) {
+                    for(var y = yinf; y <= ysup; y += dy) {
                         result += f(x, y);
                     }
                 }
@@ -3256,29 +4279,29 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"mult\".";
             }
         },
-        fds: function(func, a, b, c, d) {
+        fds: function(func, tinf, tsup, sinf, ssup) {
             var result = 0;
             var drdt, drds;
             if(func.type === "curv") {
-                var dt = (b - a) / 10000;
+                var dt = (tsup - tinf) / 10000;
                 if(func.definition.length === 2) {
-                    for(var t = a; t <= b; t += dt) {
+                    for(var t = tinf; t <= tsup; t += dt) {
                         drdt = Chalkboard.calc.dfdx(func, t);
                         result += Chalkboard.vec2.mag(drdt);
                     }
                     return result * dt;
                 } else if(func.definition.length === 3) {
-                    for(var t = a; t <= b; t += dt) {
+                    for(var t = tinf; t <= tsup; t += dt) {
                         drdt = Chalkboard.calc.dfdx(func, t);
                         result += Chalkboard.vec3.mag(drdt);
                     }
                     return result * dt;
                 }
             } else if(func.type === "surf") {
-                var dt = (b - a) / 100,
-                    ds = (d - c) / 100;
-                for(var s = c; s <= d; s += ds) {
-                    for(var t = a; t <= b; t += dt) {
+                var dt = (tsup - tinf) / 100,
+                    ds = (ssup - sinf) / 100;
+                for(var s = sinf; s <= ssup; s += ds) {
+                    for(var t = tinf; t <= tsup; t += dt) {
                         drds = Chalkboard.matr.toVector(Chalkboard.calc.grad(func, Chalkboard.vec2.new(s, t)), "vec3", "col", 1);
                         drdt = Chalkboard.matr.toVector(Chalkboard.calc.grad(func, Chalkboard.vec2.new(s, t)), "vec3", "col", 2);
                         result += Chalkboard.vec3.mag(Chalkboard.vec3.cross(drds, drdt));
@@ -3289,22 +4312,22 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"curv\" or \"surf\".";
             }
         },
-        frds: function(funcORvecfield, func, a, b) {
+        frds: function(funcORvecfield, func, inf, sup) {
             if(func.type === "curv") {
                 var result = 0;
-                var dt = (b - a) / 10000;
+                var dt = (sup - inf) / 10000;
                 if(funcORvecfield.type === "mult") {
-                    for(var t = a; t <= b; t += dt) {
-                        result += Chalkboard.real.val(funcORvecfield, Chalkboard.vec2.toArray(Chalkboard.real.val(func, t))) * Chalkboard.vec2.mag(Chalkboard.calc.dfdx(func, t));
+                    for(var t = inf; t <= sup; t += dt) {
+                        result += Chalkboard.real.val(funcORvecfield, Chalkboard.real.val(func, t)) * Chalkboard.vec2.mag(Chalkboard.calc.dfdx(func, t));
                     }
                     return result * dt;
                 } else if(funcORvecfield.type === "vec2field") {
-                    for(var t = a; t <= b; t += dt) {
+                    for(var t = inf; t <= sup; t += dt) {
                         result += Chalkboard.vec2.dot(Chalkboard.vec2.fromField(funcORvecfield, Chalkboard.real.val(func, t)), Chalkboard.calc.dfdx(func, t));
                     }
                     return result * dt;
                 } else if(funcORvecfield.type === "vec3field") {
-                    for(var t = a; t <= b; t += dt) {
+                    for(var t = inf; t <= sup; t += dt) {
                         result += Chalkboard.vec3.dot(Chalkboard.vec3.fromField(funcORvecfield, Chalkboard.real.val(func, t)), Chalkboard.calc.dfdx(func, t));
                     }
                     return result * dt;
@@ -3315,29 +4338,29 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"curv\".";
             }
         },
-        fnds: function(vecfield, func, a, b, c, d) {
+        fnds: function(vecfield, func, tinf, tsup, sinf, ssup) {
             var result = 0;
             var drdt, drds;
             if(func.type === "curv") {
-                var dt = (b - a) / 10000;
+                var dt = (tsup - tinf) / 10000;
                 if(func.definition.length === 2) {
-                    for(var t = a; t <= b; t += dt) {
+                    for(var t = tinf; t <= tsup; t += dt) {
                         drdt = Chalkboard.calc.dfdx(func, t);
                         result += Chalkboard.vec2.dot(Chalkboard.vec2.fromField(vecfield, Chalkboard.real.val(func, t)), Chalkboard.vec2.new(-drdt.y, drdt.x)) * Chalkboard.vec2.mag(drdt);
                     }
                     return result * dt;
                 } else if(func.definition.length === 3) {
-                    for(var t = a; t <= b; t += dt) {
+                    for(var t = tinf; t <= tsup; t += dt) {
                         drdt = Chalkboard.calc.dfdx(func, t);
                         result += Chalkboard.vec3.dot(Chalkboard.vec3.fromField(vecfield, Chalkboard.real.val(func, t)), Chalkboard.calc.normal(func, t)) * Chalkboard.vec3.mag(drdt);
                     }
                     return result * dt;
                 }
             } else if(func.type === "surf") {
-                var dt = (b - a) / 100,
-                    ds = (d - c) / 100;
-                for(var s = c; s <= d; s += ds) {
-                    for(var t = a; t <= b; t += dt) {
+                var dt = (tsup - tinf) / 100,
+                    ds = (ssup - sinf) / 100;
+                for(var s = sinf; s <= ssup; s += ds) {
+                    for(var t = tinf; t <= tsup; t += dt) {
                         drds = Chalkboard.matr.toVector(Chalkboard.calc.grad(func, Chalkboard.vec2.new(s, t)), "vec3", "col", 1);
                         drdt = Chalkboard.matr.toVector(Chalkboard.calc.grad(func, Chalkboard.vec2.new(s, t)), "vec3", "col", 2);
                         result += Chalkboard.vec3.scalarTriple(Chalkboard.vec3.fromField(vecfield, Chalkboard.real.val(func, Chalkboard.vec2.new(s, t))), drds, drdt);
@@ -3348,12 +4371,12 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"curv\" or \"surf\".";
             }
         },
-        fzdz: function(func_1, func_2, a, b) {
+        fzdz: function(func_1, func_2, inf, sup) {
             if(func_1.type === "comp") {
                 if(func_2.type === "curv") {
                     var result = Chalkboard.comp.new(0, 0);
-                    var dt = (b - a) / 10000;
-                    for(var t = a; t <= b; t += dt) {
+                    var dt = (sup - inf) / 10000;
+                    for(var t = inf; t <= sup; t += dt) {
                         var fz = Chalkboard.comp.val(func_1, Chalkboard.vec2.toComplex(Chalkboard.real.val(func_2, t)));
                         var rt = Chalkboard.calc.dfdx(func_2, t);
                         result = Chalkboard.comp.add(result, Chalkboard.comp.new((fz.a * rt.x) - (fz.b * rt.y), (fz.b * rt.x) + (fz.a * rt.y)));