@zushah/chalkboard 1.6.0 → 1.7.0

package/src/ChalkboardProcessing.js

@@ -1,6 +1,6 @@
 /*
     The Chalkboard Library
-    Version 1.6.0 released 12/25/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/
 
@@ -11,7 +11,7 @@
 */
 var Chalkboard = {
     README: function() {
-        console.log("The Chalkboard Library\nVersion 1.6.0 released 12/25/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\nRepository ===> https://www.github.com/Zushah/Chalkboard\nWebsite ===> https://zushah.github.io/Chalkboard/home.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,6 +45,8 @@ var Chalkboard = {
         exponent = exponent || 1;
         return Math.pow(Math.pow(10, 1 / Math.log(10)), exponent);
     },
+    CONTEXT: "ctx",
+    PARSEPREFIX: "",
     numb: {
         random: function(inf, sup) {
             if(inf === undefined) {
@@ -259,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];
@@ -326,9 +340,8 @@ var Chalkboard = {
                 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") {
@@ -510,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") {
@@ -618,9 +637,21 @@ var Chalkboard = {
             return Chalkboard.comp.new(comp.a, -comp.b);
         },
         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) {
@@ -630,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) {
@@ -660,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));
@@ -702,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) {
@@ -714,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));
         },
@@ -766,42 +867,39 @@ var Chalkboard = {
         }
     },
     plot: {
-        CONTEXT: "ctx",
         xyplane: function(config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+            }).size /= 100;
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             stroke(config.stroke);
             strokeWeight(config.strokeWeight / 4);
-            for(var i = Math.floor(-config.origin[0] / config.size); i <= (width - config.origin[0]) / config.size; i++) {
-                line(i / config.size, -config.origin[1], i / config.size, width - config.origin[1]);
+            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.origin[1] / config.size); i <= (width - config.origin[1]) / config.size; i++) {
-                line(-config.origin[0], i / config.size, width - config.origin[0], i / config.size);
+            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.origin[0], 0, width - config.origin[0], 0);
-            line(0, -config.origin[1], 0, width - config.origin[1]);
+            line(-config.x, 0, width - config.x, 0);
+            line(0, -config.y, 0, width - config.y);
             popMatrix();
         },
         rOplane: function(config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+            }).size /= 100;
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             stroke(config.stroke);
             strokeWeight(config.strokeWeight / 4);
@@ -809,23 +907,22 @@ var Chalkboard = {
                 ellipse(0, 0, 2 * i / config.size, 2 * i / config.size);
             }
             strokeWeight(config.strokeWeight);
-            line(-config.origin[0], 0, width - config.origin[0], 0);
-            line(0, -config.origin[1], 0, width - config.origin[1]);
+            line(-config.x, 0, width - config.x, 0);
+            line(0, -config.y, 0, width - config.y);
             popMatrix();
         },
         function: function(func, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || (func.type === "comp" ? [[-10, 10], [-10, 10]] : [-10, 10]),
-                origin: config.origin || [width / 2, height / 2],
-                strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+                strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || (func.type === "comp" ? [[-10, 10], [-10, 10]] : [-10, 10])
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -883,17 +980,16 @@ var Chalkboard = {
             return data;
         },
         barplot: function(arr, bins, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
-                stroke: config.stroke || color(0),
                 fill: config.fill || color(255),
-                origin: config.origin || [width / 2, height / 2],
+                stroke: config.stroke || color(0),
                 strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+            }).size /= 100;
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
             fill(config.fill);
@@ -920,16 +1016,15 @@ var Chalkboard = {
             return bars;
         },
         lineplot: function(arr, bins, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+            }).size /= 100;
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -956,17 +1051,16 @@ var Chalkboard = {
             return verts;
         },
         scatterplot: function(arr1, arr2, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 5
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
             if(arr1.length === arr2.length) {
@@ -979,18 +1073,17 @@ var Chalkboard = {
             return data;
         },
         comp: function(comp, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 5
-            };
-            config.size /= 100;
+            }).size /= 100;
             stroke(config.stroke);
             strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             point(comp.a / config.size, -comp.b / config.size);
             popMatrix();
             noStroke();
