npm - @zushah/chalkboard - Versions diffs - 2.1.0 → 2.2.0 - Mend

@zushah/chalkboard 2.1.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -1,6 +1,48 @@
 # Chalkboard changelog
 All notable changes of every update of the Chalkboard library are recorded in this file.
+## [v2.2.0 Galois](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.2.0) - 04/07/2024
+The twelfth release of the Chalkboard library.
+Commits: [`v2.1.0...v2.2.0`](https://www.github.com/Zushah/Chalkboard/compare/v2.1.0...v2.2.0)
+- Added abstract algebra functionalities with the new `abal` category containing 76 commands, so only a few notable ones are mentioned below
+- Added `abal.set` which defines a mathematical set, as well as `abal.Z` which defines the set of integers or the set of integers modulo n, `abal.Q` which defines the set of rational numbers, `abal.R` which defines the set of real numbers, and `abal.C` which defines the set of complex numbers or the set of nth roots of unity
+- Added `abal.union`, `abal.intersection`, `abal.complement`, `abal.difference`, `abal.symmetricDifference`, `abal.Cartesian`, `abal.powerSet`, `abal.isSubset`, and `abal.isSuperset` which respectively calculate the union of two sets, the intersection of two sets, the complement of a set, the difference of two sets, the symmetric difference of two sets, the Cartesian product of two sets, the power set of a set, whether or not a set is a subset of another set, and whether or not a set is a superset of another set
+- Added `abal.group`, `abal.ring`, and `abal.field` which define the algebraic structures known as groups, rings, and fields
+- Added `abal.direct` which calculates the direct sum or direct product of two algebraic structures
+- Added `abal.cosets` and `abal.quotient` which respectively calculate the cosets or quotient structure of two inputted algebraic structures
+- Added `abal.homomorphism`, `abal.endomorphism`, `abal.isomorphism`, `abal.automorphism`, `abal.idmorphism`, and `abal.invmorphism` which define various types of morphisms between one or two algebraic structures
+- Added `abal.compose` which calculates the composition morphism of two given morphisms
+- Added `abal.image`, `abal.preimage`, and `abal.kernel` which respectively calculate the image, preimage, or kernel of a given morphism
+- Added `abal.cardinality` which calculates the cardinality of a set or the set of a structure
+- Added `abal.isEqual` which checks if two sets, structures, or morphisms are equal
+- Added `abal.copy` which creates a copy of a set, structure, or morphism
+- Added `abal.toArray`, `abal.toMatrix`, `abal.toObject`, `abal.toString`, `abal.toTensor`, and `abal.toVector` which convert sets or structures to arrays, matricies, objects, strings, tensors, or vectors, and `abal.print` prints a set or structure in the console
+- Added `stat.Bayes` which calculates the posterior probability given prior probabilities
+- Added `stat.expected` which calculates the expected value of an array given the probabilities of its elements
+- Added `stat.normal` and `stat.inormal` which respectively calculate the values of the standard normal distribution and cumulative distribution function of the standard normal distribution
+- Added `stat.resampling` which resamples an array either by the bootstrap or jackknife methods
+- Added `stat.interpolate` which linearly or quadratically interpolates missing elements in an array
+- Added `stat.absolute` which takes the absolute value of the elements of an array, `stat.negate` which negates the elements of an array, `stat.add` which adds the elements of two arrays, `stat.sub` which subtracts the elements of two arrays, `stat.dot` which calculates the dot product of two arrays, `stat.scl` which scales the elements of an array by a given number, `stat.sum` which calculates the sum of the elements of an array, `stat.mul` which calculates the product of the elements of an array, and `stat.reverse` which reverses the elements of an array
+- Added `stat.cumsum`, `stat.cummul`, `stat.cummax`, and `stat.cummin` which respectively calculate the cumululative sum, product, maximum, and minimum of an array
+- Added `stat.meanMoving` and `stat.meanWeighted` which respectively calculate the moving and weighted averages of an array
+- Added `stat.covariance` which calculates the covariance of two arrays and `stat.correlationCoefficient` which calculates the correlation coefficient of two arrays
+- Added `stat.interquartileRange` which calculates the interquartile range of an array
+- Added `stat.zscored` which standardizes the elements of an array by their mean and standard deviation
+- Added `stat.pad` which pads an array by a given element to a given length
+- Added `stat.unique` which deduplicates an array of numbers, arrays, objects, etc.
+- Added `matr.toSet`, `stat.toSet` and `tens.toSet` to convert matrices, arrays, and tensors to sets
+- Added `numb.toFraction` to convert decimals to fractions and `numb.isRational` to check if a number is rational
+- Changed `APPLY` to work for sets and algebraic structures introduced in the `abal` category
+- Changed `stat.change` and `stat.chiSquared` to be written more succinctly
+- Changed `stat.confidenceInterval` to use an adjustable confidence level
+- Changed `stat.toMatrix` to be able to use only one parameter for the size of the matrix instead of requiring two
+- Changed `matr.rotator` to be faster
+- Changed `comp.toString` to output 1, i, -1, or -i when 1+0i, 0+1i, -1+0i, or 0-1i are inputted
+- Fixed `comp.div` which was broken for who knows how long because it was using the wrong formula for some reason
+- Fixed `matr.resize` which was always returning zero matrices
+- Fixed `matr.zero` which was unnecessarily using erasing operations
+- Fixed `tens.init` which had an expression assigned to itself
 ## [v2.1.0 Seki](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.1.0) - 01/22/2024
 The eleventh release of the Chalkboard library.
 Commits: [`v2.0.0...v2.1.0`](https://www.github.com/Zushah/Chalkboard/compare/v2.0.0...v2.1.0)
@@ -42,7 +84,7 @@ Commits: [`v1.7.0...v2.0.0`](https://www.github.com/Zushah/Chalkboard/compare/v1
 - Changed `real.function` to be renamed as `real.define`, `comp.function` to be renamed as `comp.define`, and `plot.function` to be renamed as `plot.definition`
 - Changed `LOGO` to draw the logo as a circle instead of a square
 - Changed `matr.mulvec` to be renamed as `matr.mulVector`
-- Fixed `matr.mulVector`` which didn't work when the rows of the matrix equaled the dimension of the vector
+- Fixed `matr.mulVector` which didn't work when the rows of the matrix equaled the dimension of the vector
 - Discontinued the Processsing.js edition of the library, meaning it will no longer be updated and it will only be available on the Khan Academy release (it will no longer be available on GitHub)
 ## [v1.7.0 Descartes](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.7.0) - 01/01/2024

package/LICENSE.md CHANGED Viewed

@@ -1,6 +1,6 @@
 MIT License
-Copyright (c) 2023-2024 Zushah
+Copyright (c) 2023-2025 Zushah
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md CHANGED Viewed

@@ -1,11 +1,11 @@
 <p align="center"><a href="https://www.github.com/Zushah/Chalkboard"><img src="https://raw.githubusercontent.com/Zushah/Chalkboard/main/assets/Chalkboard-logo.png" width="50%"></a></p>
 <p align="center">
-    <a href="https://www.github.com/Zushah/Chalkboard/releases/tag/v2.1.0"><img src="https://img.shields.io/badge/release-v2.1.0_Seki-blueviolet?logo=github&logoColor=white" alt="Latest release"></a>
+    <a href="https://www.github.com/Zushah/Chalkboard/releases/tag/v2.2.0"><img src="https://img.shields.io/badge/release-v2.2.0_Galois-blueviolet?logo=github&logoColor=white" alt="Latest release"></a>
     <a href="https://www.codefactor.io/repository/github/zushah/chalkboard"><img src="https://img.shields.io/codefactor/grade/github/Zushah/Chalkboard?color=blue&logo=codefactor&logoColor=white" alt="CodeFactor grade"></a>
-    <a href="https://bundlephobia.com/package/@zushah/chalkboard@2.1.0"><img src="https://img.shields.io/bundlephobia/min/%40zushah/chalkboard?color=darkgreen&logo=files&logoColor=white" alt="Minified size"></a>
+    <a href="https://bundlephobia.com/package/@zushah/chalkboard@2.2.0"><img src="https://img.shields.io/bundlephobia/min/%40zushah/chalkboard?color=darkgreen&logo=files&logoColor=white" alt="Minified size"></a>
     <a href="https://www.npmjs.com/package/@zushah/chalkboard"><img src="https://img.shields.io/npm/dm/%40zushah/chalkboard?logo=npm&logoColor=white" alt="npm downloads"></a>
     <a href="https://www.github.com/Zushah/Chalkboard/blob/main/LICENSE.md"><img src="https://img.shields.io/github/license/Zushah/Chalkboard?color=yellow&logo=opensourceinitiative&logoColor=white" alt="MIT License"></a>
-    <a href="https://en.wikipedia.org/wiki/TypeScript"><img src="https://img.shields.io/github/languages/top/Zushah/Chalkboard?color=orange&logo=typescript&logoColor=white" alt="Written in TypeScript"></a>
+    <a href="https://www.github.com/microsoft/TypeScript"><img src="https://img.shields.io/github/languages/top/Zushah/Chalkboard?color=blue&logo=typescript&logoColor=white" alt="Written in TypeScript"></a>
     <a href="https://www.jsdelivr.com/package/gh/Zushah/Chalkboard"><img src="https://img.shields.io/jsdelivr/gh/hm/Zushah/Chalkboard?color=crimson&logo=jsdelivr&logoColor=white" alt="jsDelivr requests"></a>
     <br>
     <a href="https://zushah.github.io/Chalkboard">https://zushah.github.io/Chalkboard</a>
@@ -23,23 +23,24 @@
 </ol>
 # About
-The Chalkboard library is a JavaScript namespace that provides a plethora of both practical and abstract mathematical functionalities for its user. It was developed by [Zushah](https://www.github.com/Zushah) during 2022 and 2023 and then [released](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.0.0) on November 6, 2023. As per the latest release of [v2.1.0 Seki](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.1.0), Chalkboard has 455 different commands. The library is available for regular JavaScript on both the client-side and the server-side as well as [Proccesing.js](https://www.processing.org/) (fully compatible with [Khan Academy](https://www.khanacademy.org/cs/chalkboard/6708642430369792)). Chalkboard's website can be visited [here](https://zushah.github.io/Chalkboard).
+The Chalkboard library is a JavaScript namespace that provides a plethora of both practical and abstract mathematical functionalities for its user. It was developed by [Zushah](https://www.github.com/Zushah) during 2022 and 2023 and then [released](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.0.0) on November 6, 2023. As per the latest release of [v2.2.0 Galois](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.2.0), Chalkboard has 564 unique commands. The library is available for regular JavaScript on both the client-side and the server-side as well as [Proccesing.js](https://www.processing.org/) (fully compatible with [Khan Academy](https://www.khanacademy.org/cs/chalkboard/6708642430369792)). Chalkboard's website can be visited [here](https://zushah.github.io/Chalkboard).
 # Installation
 If your JavaScript project is being run on the client-side within a webpage, you can install Chalkboard with this HTML tag:
 ```html
-<script src="https://cdn.jsdelivr.net/gh/Zushah/Chalkboard@2.1.0/dist/Chalkboard.min.js"></script>
+<script src="https://cdn.jsdelivr.net/gh/Zushah/Chalkboard@2.2.0/dist/Chalkboard.min.js"></script>
 ```
 If your JavaScript project is being run on the server-side within the [Node.js](https://nodejs.org/en) environment, you can install Chalkboard with this console command:
 ```bash
 npm install @zushah/chalkboard
 ```
-Alternatively, you can simply download the [latest release](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.1.0) and put the relevant files in your project's directory.
+Alternatively, you can simply download the [latest release](https://www.github.com/Zushah/Chalkboard/releases/tag/v2.2.0) and put the relevant files in your project's directory.
 Chalkboard can also be downloaded on [Khan Academy](https://www.khanacademy.org) from the code in the corresponding [release](https://www.khanacademy.org/cs/chalkboard/6708642430369792).
 # Documentation
-Chalkboard has twelve categories of commands:
+Chalkboard has thirteen categories of commands:
+- `abal` - Abstract algebra definitions, sets, operations, structures, and morphisms
 - `calc` - Single/multi-variable real/complex-valued calculus operations
 - `comp` - Complex number and complex function operations
 - `geom` - Geometric operations
@@ -64,11 +65,15 @@ There are also eight "global" commands and constants, which are:
 - `VERSION` - The installed version of Chalkboard
 - `VERSIONALIAS` - The alias of the installed version of Chalkboard
-Lastly, Chalkboard has seven data types (also known as Chalkboard objects):
+Lastly, Chalkboard has eleven data types (also known as Chalkboard objects):
 - `ChalkboardComplex` - Complex numbers
 - `ChalkboardFunction` - Mathematical functions
 - `ChalkboardMatrix` - Matrices
+- `ChalkboardMorphism` - Morphisms
 - `ChalkboardQuaternion` - Quaternions
+- `ChalkboardSet` - Sets
+- `ChalkboardStructure` - Algebraic structures
+- `ChalkboardStructureExtension` - Algebraic structure extensions
 - `ChalkboardTensor` - Tensors
 - `ChalkboardVector` - Vectors
 - `ChalkboardVectorField` - Vector fields
@@ -83,51 +88,49 @@ Chalkboard.category.command(parameters);
 Here is some code that shows off only a few features of Chalkboard:
 ```js
 const cb = Chalkboard; // Initialize in a browser
-// or
 const cb = require("@zushah/chalkboard"); // Initialize in Node with CommonJS
-// or
 import cb from "@zushah/chalkboard"; // Initiialize in Node with ES Modules
-let f = cb.real.define("Math.cos(2 * x)"); // f(x) = cos(2x)
-let dfdx = cb.calc.dfdx(f, 2); // Derivative of f at x = 0
-let fxdx = cb.calc.fxdx(f, 0, 2); // Antiderivative of f from x = 0 to x = 2
-let fourier = cb.calc.Fourier(f, 2); // Fourier transform of f at x = 2
+const f = cb.real.define("Math.cos(2 * x)"); // f(x) = cos(2x)
+const dfdx = cb.calc.dfdx(f, 2); // Derivative of f at x = 0
+const fxdx = cb.calc.fxdx(f, 0, 2); // Antiderivative of f from x = 0 to x = 2
+const fourier = cb.calc.Fourier(f, 2); // Fourier transform of f at x = 2
-let f = cb.vect.field("x", "y", "z"); // f(x, y, z) = (x, y, z)
-let r = cb.real.define(["Math.cos(s) * Math.cos(t)", "Math.sin(s) * Math.cos(t)", "Math.sin(t)"], "surf"); // r(s, t) = (cos(s)cos(t), sin(s)cos(t), sin(t))
-let fnds = cb.calc.fnds(f, r, cb.PI(-1/2), cb.PI(1/2), 0, cb.PI(2)); // Flux of the radial vector field through the unit sphere
+const f = cb.vect.field("x", "y", "z"); // f(x, y, z) = (x, y, z)
+const r = cb.real.define(["Math.cos(s) * Math.cos(t)", "Math.sin(s) * Math.cos(t)", "Math.sin(t)"], "surf"); // r(s, t) = (cos(s)cos(t), sin(s)cos(t), sin(t))
+const fnds = cb.calc.fnds(f, r, cb.PI(-1/2), cb.PI(1/2), 0, cb.PI(2)); // Flux of the radial vector field through the unit sphere
-let primes = cb.numb.primeArr(0, 100); // Array of prime numbers between 0 and 100
-let midPrime = cb.stat.median(primes); // Median number in the primes array
+const primes = cb.numb.primeArr(0, 100); // Array of prime numbers between 0 and 100
+const midPrime = cb.stat.median(primes); // Median number in the primes array
 cb.plot.barplot(primes, cb.stat.array(0, 100, 11), {size: 5, strokeStyle: "black", fillStyle: "blue"}); // Barplot of the primes array with a bin size of 10, a scale of 2, a stroke color of black, and a fill color of blue
-let z = cb.comp.init(1, 1); // z = 1 + i
-let zsqsqrt = cb.comp.sqrt(cb.comp.sq(z)); // The square root of z squared equals z
-let f = cb.comp.define("a*a - b*b + 1", "2*a*b"); // f(z) = z^2 + 1
+const z = cb.comp.init(1, 1); // z = 1 + i
+const zsqsqrt = cb.comp.sqrt(cb.comp.sq(z)); // The square root of z squared equals z
+const f = cb.comp.define("a*a - b*b + 1", "2*a*b"); // f(z) = z^2 + 1
 cb.plot.definition(f); // Plots the domain coloring of f
-let r = cb.real.define(["Math.cos(t)", "Math.sin(t)"], "curv"); // r(t) = (cos(t), sin(t))
+const r = cb.real.define(["Math.cos(t)", "Math.sin(t)"], "curv"); // r(t) = (cos(t), sin(t))
 cb.plot.xyplane({size: 2}); // Draws the Cartesian coordinate plane scaled by 2
 cb.plot.definition(r, {size: 2, strokeStyle: "rgb(255, 100, 100)", domain: [0, cb.PI(2)]}); // Plots r(t) scaled by 2 colored light red from t = 0 to t = π/2
-let a = cb.vect.init(1, 2, 3); // Vector a = (1, 2, 3)
-let b = cb.vect.init(4, 5, 6); // Vector b = (4, 5, 6)
-let c = cb.vect.init(7, 8, 9); // Vector c = (7, 8, 9)
-let axbxc = cb.vect.vectorTriple(a, b, c); // Triple cross product between a, b, and c
+const a = cb.vect.init(1, 2, 3); // Vector a = (1, 2, 3)
+const b = cb.vect.init(4, 5, 6); // Vector b = (4, 5, 6)
+const c = cb.vect.init(7, 8, 9); // Vector c = (7, 8, 9)
+const axbxc = cb.vect.vectorTriple(a, b, c); // Triple cross product between a, b, and c
 cb.vect.print(axbxc); // Prints axbxc in the console
-let m = cb.matr.init( // m is a 5x5 matrix
+const m = cb.matr.init( // m is a 5x5 matrix
     [0, 1, 1, 1, 1],
     [1, 0, 1, 1, 1],
     [1, 1, 0, 1, 1],
     [1, 1, 1, 0, 1],
     [1, 1, 1, 1, 0]
 );
-let mi = cb.matr.invert(m); // mi is the inverse of m
-let mmi = cb.matr.mul(m, mi); // mmi is the product of m and mi
+const mi = cb.matr.invert(m); // mi is the inverse of m
+const mmi = cb.matr.mul(m, mi); // mmi is the product of m and mi
 cb.matr.print(mmi); // Prints mmi in the console
-let t = cb.tens.init( // t is a 2x2x2 rank-3 tensor
+const t = cb.tens.init( // t is a 2x2x2 rank-3 tensor
     [
         [1, 2],
         [3, 4]
@@ -137,21 +140,23 @@ let t = cb.tens.init( // t is a 2x2x2 rank-3 tensor
         [7, 8]
     ]
 );
-let tt = cb.tens.mul(t, t); // tt is a 2x2x2x2x2x2 rank-6 tensor
-let ttm = cb.tens.resize(tt, 8, 8); // ttm is an 8x8 matrix (or rank-2 tensor)
+const tt = cb.tens.mul(t, t); // tt is a 2x2x2x2x2x2 rank-6 tensor
+const ttm = cb.tens.resize(tt, 8, 8); // ttm is an 8x8 matrix (or rank-2 tensor)
 cb.tens.print(tt); // Prints tt in the console just to see what it looks like for fun
+const factorialt = cb.APPLY(t, (x) => cb.numb.factorial(x)); // Calculates the factorial of each element of t
-// Calculates the factorial of each element of t
-let factorialt = cb.APPLY(t, (x) => {
-    return cb.numb.factorial(x);
-});
+const Z4 = cb.abal.Z(4); // The set of integers modulo 4 is the set {0, 1, 2, 3}
+const C4 = cb.abal.C(4); // The set of fourth roots of unity is the set {1, i, -1, -i}
+const G = cb.abal.group(Z4, (a, b) => (a + b) % 4); // The group G is the set Z4 with mod 4 addition
+const H = cb.abal.group(C4, (z, w) => cb.comp.mul(z, w)); // The group H is the set C4 with complex multiplication
+const F = cb.abal.isomorphism(G, H, (n) => cb.comp.round(cb.comp.pow(cb.comp.init(0, 1), n))); // The isomorphism F: G → H is defined by F(n) = i^n for all n in Z4
 ```
-More examples that are more interesting can be seen [here](https://zushah.github.io/Chalkboard/examples/index.html) with their source code [here](https://www.github.com/Zushah/Chalkboard/tree/main/examples).
+Several examples that are rather interesting can be seen [here](https://zushah.github.io/Chalkboard/examples/index.html), and their source code is [here](https://www.github.com/Zushah/Chalkboard/tree/main/examples).
 # Contributing
 <ol>
     <li>Fork Chalkboard's GitHub repository. Make sure the fork is based on the main branch.</li>
-    <li>Clone the repository, download the dependencies with `npm install`, and then make your contributions to your fork.</li>
+    <li>Clone the repository, download the dev dependencies with `npm install`, and then make your contributions to your fork.</li>
     <li>When you're done, commit the changes to your fork with a detailed description.</li>
     <li>Open a pull request. It will be reviewed soon and then merged to the main branch.</li>
 </ol>
@@ -163,9 +168,9 @@ The changelog can be read [here](https://www.github.com/Zushah/Chalkboard/blob/m
 The Chalkboard library is available under the [MIT License](https://www.github.com/Zushah/Chalkboard/blob/main/LICENSE.md).
 # Acknowledgments
-Thanks to [@bhavjitChauhan](https://www.github.com/bhavjitChauhan) for his [contribution](https://www.github.com/Zushah/Chalkboard/pull/1) to [v1.3.0 Heaviside](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.3.0).\
-Thanks to [@gyang0](https://www.github.com/gyang0) for his [contribution](https://www.github.com/Zushah/zushah.github.io/pull/1) to the [documentation](https://www.github.com/Zushah/zushah.github.io/tree/main/Chalkboard).\
-Thanks to [@JentGent](https://www.github.com/JentGent) for his [implementation](https://www.github.com/JentGent/linalg/blob/main/linalg.js#L519) for calculating QR decomposition which was [adapted](https://www.github.com/Zushah/Chalkboard/commit/1dce0dbac82b38f9a550dd496bc878c402a92442) into [v1.7.0 Descartes](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.7.0).
+Thanks to [@bhavjitChauhan](https://www.github.com/bhavjitChauhan) for his contribution ([here](https://www.github.com/Zushah/Chalkboard/pull/1)) to [v1.3.0 Heaviside](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.3.0).\
+Thanks to [@gyang0](https://www.github.com/gyang0) for his contributions ([here](https://www.github.com/Zushah/zushah.github.io/pull/1) and [here](https://github.com/Zushah/Chalkboard/pull/5)) to the [documentation](https://www.github.com/Zushah/zushah.github.io/tree/main/Chalkboard).\
+Thanks to [@JentGent](https://www.github.com/JentGent) for his implementation ([here](https://www.github.com/JentGent/linalg/blob/main/linalg.js#L519)) for calculating QR decomposition which was [adapted](https://www.github.com/Zushah/Chalkboard/commit/1dce0dbac82b38f9a550dd496bc878c402a92442) into [v1.7.0 Descartes](https://www.github.com/Zushah/Chalkboard/releases/tag/v1.7.0).
 # Contact
 [GitHub](https://www.github.com/Zushah)\

package/dist/Chalkboard.d.ts CHANGED Viewed

@@ -7,12 +7,43 @@ type ChalkboardFunction = {
     type: "expl" | "inve" | "pola" | "curv" | "surf" | "mult" | "comp";
 };
 type ChalkboardMatrix = number[][];
+type ChalkboardMorphism<T, U> = {
+    struc1: ChalkboardStructure<T>;
+    struc2: ChalkboardStructure<U>;
+    mapping: (a: T) => U;
+};
 type ChalkboardQuaternion = {
     a: number;
     b: number;
     c: number;
     d: number;
 };
+type ChalkboardSet<T> = {
+    contains: (element: T) => boolean;
+    elements?: T[];
+    id?: string;
+};
+type ChalkboardStructure<T> = {
+    set: ChalkboardSet<T>;
+    operation?: (a: T, b: T) => T;
+    identity?: T;
+    inverter?: (a: T) => T;
+    add?: (a: T, b: T) => T;
+    mul?: (a: T, b: T) => T;
+    addIdentity?: T;
+    mulIdentity?: T;
+    addInverter?: (a: T) => T;
+    mulInverter?: (a: T) => T;
+};
+type ChalkboardStructureExtension<T, U extends T> = {
+    base: ChalkboardStructure<T>;
+    extension: ChalkboardStructure<U>;
+    degree: number;
+    basis: ChalkboardVector[];
+    isFinite: boolean;
+    isSimple: boolean;
+    isAlgebraic: boolean;
+};
 type ChalkboardTensor = number | ChalkboardTensor[];
 type ChalkboardVector = {
     x: number;
@@ -27,15 +58,97 @@ type ChalkboardVectorField = {
     s?: string;
 };
 declare namespace Chalkboard {
-    const APPLY: (object: ChalkboardComplex | ChalkboardMatrix | ChalkboardQuaternion | ChalkboardTensor | ChalkboardVector, callback: Function) => ChalkboardComplex | ChalkboardMatrix | ChalkboardQuaternion | ChalkboardTensor | ChalkboardVector;
+    const APPLY: <T>(object: ChalkboardComplex | ChalkboardMatrix | ChalkboardQuaternion | ChalkboardTensor | ChalkboardVector | ChalkboardSet<T> | ChalkboardStructure<T>, callback: (x: any) => any) => ChalkboardComplex | ChalkboardMatrix | ChalkboardQuaternion | ChalkboardTensor | ChalkboardVector | ChalkboardSet<T> | ChalkboardStructure<T>;
     let CONTEXT: string;
     const E: (exponent?: number) => number;
     const LOGO: (x?: number, y?: number, size?: number, context?: CanvasRenderingContext2D) => void;
     let PARSEPREFIX: string;
     const PI: (coefficient?: number) => number;
     const README: () => void;
-    const VERSION: "2.1.0";
-    const VERSIONALIAS: "Seki";
+    const VERSION: "2.2.0";
+    const VERSIONALIAS: "Galois";
+}
+declare namespace Chalkboard {
+    namespace abal {
+        const A: (n: number) => ChalkboardSet<number[]>;
+        const automorphism: <T>(struc: ChalkboardStructure<T>, mapping: (element: T) => T) => ChalkboardMorphism<T, T>;
+        const C: (n?: number) => ChalkboardSet<ChalkboardComplex>;
+        const cardinality: <T>(struc: ChalkboardSet<T> | ChalkboardStructure<T>) => number;
+        const Cartesian: <T, U>(set1: ChalkboardSet<T>, set2: ChalkboardSet<U>) => ChalkboardSet<[T, U]>;
+        const Cayley: (struc: ChalkboardStructure<number>, type?: "add" | "mul") => ChalkboardMatrix;
+        const center: <T>(group: ChalkboardStructure<T>) => ChalkboardSet<T>;
+        const complement: <T>(set: ChalkboardSet<T>, superset: ChalkboardSet<T>) => ChalkboardSet<T>;
+        const compose: <T, U, V>(morph1: ChalkboardMorphism<T, U>, morph2: ChalkboardMorphism<U, V>) => ChalkboardMorphism<T, V>;
+        const copy: <T, U extends T>(struc: ChalkboardSet<T> | ChalkboardStructure<T> | ChalkboardStructureExtension<T, U> | ChalkboardMorphism<T, U>) => ChalkboardSet<T> | ChalkboardStructure<T> | ChalkboardStructureExtension<T, U> | ChalkboardMorphism<T, U>;
+        const coset: <T>(struc: ChalkboardStructure<T>, substruc: ChalkboardStructure<T>) => ChalkboardSet<ChalkboardSet<T>>;
+        const cyclicSubgroup: <T>(group: ChalkboardStructure<T>, element: T) => ChalkboardSet<T>;
+        const D: (n: number) => ChalkboardSet<string>;
+        const difference: <T>(set1: ChalkboardSet<T>, set2: ChalkboardSet<T>) => ChalkboardSet<T>;
+        const direct: <T, U>(struc1: ChalkboardStructure<T>, struc2: ChalkboardStructure<U>, type?: "product" | "sum") => ChalkboardStructure<[T, U]>;
+        const endomorphism: <T>(struc: ChalkboardStructure<T>, mapping: (element: T) => T) => ChalkboardMorphism<T, T>;
+        const field: <T>(set: ChalkboardSet<T>, add: (a: T, b: T) => T, mul: (a: T, b: T) => T, addIdentity?: T, mulIdentity?: T, addInverter?: (a: T) => T, mulInverter?: (a: T) => T) => ChalkboardStructure<T>;
+        const fieldExtension: <T, U extends T>(base: ChalkboardStructure<T>, extension: ChalkboardStructure<U>, degree: number, basis: ChalkboardVector[], isFinite: boolean, isSimple: boolean, isAlgebraic: boolean) => ChalkboardStructureExtension<T, U>;
+        const GL: (n: number) => ChalkboardSet<ChalkboardMatrix>;
+        const group: <T>(set: ChalkboardSet<T>, operation: (a: T, b: T) => T, identity?: T, inverter?: (a: T) => T) => ChalkboardStructure<T>;
+        const homomorphism: <T, U>(struc1: ChalkboardStructure<T>, struc2: ChalkboardStructure<U>, mapping: (element: T) => U) => ChalkboardMorphism<T, U>;
+        const idmorphism: <T>(struc: ChalkboardStructure<T>) => ChalkboardMorphism<T, T>;
+        const image: <T, U>(morph: ChalkboardMorphism<T, U>, subset?: ChalkboardSet<T>) => ChalkboardSet<U>;
+        const intersection: <T>(set1: ChalkboardSet<T>, set2: ChalkboardSet<T>) => ChalkboardSet<T>;
+        const invmorphism: <T, U>(morph: ChalkboardMorphism<T, U>) => ChalkboardMorphism<U, T>;
+        const isAutomorphism: <T>(morph: ChalkboardMorphism<T, T>) => boolean;
+        const isBijective: <T, U>(morph: ChalkboardMorphism<T, U>) => boolean;
+        const isClosed: <T>(set: ChalkboardSet<T> | string, operation: ((a: T, b: T) => T) | "addition" | "multiplication") => boolean;
+        const isCommutative: <T>(struc: ChalkboardStructure<T>) => boolean;
+        const isCyclicSubgroup: <T>(group: ChalkboardStructure<T>, subgroup: ChalkboardSet<T>) => boolean;
+        const isEmpty: <T>(struc: ChalkboardSet<T> | ChalkboardStructure<T>) => boolean;
+        const isEndomorphism: <T>(morph: ChalkboardMorphism<T, T>) => boolean;
+        const isEqual: <T, U>(struc1: ChalkboardSet<T> | ChalkboardStructure<T> | ChalkboardMorphism<T, U>, struc2: ChalkboardSet<T> | ChalkboardStructure<T> | ChalkboardMorphism<T, U>) => boolean;
+        const isExact: <T, U, V>(morph1: ChalkboardMorphism<T, U>, morph2: ChalkboardMorphism<U, V>) => boolean;
+        const isField: <T>(field: ChalkboardStructure<T>) => boolean;
+        const isGroup: <T>(group: ChalkboardStructure<T>) => boolean;
+        const isHomomorphism: <T, U>(morph: ChalkboardMorphism<T, U>) => boolean;
+        const isIdeal: <T>(ring: ChalkboardStructure<T>, subset: ChalkboardSet<T>) => boolean;
+        const isIdentity: <T>(struc: ChalkboardStructure<T>, element: T, type?: "add" | "mul") => boolean;
+        const isInjective: <T, U>(morph: ChalkboardMorphism<T, U>) => boolean;
+        const isInverse: <T>(struc: ChalkboardStructure<T>, element1: T, element2: T, type?: "add" | "mul") => boolean;
+        const isIsomorphism: <T, U>(morph: ChalkboardMorphism<T, U>) => boolean;
+        const isNormalSubgroup: <T>(group: ChalkboardStructure<T>, subgroup: ChalkboardSet<T>) => boolean;
+        const isomorphism: <T, U>(struc1: ChalkboardStructure<T>, struc2: ChalkboardStructure<U>, mapping: (element: T) => U) => ChalkboardMorphism<T, U>;
+        const isPrincipalIdeal: <T>(ring: ChalkboardStructure<T>, ideal: ChalkboardSet<T>) => boolean;
+        const isRing: <T>(ring: ChalkboardStructure<T>) => boolean;
+        const isSubfield: <T>(field: ChalkboardStructure<T>, subset: ChalkboardSet<T>) => boolean;
+        const isSubgroup: <T>(group: ChalkboardStructure<T>, subset: ChalkboardSet<T>) => boolean;
+        const isSubring: <T>(ring: ChalkboardStructure<T>, subset: ChalkboardSet<T>) => boolean;
+        const isSubset: <T>(set: ChalkboardSet<T>, superset: ChalkboardSet<T>) => boolean;
+        const isSuperset: <T>(set: ChalkboardSet<T>, subset: ChalkboardSet<T>) => boolean;
+        const isSurjective: <T, U>(morph: ChalkboardMorphism<T, U>) => boolean;
+        const kernel: <T, U>(morph: ChalkboardMorphism<T, U>, subset?: ChalkboardSet<T>) => ChalkboardSet<T>;
+        const Lagrange: <T>(group: ChalkboardStructure<T>, subgroup: ChalkboardSet<T>) => boolean;
+        const M: (rows: number, cols?: number) => ChalkboardSet<ChalkboardMatrix>;
+        const N: () => ChalkboardSet<number>;
+        const order: <T>(group: ChalkboardStructure<T>, element: T) => number;
+        const P: () => ChalkboardSet<number>;
+        const powerSet: <T>(set: ChalkboardSet<T>) => ChalkboardSet<ChalkboardSet<T>>;
+        const preimage: <T, U>(morph: ChalkboardMorphism<T, U>, subset?: ChalkboardSet<U>) => ChalkboardSet<T>;
+        const principalIdeal: <T>(ring: ChalkboardStructure<T>, element: T) => ChalkboardSet<T>;
+        const print: (struc: ChalkboardSet<number> | ChalkboardStructure<number>) => void;
+        const Q: () => ChalkboardSet<number>;
+        const quotient: <T>(struc: ChalkboardStructure<T>, substruc: ChalkboardStructure<T>) => ChalkboardStructure<ChalkboardSet<T>>;
+        const R: () => ChalkboardSet<number>;
+        const ring: <T>(set: ChalkboardSet<T>, add: (a: T, b: T) => T, mul: (a: T, b: T) => T, addIdentity?: T, mulIdentity?: T, addInverter?: (a: T) => T) => ChalkboardStructure<T>;
+        const ringExtension: <T, U extends T>(base: ChalkboardStructure<T>, extension: ChalkboardStructure<U>, degree: number, basis: ChalkboardVector[], isFinite: boolean, isSimple: boolean, isAlgebraic: boolean) => ChalkboardStructureExtension<T, U>;
+        const S: (n: number) => ChalkboardSet<number[]>;
+        const set: <T>(set: T[]) => ChalkboardSet<T>;
+        const symmetricDifference: <T>(set1: ChalkboardSet<T>, set2: ChalkboardSet<T>) => ChalkboardSet<T>;
+        const toArray: <T>(struc: ChalkboardSet<T> | ChalkboardStructure<T>) => T[];
+        const toMatrix: (struc: ChalkboardSet<number> | ChalkboardStructure<number>, rows: number, cols?: number) => ChalkboardMatrix;
+        const toObject: (struc: ChalkboardSet<number> | ChalkboardStructure<number>) => object;
+        const toString: (struc: ChalkboardSet<number> | ChalkboardStructure<number>) => string;
+        const toTensor: (struc: ChalkboardSet<number> | ChalkboardStructure<number>, ...size: number[]) => ChalkboardTensor;
+        const toVector: (struc: ChalkboardSet<number> | ChalkboardStructure<number>, dimension: 2 | 3 | 4, index?: number) => ChalkboardVector;
+        const union: <T>(set1: ChalkboardSet<T>, set2: ChalkboardSet<T>) => ChalkboardSet<T>;
+        const Z: (n?: number) => ChalkboardSet<number>;
+    }
 }
 declare namespace Chalkboard {
     namespace calc {
@@ -234,6 +347,7 @@ declare namespace Chalkboard {
         const symmetricBinomial: (size: number) => ChalkboardMatrix;
         const toArray: (matr: ChalkboardMatrix) => number[];
         const toObject: (matr: ChalkboardMatrix) => object;
+        const toSet: (matr: ChalkboardMatrix) => ChalkboardSet<number>;
         const toString: (matr: ChalkboardMatrix) => string;
         const toTensor: (matr: ChalkboardMatrix, ...size: number[]) => ChalkboardTensor;
         const toVector: (matr: ChalkboardMatrix, dimension: 2 | 3 | 4, index?: number, axis?: 0 | 1) => ChalkboardVector;
@@ -266,6 +380,7 @@ declare namespace Chalkboard {
         const Goldbach: (num: number) => [number, number] | undefined;
         const isApproxEqual: (a: number, b: number, precision?: number) => boolean;
         const isPrime: (num: number) => boolean;
+        const isRational: (num: number, tolerance?: number) => boolean;
         const Kronecker: (a: number, b: number) => 1 | 0;
         const lcm: (a: number, b: number) => number;
         const map: (num: number, range1: number[], range2: number[]) => number;
@@ -282,6 +397,7 @@ declare namespace Chalkboard {
         const roundTo: (num: number, positionalIndex: number) => number;
         const sgn: (num: number) => -1 | 0 | 1;
         const sum: (formula: string, inf: number, sup: number) => number;
+        const toFraction: (num: number, tolerance?: number) => [number, number];
     }
 }
 declare namespace Chalkboard {
@@ -525,46 +641,74 @@ declare namespace Chalkboard {
 }
 declare namespace Chalkboard {
     namespace stat {
+        const absolute: (arr: number[]) => number[];
+        const add: (arr1: number[], arr2: number[]) => number[];
         const array: (inf: number, sup: number, length?: number) => number[];
         const autocorrelation: (arr: number[]) => number[];
+        const Bayes: (pA: number, pGivenA: number, pGivenNotA: number) => number;
         const change: (arr1: number[], arr2: number[]) => number[];
         const chiSquared: (arr1: number[], arr2: number[]) => number[];
-        const confidenceInterval: (arr: number[]) => [number, number];
+        const confidenceInterval: (arr: number[], confidence?: number) => [number, number];
         const constrain: (arr: number[], range?: [number, number]) => number[];
         const convolution: (arr1: number[], arr2: number[]) => number[];
         const correlation: (arr1: number[], arr2: number[]) => number[];
+        const correlationCoefficient: (arr1: number[], arr2: number[]) => number;
+        const covariance: (arr1: number[], arr2: number[]) => number;
+        const cummax: (arr: number[]) => number[];
+        const cummin: (arr: number[]) => number[];
+        const cummul: (arr: number[]) => number[];
+        const cumsum: (arr: number[]) => number[];
         const deviation: (arr: number[]) => number;
+        const dot: (arr1: number[], arr2: number[]) => number;
         const error: (arr: number[]) => number;
         const eq: (arr: number[], arrORnum: number | number[]) => number[];
+        const expected: (arr: number[], probabilities?: number[]) => number;
         const Gaussian: (height: number, mean: number, deviation: number) => ChalkboardFunction;
         const gt: (arr: number[], arrORnum: number | number[], includeEnd?: boolean) => number[];
         const ineq: (arr: number[], inf: number, sup: number, includeInf?: boolean, includeSup?: boolean) => number[];
+        const inormal: (p: number) => number;
+        const interpolate: (arr: (number | null | undefined)[], type?: "linear" | "quadratic") => number[];
+        const interquartileRange: (arr: number[]) => number;
         const kurtosis: (arr: number[]) => number;
         const lt: (arr: number[], arrORnum: number | number[], includeEnd?: boolean) => number[];
         const mad: (arr: number[]) => number;
         const max: (arr: number[]) => number;
         const mean: (arr: number[], type?: "arithmetic" | "geometric" | "harmonic") => number;
+        const meanMoving: (arr: number[], windowSize: number) => number[];
+        const meanWeighted: (arr: number[], weights: number[]) => number;
         const median: (arr: number[]) => number;
         const min: (arr: number[]) => number;
         const mode: (arr: number[]) => number;
+        const mul: (arr: number[]) => number;
+        const negate: (arr: number[]) => number[];
         const norm: (arr: number[], type?: "L0" | "L1" | "L2" | "LInfinity") => number;
+        const normal: (x: number) => number;
         const normalize: (arr: number[], type?: "L0" | "L1" | "L2" | "LInfinity") => number[];
         const normsq: (arr: number[], type?: "L0" | "L1" | "L2" | "LInfinity") => number;
+        const pad: (arr: number[], length: number, num?: number) => number[];
         const percentile: (arr: number[], num: number) => number;
         const print: (arr: number[]) => void;
         const quartile: (arr: number[], type: "Q1" | "Q2" | "Q3") => number;
         const random: (inf: number, sup: number, length: number) => number[];
         const range: (arr: number[]) => number;
         const regression: (data: number[][], type?: "linear" | "polynomial" | "power" | "exponential" | "logarithmic", degree?: number) => ChalkboardFunction;
+        const resampling: (arr: number[], samples?: number, type?: "bootstrap" | "jackknife") => number[][];
+        const reverse: (arr: number[]) => number[];
+        const scl: (arr: number[], num: number) => number[];
         const shuffle: (arr: number[]) => number[];
         const skewness: (arr: number[]) => number;
+        const sub: (arr1: number[], arr2: number[]) => number[];
         const subsets: (arr: number[]) => number[][];
-        const toMatrix: (arr: number[], rows: number, cols: number) => ChalkboardMatrix;
+        const sum: (arr: number[]) => number;
+        const toMatrix: (arr: number[], rows: number, cols?: number) => ChalkboardMatrix;
         const toObject: (arr: number[]) => object;
+        const toSet: (arr: number[]) => ChalkboardSet<number>;
         const toString: (arr: number[]) => string;
         const toTensor: (arr: number[], ...size: number[]) => ChalkboardTensor;
         const toVector: (arr: number[], dimension: 2 | 3 | 4, index?: number) => ChalkboardVector;
+        const unique: <T>(arr: T[]) => T[];
         const variance: (arr: number[]) => number;
+        const zscored: (arr: number[]) => number[];
     }
 }
 declare namespace Chalkboard {
@@ -600,6 +744,7 @@ declare namespace Chalkboard {
         const toArray: (tens: ChalkboardTensor) => number[];
         const toMatrix: (tens: ChalkboardTensor) => ChalkboardMatrix;
         const toObject: (tens: ChalkboardTensor) => object | number;
+        const toSet: (tens: ChalkboardTensor) => ChalkboardSet<number>;
         const toString: (tens: ChalkboardTensor, indentation?: number) => string;
         const toVector: (tens: ChalkboardTensor, dimension: number, index?: number) => ChalkboardVector;
         const transpose: (tens: ChalkboardTensor) => ChalkboardTensor;