@@ -998,38 +1091,36 @@ var Chalkboard = {
             return [[comp.a], [comp.b]];
         },
         vec2: function(vec2, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
-                strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+                strokeWeight: config.strokeWeight || 5
+            }).size /= 100;
             stroke(config.stroke);
             strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            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, config) {
-            config = config || {};
-            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]],
-                origin: config.origin || [width / 2, height / 2],
-                strokeWeight: config.strokeWeight || 2,
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             stroke(config.stroke);
             strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            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));
@@ -1041,65 +1132,55 @@ var Chalkboard = {
             return data;
         },
         vec3: function(vec3, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
-                strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
+                strokeWeight: config.strokeWeight || 5
+            }).size /= 100;
             stroke(config.stroke);
             strokeWeight(config.strokeWeight);
             pushMatrix();
-            translate(config.origin[0], config.origin[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, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                origin: config.origin || [width / 2, height / 2],
-                strokeWeight: config.strokeWeight || 2
-            };
-            config.size /= 100;
-            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, {origin: [config.origin[0], config.origin[1] + (i / config.size) * matr[1][1]], strokeWeight: config.strokeWeight / 4});
-                Chalkboard.vec2.plot(plotnegx, {origin: [config.origin[0], config.origin[1] + (i / config.size) * matr[1][1]], strokeWeight: config.strokeWeight / 4});
-                Chalkboard.vec2.plot(plotposy, {origin: [config.origin[0] + (i / config.size) * matr[0][0], config.origin[1]], strokeWeight: config.strokeWeight / 4});
-                Chalkboard.vec2.plot(plotnegy, {origin: [config.origin[0] + (i / config.size) * matr[0][0], config.origin[1]], strokeWeight: config.strokeWeight / 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, config);
-            Chalkboard.vec2.plot(plotnegaxisx, config);
-            Chalkboard.vec2.plot(plotposaxisy, config);
-            Chalkboard.vec2.plot(plotnegaxisy, config);
+                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, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1118,19 +1199,18 @@ var Chalkboard = {
             return data;
         },
         d2fdx2: function(func, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1149,19 +1229,18 @@ var Chalkboard = {
             return data;
         },
         fxdx: function(func, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1180,19 +1259,18 @@ var Chalkboard = {
             return data;
         },
         convolution: function(func_1, func_2, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1206,19 +1284,18 @@ var Chalkboard = {
             return data;
         },
         correlation: function(func_1, func_2, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1232,19 +1309,18 @@ var Chalkboard = {
             return data;
         },
         autocorrelation: function(func, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1258,19 +1334,18 @@ var Chalkboard = {
             return data;
         },
         Taylor: function(func, n, a, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1284,19 +1359,18 @@ var Chalkboard = {
             return data;
         },
         Laplace: function(func, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1317,19 +1391,18 @@ var Chalkboard = {
             return data;
         },
         Fourier: function(func, config) {
-            config = config || {};
-            config = {
+            (config = {
+                x: (config = config || {}).x || width / 2,
+                y: config.y || height / 2,
                 size: config.size || 1,
                 stroke: config.stroke || color(0),
-                domain: config.domain || [-10, 10],
-                origin: config.origin || [width / 2, height / 2],
                 strokeWeight: config.strokeWeight || 2,
+                domain: config.domain || [-10, 10],
                 res: config.res || 25
-            };
-            config.size /= 100;
+            }).size /= 100;
             var data = [];
             pushMatrix();
-            translate(config.origin[0], config.origin[1]);
+            translate(config.x, config.y);
             noFill();
             strokeWeight(config.strokeWeight);
             stroke(config.stroke);
@@ -1750,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]) {
@@ -1771,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) {
@@ -1827,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) {
@@ -1859,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) {
@@ -2182,13 +2255,14 @@ var Chalkboard = {
                 return "TypeError: Parameter \"type\" must be either \"linear\", \"polynomial\", \"power\", \"exponential\", or \"logarithmic\".";
             }
         },
-        toVector: function(arr, type) {
+        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\".";
             }
@@ -2209,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++) {
@@ -2231,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));
         },
@@ -2375,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));
         },
@@ -2526,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));
         },
@@ -2660,8 +2749,23 @@ var Chalkboard = {
     },
     matr: {
         new: function(matrix) {
-            matrix = Array.from(arguments);
-            return matrix;
+            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;
@@ -2669,6 +2773,21 @@ var Chalkboard = {
         cols: function(matr) {
             return matr[0].length;
         },
+        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") {
@@ -2698,6 +2817,9 @@ var Chalkboard = {
             }
         },
         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 < rows; i++) {
@@ -2712,6 +2834,9 @@ var Chalkboard = {
             }
         },
         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++) {
@@ -2737,7 +2862,25 @@ var Chalkboard = {
                 return undefined;
             }
         },
-        random: function(rows, cols, inf, sup) {
+        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 < rows; i++) {
@@ -2751,6 +2894,73 @@ 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 row.slice(0, col - 1).concat(row.slice(col));
@@ -2873,7 +3083,7 @@ var Chalkboard = {
         LUdecomp: function(matr) {
             if(Chalkboard.matr.rows(matr) === Chalkboard.matr.cols(matr)) {
                 var L = Chalkboard.matr.identity(Chalkboard.matr.rows(matr)),
-                    U = Chalkboard.matr.zero(Chalkboard.matr.empty(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;
@@ -2896,51 +3106,51 @@ var Chalkboard = {
             }
         },
         QRdecomp: function(matr) {
-            if(Chalkboard.matr.rows(matr) === Chalkboard.matr.cols(matr)) {
-                var Q = Chalkboard.matr.zero(Chalkboard.matr.empty(Chalkboard.matr.rows(matr))),
-                    R = Chalkboard.matr.zero(Chalkboard.matr.empty(Chalkboard.matr.rows(matr)));
-                var dot = function(v1, v2) {
-                    var result = 0;
-                    for(var i = 0; i < v1.length; i++) {
-                        result += v1[i] * v2[i];
+            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];
                     }
-                    return result;
-                }
-                var mag = function(v) {
-                    var result = 0;
+                    dot *= 2;
                     for(var i = 0; i < v.length; i++) {
-                        result += v[i] * v[i];
+                        R[i + j][k] -= dot * v[i];
                     }
-                    return Math.sqrt(result);
                 }
-                for(var j = 0; j < Chalkboard.matr.rows(matr); j++) {
-                    var v = matr.map(function(row) {
-                        return row[j];
-                    });
-                    for(var i = 0; i < j; i++) {
-                        var q = Q.map(function(row) {
-                            return row[i];
-                        });
-                        var coeff = dot(v, q) / (mag(q) * mag(q));
-                        v = v.map(function(e, index) {
-                            return e - coeff * q[index];
-                        });
-                    }
-                    for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
-                        Q[i][j] = v[i] / mag(v);
+                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];
                     }
-                    for(var i = 0; i < Chalkboard.matr.rows(matr); i++) {
-                        R[j][i] = i < j ? 0 : matr.map(function(row) {
-                            return row[i];
-                        }).reduce(function(a, v, index) {
-                            return a + v * Q[index][j];
-                        }, 0);
+                    dot *= 2;
+                    for(var i = 0; i < v.length; i++) {
+                        Q[k][i + j] -= dot * v[i];
                     }
                 }
-                return {Q: Q, R: R};
-            } else {
-                return undefined;
             }
+            return {Q: Q, R: R};
         },
         zero: function(matr) {
             var result = Chalkboard.matr.new();
@@ -3042,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();
@@ -3087,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) {
@@ -3106,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++) {
@@ -3189,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++) {
@@ -3198,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++) {
@@ -3209,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: {
@@ -3571,7 +4216,7 @@ var Chalkboard = {
                 return "TypeError: Parameter \"func\" must be of type \"comp\".";
             }
         },
-        fxdx: function(func, a, b) {
+        fxdx: function(func, inf, sup) {
             if(func.type === "expl" || func.type === "inve" || func.type === "pola") {
                 var f;
                 if(func.type === "expl") {
@@ -3581,36 +4226,36 @@ var Chalkboard = {
                 } 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);
                 }
@@ -3618,14 +4263,14 @@ var Chalkboard = {
                 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);
                     }
                 }
@@ -3634,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));
@@ -3667,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;
@@ -3693,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);
@@ -3726,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)));