Mathlab-pro NPM

MathLab-Pro

Dive into Calculations 🎲

This library is a practical project from my web development course - thank you.

MathLab-Pro is a comprehensive library of mathematical calculations designed to cater to a wide range of applications, from pure mathematics and physics to major scientific fields such as engineering and computer science. This library offers a diverse range of mathematical functions, covering basic operations to trigonometric, exponential, logarithmic functions, and more. With MathLab-Pro, you gain access to a powerful collection of mathematical tools to assist you in performing accurate and efficient calculations in your projects. The library is designed with ease of use in mind, facilitating integration and utilization across various applications. Additionally, MathLab-Pro provides comprehensive documentation to help you explore the full potential of the library.

Installation

You can install MathLab-Pro using npm:

npm install mathlab-pro

Usage

To use MathLab-Pro in your project, you need to require it:

const _ = require("mathlab-pro");

// Example code showcasing the usage of MathLab-Pro

Make sure to replace exampleFunction with the actual function you want to use from the MathLab-Pro library.

Documentation

To obtain detailed information on how to use MathLab-Pro and a complete list of available functions, please refer to the official documentation below:

Mathalphabets

The Mathalphabets class provides functions to retrieve symbols from various mathematical alphabets, including the Greek alphabet, Latex alphabet, Fraktur alphabet, and Cyrillic alphabet.

`getGreekAlphabetUppercase(indexOrText)`

Returns the uppercase Greek alphabet letter corresponding to the specified index or symbol name.

Parameters:

indexOrText (number||string): The index or symbol name of the desired letter.

Returns:

(string || array): The uppercase Greek alphabet letter corresponding to the specified index or an array of all Greek alphabet letters if no argument is provided.

Throws:
(Error): If the provided index is invalid or the symbol name is not recognized.

Example

const letter = Mathalphabets.getGreekAlphabetUppercase();
console.log(letter);
// Output:

// [
//     'Α', 'Β', 'Γ', 'Δ', 'Ε',
//     'Ζ', 'Η', 'Θ', 'Ι', 'Κ',
//     'Λ', 'Μ', 'Ν', 'Ξ', 'Ο',
//     'Π', 'Ρ', 'Σ', 'Τ', 'Υ',
//     'Φ', 'Χ', 'Ψ', 'Ω'
// ]

const letter1 = Mathalphabets.getGreekAlphabetUppercase(3);
console.log(letter1); // Output: Δ

const letter2 = Mathalphabets.getGreekAlphabetUppercase(13);
console.log(letter2); // Output: Ξ

const letter3 = Mathalphabets.getGreekAlphabetUppercase(22);
console.log(letter3); // Output: Ψ

console.log(Mathalphabets.getGreekAlphabetUppercase("GAMMA")); // returns "Γ"
console.log(Mathalphabets.getGreekAlphabetUppercase("DELTA")); // returns "Δ"
console.log(Mathalphabets.getGreekAlphabetUppercase("ETA")); // returns "Η"
console.log(Mathalphabets.getGreekAlphabetUppercase("THETA")); // returns "Θ"
console.log(Mathalphabets.getGreekAlphabetUppercase("LAMBDA")); // returns "Λ"
console.log(Mathalphabets.getGreekAlphabetUppercase("XI")); // returns "Ξ"

`getGreekAlphabetLowercase(indexOrText)`

Returns the lowercase Greek alphabet letter corresponding to the specified index or symbol name.

Parameters:

indexOrText (number|string): The index or symbol name of the desired letter.

Returns:

(string|array): The lowercase Greek alphabet letter corresponding to the specified index or an array of all Greek alphabet letters if no argument is provided.

Throws:
(Error): If the provided index is invalid or the symbol name is not recognized.

Example

const letter = Mathalphabets.getGreekAlphabetLowercase();
console.log(letter);
// Output:

// [
//    'α', 'β', 'γ', 'δ', 'ε',
//    'ζ', 'η', 'θ', 'ι', 'κ',
//    'λ', 'μ', 'ν', 'ξ', 'ο',
//    'π', 'ρ', 'σ', 'τ', 'υ',
//    'φ', 'χ', 'ψ', 'ω'
// ]

const letter0 = Mathalphabets.getGreekAlphabetLowercase(3);
console.log(letter0); // Output: δ

const letter01 = Mathalphabets.getGreekAlphabetLowercase(13);
console.log(letter01); // Output: ξ

const letter02 = Mathalphabets.getGreekAlphabetLowercase(22);
console.log(letter02); // Output: ψ

console.log(Mathalphabets.getGreekAlphabetLowercase("alpha")); // returns α
console.log(Mathalphabets.getGreekAlphabetLowercase("delta")); // returns δ
console.log(Mathalphabets.getGreekAlphabetLowercase("eta")); // returns η
console.log(Mathalphabets.getGreekAlphabetLowercase("theta")); // returns θ
console.log(Mathalphabets.getGreekAlphabetLowercase("lambda")); // returns λ
console.log(Mathalphabets.getGreekAlphabetLowercase("xi")); // returns ξ

`getLatexAlphabetSymbol(index)`

Returns the symbol of the corresponding LaTeX alphabet based on the specified index or name. If no index or name is provided, it returns the complete list of symbols.

Parameters:

indexOrText (optional): The index of the desired symbol or the name of the letter. If no argument is provided, it returns the complete list of symbols.

Return

string or string[]: The symbol of the corresponding LaTeX alphabet based on the specified index or name, or the complete list of symbols if no argument is provided.

Exceptions

Error: If the provided index or name is invalid.

Examples

const symbol = Mathalphabets.getLatexAlphabetSymbol();
console.log(symbol);
// [
//   'α', 'β', 'γ', 'δ', 'ε',
//   'ζ', 'η', 'θ', 'ι', 'κ',
//   'λ', 'μ', 'ν', 'ξ', 'ο',
//   'π', 'ρ', 'σ', 'τ', 'υ',
//   'φ', 'χ', 'ψ', 'ω'
// ]

const symbol = Mathalphabets.getLatexAlphabetSymbol(1);
console.log(symbol); // Output: β

const symbol = Mathalphabets.getLatexAlphabetSymbol(6);
console.log(symbol); // Output: η

const symbol = Mathalphabets.getLatexAlphabetSymbol("PHI");
console.log(symbol); // Output: φ

`Fraktur Alphabet`

The Fraktur Alphabet class provides methods to retrieve symbols from the Fraktur alphabet. The Fraktur alphabet is a typeface that is based on Gothic script and is commonly used in mathematical notation and decorative typography.

Methods

`getFrakturAlphabetSymbol(indexOrText)`

Returns the symbol of the Fraktur alphabet corresponding to the specified index or name. If no index or name is provided, it returns the complete list of symbols.

indexOrText (optional)_: The index of the desired symbol or the name of the letter. It can be a number or a string.

Returns:

The symbol of the Fraktur alphabet corresponding to the specified index or name, or the complete list of symbols if no argument is provided.

Throws:

An error if the provided index or name is invalid.

Example

// Recupera a lista completa de símbolos
const symbols = Mathalphabets.getFrakturAlphabetSymbol();
console.log(symbols);
//  Saída:
// [
//    "𝔄", "𝔅", "ℭ", "𝔇", "𝔈",
//    "𝔉", "𝔊", "ℌ", "ℑ", "𝔍", "𝔎",
//    "𝔏", "𝔐", "𝔑", "𝔒", "𝔓", "𝔔",
//    "ℜ", "𝔖", "𝔗", "𝔘", "𝔙", "𝔚",
//    "𝔛", "𝔜", "ℨ"
// ]

// Recupera o símbolo pelo índice
const symbol = Mathalphabets.getFrakturAlphabetSymbol(0);
console.log(symbol);
// Saída: "𝔄"

// Recupera o símbolo pelo nome
const symbol = Mathalphabets.getFrakturAlphabetSymbol("D");
console.log(symbol);
// Saída: "𝔇"

mathematicalOperators(index)

The mathematicalOperators function returns a mathematical operator based on the specified index.

Parameters

index (number): The index of the mathematical operator.

Return

The mathematical operator corresponding to the specified index.

Error Handling
If the index is out of bounds (i.e., not a valid index in the operators array), an error message is logged to the console: "Error: Index out of array bounds."

Examples

console.log(Mathalphabets.mathematicalOperators());
// RETURNS

//  [
//        '∀', '∁', '∂', '∃', '∄', '∅', '∆', '∇', '∈', '∉', '∊', '∋',
//        '∌', '∍', '∎', '∏', '∐', '∑', '−', '∓', '∔', '∕', '∖', '∗',
//        '∘', '∙', '√', '∛', '∜', '∝', '∞', '∟', '∠', '∡', '∢', '∣',
//        '∤', '∥', '∦', '∧', '∨', '∩', '∪', '∫', '∬', '∭', '∮', '∯',
//        '∰', '∱', '∲', '∳', '∴', '∵', '∶', '∷', '∸', '∹', '∺', '∻',
//        '∼', '∽', '∾', '∿', '≀', '≁', '≂', '≃', '≄', '≅', '≆', '≇',
//        '≈', '≉', '≊', '≋', '≌', '≍', '≎', '≏', '≐', '≑', '≒', '≓',
//        '≔', '≕', '≖', '≗', '≘', '≙', '≚', '≛', '≜', '≝', '≞', '≟',
//        '≠', '≡', '≢', '≣',
//        ... 344 more items
//  ]
const operator1 = Mathalphabets.mathematicalOperators(1);
console.log(operator1);
// RETURN ∁
const operator2 = Mathalphabets.mathematicalOperators(2);
console.log(operator2);
// RETURN ∂
const operator3 = Mathalphabets.mathematicalOperators(3);
console.log(operator3);
// RETURN ∃
const operator4 = Mathalphabets.mathematicalOperators(4);
console.log(operator4);
// RETURN ∄
const operator5 = Mathalphabets.mathematicalOperators(5);
console.log(operator5);
// RETURN ∅
const operator6 = Mathalphabets.mathematicalOperators(6);
console.log(operator6);
// RETURN ∆
const operator7 = Mathalphabets.mathematicalOperators(7);
console.log(operator7);
// RETURN ∇
const operator8 = Mathalphabets.mathematicalOperators(8);
console.log(operator8);
// RETURN ∈
const operator9 = Mathalphabets.mathematicalOperators(9);
console.log(operator9);
// RETURN ∉
const operator10 = Mathalphabets.mathematicalOperators(10);
console.log(operator10);
// RETURN ∊

∀ - `index [ 000 ] - for all'`

∁ - `index [ 001 ] - complement'`

∂ - `index [ 002 ] - partial differential`

∃ - `index [ 003 ] - there exists`

∄ - `index [ 004 ] - there does not exist`

∅ - `index [ 005 ] - empty set`

∆ - `index [ 006 ] - increment`

∇ - `index [ 007 ] - nabla`

∈ - `index [ 008 ] - element of`

∉ - `index [ 009 ] - not an element of`

∊ - `index [ 010 ] - small element of`

∋ - `index [ 011 ] - contains as member`

∌ - `index [ 012 ] - does not contain as member`

∍ - `index [ 013 ] - small contains as member`

∎ - `index [ 014 ] - end of proof`

∏ - `index [ 015 ] - n-ary product`

∐ - `index [ 016 ] - n-ary coproduct`

∑ - `index [ 017 ] - n-ary summation`

− - `index [ 018 ] - minus sign`

∓ - `index [ 019 ] - minus-or-plus sign`

∔ - `index [ 020 ] - dot plus`

∕ - `index [ 021 ] - division slash`

∖ - `index [ 022 ] - set minus`

∗ - `index [ 023 ] - asterisk operator`

∘ - `index [ 024 ] - ring operator`

∙ - `index [ 025 ] - bullet operator`

√ - `index [ 026 ] - square root`

∛ - `index [ 027 ] - cube root`

∜ - `index [ 028 ] - fourth root`

∝ - `index [ 029 ] - proportional to`

∞ - `index [ 030 ] - infinity`

∟ - `index [ 031 ] - right angle`

∠ - `index [ 032 ] - angle`

∡ - `index [ 033 ] - measured angle`

∢ - `index [ 034 ] - spherical angle`

∣ - `index [ 035 ] - divides`

∤ - `index [ 036 ] - does not divide`

∥ - `index [ 037 ] - parallel to`

∦ - `index [ 038 ] - not parallel to`

∧ - `index [ 039 ] - logical and`

∨ - `index [ 040 ] - logical or`

∩ - `index [ 041 ] - intersection`

∪ - `index [ 042 ] - union`

∫ - `index [ 043 ] - integral`

∬ - `index [ 044 ] - double integral`

∭ - `index [ 045 ] - triple integral`

∮ - `index [ 046 ] - contour integral`

∯ - `index [ 047 ] - surface integral`

∰ - `index [ 048 ] - volume integral`

∱ - `index [ 049 ] - clockwise integral`

∲ - `index [ 050 ] - clockwise contour integral`

∳ - `index [ 051 ] - anticlockwise contour integral`

∴ - `index [ 052 ] - therefore`

∵ - `index [ 053 ] - because`

∶ - `index [ 054 ] - ratio`

∷ - `index [ 055 ] - proportion`

∸ - `index [ 056 ] - dot minus`

∹ - `index [ 057 ] - excess`

∺ - `index [ 058 ] - geometric proportion`

∻ - `index [ 059 ] - homothetic`

∼ - `index [ 060 ] - tilde operator`

∽ - `index [ 061 ] - reversed tilde`

∾ - `index [ 062 ] - inverted lazy`

∿ - `index [ 063 ] - sine wave`

≀ - `index [ 064 ] - wreath product`

≁ - `index [ 065 ] - not tilde`

≂ - `index [ 066 ] - minus tilde`

≃ - `index [ 067 ] - asymptotically equal to`

≄ - `index [ 068 ] - not asymptotically equal to`

≅ - `index [ 069 ] - approximately equal to`

≆ - `index [ 070 ] - approximately but not actually equal to`

≇ - `index [ 071 ] - neither approximately nor actually equal to`

≈ - `index [ 072 ] - almost equal to`

≉ - `index [ 073 ] - not almost equal to`

≊ - `index [ 074 ] - almost equal or equal to`

≋ - `index [ 075 ] - triple tilde`

≌ - `index [ 076 ] - all equal to`

≍ - `index [ 077 ] - equivalent to`

≎ - `index [ 078 ] - geometrically equivalent to`

≏ - `index [ 079 ] - difference between`

≐ - `index [ 080 ] - approaches the limit`

≑ - `index [ 081 ] - geometrically equal to`

≒ - `index [ 082 ] - approximately equal to or the image of`

≓ - `index [ 083 ] - image of or approximately equal to`

≔ - `index [ 084 ] - colon equals`

≕ - `index [ 085 ] - equals colon`

≖ - `index [ 086 ] - ring in equal to`

≗ - `index [ 087 ] - ring equal to`

≘ - `index [ 088 ] - corresponds to`

≙ - `index [ 089 ] - estimates`

≚ - `index [ 090 ] - equiangular to`

≛ - `index [ 091 ] - star equals`

≜ - `index [ 092 ] - delta equal to`

≝ - `index [ 093 ] - equal to by definition`

≞ - `index [ 094 ] - measured by`

≟ - `index [ 095 ] - questioned equal to`

≠ - `index [ 096 ] - not equal to`

≡ - `index [ 097 ] - identical to`

≢ - `index [ 098 ] - not identical to`

≣ - `index [ 099 ] - strictly equivalent to`

≤ - `index [ 100 ] - less-than or equal to`

≥ - `index [ 101 ] - greater-than or equal to`

≦ - `index [ 102 ] - less-than over equal to`

≧ - `index [ 103 ] - greater-than over equal to`

≨ - `index [ 104 ] - less-than but not equal to`

≩ - `index [ 105 ] - greater-than but not equal to`

≪ - `index [ 106 ] - much less-than`

≫ - `index [ 107 ] - much greater-than`

≬ - `index [ 108 ] - between`

≭ - `index [ 109 ] - not equivalent to`

≮ - `index [ 110 ] - not less-than`

≯ - `index [ 111 ] - not greater-than`

≰ - `index [ 112 ] - neither less-than nor equal to`

≱ - `index [ 113 ] - neither greater-than nor equal to`

≲ - `index [ 114 ] - less-than or equivalent to`

≳ - `index [ 115 ] - greater-than or equivalent to`

≴ - `index [ 116 ] - neither less-than nor equivalent to`

≵ - `index [ 117 ] - neither greater-than nor equivalent to`

≶ - `index [ 118 ] - less-than or greater-than`

≷ - `index [ 119 ] - greater-than or less-than`

≸ - `index [ 120 ] - neither less-than nor greater-than`

≹ - `index [ 121 ] - neither greater-than nor less-than`

≺ - `index [ 122 ] - precedes`

≻ - `index [ 123 ] - succeeds`

≼ - `index [ 124 ] - precedes or equal to`

≽ - `index [ 125 ] - succeeds or equal to`

≾ - `index [ 126 ] - precedes or equivalent to`

≿ - `index [ 127 ] - succeeds or equivalent to`

⊀ - `index [ 128 ] - does not precede`

⊁ - `index [ 129 ] - does not succeed`

⊂ - `index [ 130 ] - subset of`

⊃ - `index [ 131 ] - superset of`

⊄ - `index [ 132 ] - not a subset of`

⊅ - `index [ 133 ] - not a superset of`

⊆ - `index [ 134 ] - subset of or equal to`

⊇ - `index [ 135 ] - superset of or equal to`

⊈ - `index [ 136 ] - neither a subset of nor equal to`

⊉ - `index [ 137 ] - neither a superset of nor equal to`

⊊ - `index [ 138 ] - subset of but not equal to`

⊋ - `index [ 139 ] - superset of but not equal to`

⊌ - `index [ 140 ] - neither a subset of nor equal to`

⊍ - `index [ 141 ] - neither a superset of nor equal to`

⊎ - `index [ 142 ] - multiset`

⊏ - `index [ 143 ] - square image of`

⊐ - `index [ 144 ] - square original of`

⊑ - `index [ 145 ] - square image of or equal to`

⊒ - `index [ 146 ] - square original of or equal to`

⊓ - `index [ 147 ] - square cap`

⊔ - `index [ 148 ] - square cup`

⊕ - `index [ 149 ] - circled plus`

⊖ - `index [ 150 ] - circled minus`

⊗ - `index [ 151 ] - circled times`

⊘ - `index [ 152 ] - circled division slash`

⊙ - `index [ 153 ] - circled dot`

⊚ - `index [ 154 ] - circled ring operator`

⊛ - `index [ 155 ] - circled asterisk operator`

⊜ - `index [ 156 ] - circled equals`

⊝ - `index [ 157 ] - circled dash`

⊞ - `index [ 158 ] - squared plus`

⊟ - `index [ 159 ] - squared minus`

⊠ - `index [ 160 ] - squared times`

⊡ - `index [ 161 ] - squared dot operator`

⊢ - `index [ 162 ] - right tack`

⊣ - `index [ 163 ] - left tack`

⊤ - `index [ 164 ] - down tack`

⊥ - `index [ 165 ] - up tack`

⊦ - `index [ 166 ] - assertion`

⊧ - `index [ 167 ] - models`

⊨ - `index [ 168 ] - true`

⊩ - `index [ 169 ] - forces`

⊪ - `index [ 170 ] - triple vertical bar right turnstile`

⊫ - `index [ 171 ] - double vertical bar double right turnstile`

⊬ - `index [ 172 ] - does not prove`

⊭ - `index [ 173 ] - not true`

⊮ - `index [ 174 ] - does not force`

⊯ - `index [ 175 ] - negated double vertical bar double right turnstile`

⊰ - `index [ 176 ] - precedes under relation`

⊱ - `index [ 177 ] - succeeds under relation`

⊲ - `index [ 178 ] - normal subgroup of`

⊳ - `index [ 179 ] - contains as normal subgroup`

⊴ - `index [ 180 ] - normal subgroup of or equal to`

⊵ - `index [ 181 ] - contains as normal subgroup or equal to`

⊶ - `index [ 182 ] - original of`

⊷ - `index [ 183 ] - image of`

⊸ - `index [ 184 ] - multimap`

⊹ - `index [ 185 ] - hermitian conjugate matrix`

⊺ - `index [ 186 ] - intercalate`

⊻ - `index [ 187 ] - xor`

⊼ - `index [ 188 ] - nand`

⊽ - `index [ 189 ] - nor`

⊾ - `index [ 190 ] - right angle with arc`

⊿ - `index [ 191 ] - right triangle`

⋀ - `index [ 192 ] - n-ary logical and`

⋁ - `index [ 193 ] - n-ary logical or`

⋂ - `index [ 194 ] - n-ary intersection`

⋃ - `index [ 195 ] - n-ary union`

⋄ - `index [ 196 ] - diamond operator`

⋅ - `index [ 197 ] - dot operator`

⋆ - `index [ 198 ] - star operator`

⋇ - `index [ 199 ] - division times`

⋈ - `index [ 200 ] - bowtie`

⋉ - `index [ 201 ] - left normal factor semidirect product`

⋊ - `index [ 202 ] - right normal factor semidirect product`

⋋ - `index [ 203 ] - left semidirect product`

⋌ - `index [ 204 ] - right semidirect product`

⋍ - `index [ 205 ] - reversed tilde equals`

⋎ - `index [ 206 ] - curly logical or`

⋏ - `index [ 207 ] - curly logical and`

⋐ - `index [ 208 ] - double subset`

⋑ - `index [ 209 ] - double superset`

⋒ - `index [ 210 ] - double intersection`

⋓ - `index [ 211 ] - double union`

⋔ - `index [ 212 ] - pitchfork`

⋕ - `index [ 213 ] - equal and parallel to`

⋖ - `index [ 214 ] - less-than with dot`

⋗ - `index [ 215 ] - greater-than with dot`

⋘ - `index [ 216 ] - very much less-than`

⋙ - `index [ 217 ] - very much greater-than`

⋚ - `index [ 218 ] - less-than equal to or greater-than`

⋛ - `index [ 219 ] - greater-than equal to or less-than`

⋜ - `index [ 220 ] - equal to or less-than`

⋝ - `index [ 221 ] - equal to or greater-than`

⋞ - `index [ 222 ] - equal to or precedes`

⋟ - `index [ 223 ] - equal to or succeeds`

⋠ - `index [ 224 ] - does not precede or equal`

⋡ - `index [ 225 ] - does not succeed or equal`

⋢ - `index [ 226 ] - not square image of or equal to`

⋣ - `index [ 227 ] - not square original of or equal to`

⋤ - `index [ 228 ] - square image of or not equal to`

⋥ - `index [ 229 ] - square original of or not equal to`

⋦ - `index [ 230 ] - less-than but not equivalent to`

⋧ - `index [ 231 ] - greater-than but not equivalent to`

⋨ - `index [ 232 ] - precedes but not equivalent to`

⋩ - `index [ 233 ] - succeeds but not equivalent to`

⋪ - `index [ 234 ] - not normal subgroup of`

⋫ - `index [ 235 ] - does not contain as normal subgroup`

⋬ - `index [ 236 ] - not normal subgroup of or equal to`

⋭ - `index [ 237 ] - does not contain as normal subgroup or equal`

⋮ - `index [ 238 ] - vertical ellipsis`

⋯ - `index [ 239 ] - midline horizontal ellipsis`

⋰ - `index [ 240 ] - up right diagonal ellipsis`

⋱ - `index [ 241 ] - down right diagonal ellipsis`

⋲ - `index [ 242 ] - element of with long horizontal stroke`

⋳ - `index [ 243 ] - element of with vertical bar at end of horizontal stroke`

⋴ - `index [ 244 ] - small element of with vertical bar at end of horizontal stroke`

⋵ - `index [ 245 ] - element of with dot above`

⋶ - `index [ 246 ] - element of with overbar`

⋷ - `index [ 247 ] - small element of with overbar`

⋸ - `index [ 248 ] - element of with underbar`

⋹ - `index [ 249 ] - element of with two horizontal strokes`

⋺ - `index [ 250 ] - contains with long horizontal stroke`

⋻ - `index [ 251 ] - contains with vertical bar at end of horizontal stroke`

⋼ - `index [ 252 ] - small contains with vertical bar at end of horizontal stroke`

⋽ - `index [ 253 ] - contains with overbar`

⋾ - `index [ 254 ] - small contains with overbar`

⋿ - `index [ 255 ] - z notation bag membership`

⌀ - `index [ 256 ] - diameter sign`

⌁ - `index [ 257 ] - electric arrow`

⌂ - `index [ 258 ] - house`

⌃ - `index [ 259 ] - up arrowhead`

⌄ - `index [ 260 ] - down arrowhead`

⌅ - `index [ 261 ] - projective`

⌆ - `index [ 262 ] - perspective`

⌇ - `index [ 263 ] - wavy line`

⌈ - `index [ 264 ] - left ceiling`

⌉ - `index [ 265 ] - right ceiling`

⌊ - `index [ 266 ] - left floor`

⌋ - `index [ 267 ] - right floor`

⌌ - `index [ 268 ] - bottom right crop`

⌍ - `index [ 269 ] - bottom left crop`

⌎ - `index [ 270 ] - top right crop`

⌏ - `index [ 271 ] - top left crop`

⌐ - `index [ 272 ] - reversed not sign`

⌑ - `index [ 273 ] - square lozenge`

⌒ - `index [ 274 ] - arc`

⌓ - `index [ 275 ] - segment`

⌔ - `index [ 276 ] - sector`

⌕ - `index [ 277 ] - telephone recorder`

⌖ - `index [ 278 ] - position indicator`

⌗ - `index [ 279 ] - viewdata square`

⌘ - `index [ 280 ] - place of interest sign`

⌙ - `index [ 281 ] - turned not sign`

⌜ - `index [ 282 ] - top left corner`

⌝ - `index [ 283 ] - top right corner`

⌞ - `index [ 284 ] - bottom left corner`

⌟ - `index [ 285 ] - bottom right corner`

⌠ - `index [ 286 ] - top half integral`

⌡ - `index [ 287 ] - bottom half integral`

⌢ - `index [ 288 ] - frown`

⌣ - `index [ 289 ] - smile`

⌤ - `index [ 290 ] - up arrowhead between two horizontal bars`

⌥ - `index [ 291 ] - option key`

⌦ - `index [ 292 ] - erase to the right`

⌧ - `index [ 293 ] - x in a rectangle box`

⌨ - `index [ 294 ] - keyboard`

〈 - `index [ 295 ] - left-pointing angle bracket`

〉 - `index [ 296 ] - right-pointing angle bracket`

⌫ - `index [ 297 ] - erase to the left`

⌬ - `index [ 298 ] - benzene ring`

⌭ - `index [ 299 ] - cylindricity`

⌮ - `index [ 300 ] - all around-profile`

⌯ - `index [ 301 ] - symmetry`

⌰ - `index [ 302 ] - total runout`

⌱ - `index [ 303 ] - dimension origin`

⌲ - `index [ 304 ] - conical taper`

⌳ - `index [ 305 ] - sloping large or`

⌴ - `index [ 306 ] - apl functional symbol i-beam`

⌵ - `index [ 307 ] - turned ampersand`

⌶ - `index [ 308 ] - apl functional symbol circle star`

⌷ - `index [ 309 ] - apl functional symbol quad colon`

⌸ - `index [ 310 ] - apl functional symbol upstile`

⌹ - `index [ 311 ] - apl functional symbol downstile`

⌺ - `index [ 312 ] - apl functional symbol jot`

⌻ - `index [ 313 ] - apl functional symbol circle jot`

⌼ - `index [ 314 ] - apl functional symbol slash bar`

⌽ - `index [ 315 ] - apl functional symbol backslash bar`

⌾ - `index [ 316 ] - apl functional symbol quad backslash`

⌿ - `index [ 317 ] - apl functional symbol quad less-than`

⍀ - `index [ 318 ] - apl functional symbol quad greater-than`

⍁ - `index [ 319 ] - apl functional symbol leftwards vane`

⍂ - `index [ 320 ] - apl functional symbol rightwards vane`

⍃ - `index [ 321 ] - apl functional symbol quad leftwards arrow`

⍄ - `index [ 322 ] - apl functional symbol quad rightwards arrow`

⍅ - `index [ 323 ] - apl functional symbol circle backslash`

⍆ - `index [ 324 ] - apl functional symbol down tack underbar`

⍇ - `index [ 325 ] - apl functional symbol delta stile`

⍈ - `index [ 326 ] - apl functional symbol quad down caret`

⍉ - `index [ 327 ] - apl functional symbol quad delta`

⍊ - `index [ 328 ] - apl functional symbol down tack jot`

⍋ - `index [ 329 ] - apl functional symbol upwards vane`

⍌ - `index [ 330 ] - apl functional symbol quad upwards arrow`

⍍ - `index [ 331 ] - apl functional symbol up tack overbar`

⍎ - `index [ 332 ] - apl functional symbol del stile`

⍏ - `index [ 333 ] - apl functional symbol quad up caret`

⍐ - `index [ 334 ] - apl functional symbol quad del`

⍑ - `index [ 335 ] - apl functional symbol up tack jot`

⍒ - `index [ 336 ] - apl functional symbol downwards vane`

⍓ - `index [ 337 ] - apl functional symbol quad downwards arrow`

⍔ - `index [ 338 ] - apl functional symbol quote underbar`

⍕ - `index [ 339 ] - apl functional symbol delta underbar`

⍖ - `index [ 340 ] - apl functional symbol diamond underbar`

⍗ - `index [ 341 ] - apl functional symbol jot underbar`

⍘ - `index [ 342 ] - apl functional symbol circle underbar`

⍙ - `index [ 343 ] - apl functional symbol up shoe jot`

⍚ - `index [ 344 ] - apl functional symbol quote quad`

⍛ - `index [ 345 ] - apl functional symbol circle star`

⍜ - `index [ 346 ] - apl functional symbol quad colon`

⍝ - `index [ 347 ] - apl functional symbol up tack diaeresis`

⍞ - `index [ 348 ] - apl functional symbol del diaeresis`

⍟ - `index [ 349 ] - apl functional symbol star diaeresis`

⍠ - `index [ 350 ] - apl functional symbol jot diaeresis`

⍡ - `index [ 351 ] - apl functional symbol circle diaeresis`

⍢ - `index [ 352 ] - apl functional symbol down shoe stile`

⍣ - `index [ 353 ] - apl functional symbol left shoe stile`

⍤ - `index [ 354 ] - apl functional symbol tilde diaeresis`

⍥ - `index [ 355 ] - apl functional symbol greater-than diaeresis`

⍦ - `index [ 356 ] - apl functional symbol comma bar`

⍧ - `index [ 357 ] - apl functional symbol del tilde`

⍨ - `index [ 358 ] - apl functional symbol zilde`

⍩ - `index [ 359 ] - apl functional symbol stile tilde`

⍪ - `index [ 360 ] - apl functional symbol semicolon underbar`

⍫ - `index [ 361 ] - apl functional symbol quad not equal`

⍬ - `index [ 362 ] - apl functional symbol quad question`

⍭ - `index [ 363 ] - apl functional symbol down caret tilde`

⍮ - `index [ 364 ] - apl functional symbol up caret tilde`

⍯ - `index [ 365 ] - apl functional symbol i beam tilde`

⍰ - `index [ 366 ] - apl functional symbol del tilde operator`

⍱ - `index [ 367 ] - apl functional symbol rightwards vane`

⍲ - `index [ 368 ] - apl functional symbol rightwards diams arrow`

⍳ - `index [ 369 ] - apl functional symbol quad leftwards arrow`

⍴ - `index [ 370 ] - apl functional symbol quad rightwards arrow`

⍵ - `index [ 371 ] - apl functional symbol circle backslash`

⍶ - `index [ 372 ] - apl functional symbol down tack underbar`

⍷ - `index [ 373 ] - apl functional symbol delta stile`

⍸ - `index [ 374 ] - apl functional symbol quad down caret`

⍹ - `index [ 375 ] - apl functional symbol quad delta`

⍺ - `index [ 376 ] - apl functional symbol down tack jot`

⍻ - `index [ 377 ] - apl functional symbol upwards vane`

⍼ - `index [ 378 ] - apl functional symbol quad upwards arrow`

⍽ - `index [ 379 ] - apl functional symbol up tack overbar`

⍾ - `index [ 380 ] - apl functional symbol del stile`

⍿ - `index [ 381 ] - apl functional symbol quad up caret`

⎀ - `index [ 382 ] - apl functional symbol quad del`

⎁ - `index [ 383 ] - apl functional symbol up tack jot`

⎂ - `index [ 384 ] - apl functional symbol downwards vane`

⎃ - `index [ 385 ] - apl functional symbol quad downwards arrow`

⎄ - `index [ 386 ] - apl functional symbol quote underbar`

⎅ - `index [ 387 ] - apl functional symbol delta underbar`

⎆ - `index [ 388 ] - apl functional symbol diamond underbar`

⎇ - `index [ 389 ] - apl functional symbol jot underbar`

⎈ - `index [ 390 ] - apl functional symbol circle underbar`

⎉ - `index [ 391 ] - apl functional symbol up shoe jot`

⎊ - `index [ 392 ] - apl functional symbol quote quad`

⎋ - `index [ 393 ] - apl functional symbol circle star`

⎌ - `index [ 394 ] - apl functional symbol quad colon`

⎍ - `index [ 395 ] - apl functional symbol up tack diaeresis`

⎎ - `index [ 396 ] - apl functional symbol del diaeresis`

⎏ - `index [ 397 ] - apl functional symbol star diaeresis`

⎐ - `index [ 398 ] - apl functional symbol jot diaeresis`

⎑ - `index [ 399 ] - apl functional symbol circle diaeresis`

⎒ - `index [ 400 ] - apl functional symbol down shoe stile`

⎓ - `index [ 401 ] - apl functional symbol left shoe stile`

⎔ - `index [ 402 ] - apl functional symbol tilde diaeresis`

⎕ - `index [ 403 ] - apl functional symbol greater-than diaeresis`

⎖ - `index [ 404 ] - apl functional symbol comma bar`

⎗ - `index [ 405 ] - apl functional symbol del tilde`

⎘ - `index [ 406 ] - apl functional symbol zilde`

⎙ - `index [ 407 ] - apl functional symbol stile tilde`

⎚ - `index [ 408 ] - apl functional symbol semicolon underbar`

⎛ - `index [ 409 ] - left parenthesis upper hook`

⎜ - `index [ 410 ] - left parenthesis extension`

⎝ - `index [ 411 ] - left parenthesis lower hook`

⎞ - `index [ 412 ] - right parenthesis upper hook`

⎟ - `index [ 413 ] - right parenthesis extension`

⎠ - `index [ 414 ] - right parenthesis lower hook`

⎡ - `index [ 415 ] - left square bracket upper corner`

⎢ - `index [ 416 ] - left square bracket extension`

⎣ - `index [ 417 ] - left square bracket lower corner`

⎤ - `index [ 418 ] - right square bracket upper corner`

⎥ - `index [ 419 ] - right square bracket extension`

⎦ - `index [ 420 ] - right square bracket lower corner`

⎧ - `index [ 421 ] - left curly bracket upper hook`

⎨ - `index [ 422 ] - left curly bracket middle piece`

⎩ - `index [ 423 ] - left curly bracket lower hook`

⎪ - `index [ 424 ] - curly bracket extension`

⎫ - `index [ 425 ] - right curly bracket upper hook`

⎬ - `index [ 426 ] - right curly bracket middle piece`

⎭ - `index [ 427 ] - right curly bracket lower hook`

⎮ - `index [ 428 ] - integral extension`

⎯ - `index [ 429 ] - horizontal line extension`

⎰ - `index [ 430 ] - upper left or lower right curly bracket section`

⎱ - `index [ 431 ] - upper right or lower left curly bracket section`

⎲ - `index [ 432 ] - summation top`

⎳ - `index [ 433 ] - summation bottom`

⎴ - `index [ 434 ] - top square bracket`

⎵ - `index [ 435 ] - bottom square bracket`

⎶ - `index [ 436 ] - bottom square bracket over top square bracket`

⎷ - `index [ 437 ] - radical symbol bottom`

⎸ - `index [ 438 ] - left vertical box line`

⎹ - `index [ 439 ] - right vertical box line`

⎺ - `index [ 440 ] - horizontal scan line-1`

⎻ - `index [ 441 ] - horizontal scan line-3`

⎼ - `index [ 442 ] - horizontal scan line-7`

⎽ - `index [ 443 ] - horizontal scan line-9`

`Documentation - BasicCalculations`

Methods

`add(a, b)`

Adds two numbers.

Parameters:

a (number): The first number.
b (number): The second number.

Returns:

(number) The sum of the two numbers.

Examples:

Adding 2 and 3:

const sum1 = BasicCalculations.add(2, 3);
console.log(sum1); // Output: 5

Adding -10 and 5:

const sum2 = BasicCalculations.add(-10, 5);
console.log(sum2); // Output: -5

Adding decimal numbers 1.5 and 2.75:

const sum3 = BasicCalculations.add(1.5, 2.75);
console.log(sum3); // Output: 4.25

`subtract(a, b)`

subtract(a, b) Subtracts two numbers.

Parameters:

a (number): The number to subtract from.
b (number): The number to be subtracted. Returns:

(number) The difference between the two numbers. Examples:

Subtracting 5 from 10:

const diff1 = BasicCalculations.subtract(10, 5);
console.log(diff1); // Output: 5

Subtracting -3 from -2:

const diff2 = BasicCalculations.subtract(-3, -2);
console.log(diff2); // Output: -1

Subtracting decimal numbers 3.14 from 5.5:

const diff3 = BasicCalculations.subtract(5.5, 3.14);
console.log(diff3); // Output: 2.36

`multiply(a, b)`

multiply(a, b) Multiplies two numbers.

Parameters:

a (number): The first number.
b (number): The second number. Returns:

(number) The product of the two numbers. Examples:

Multiplying 2 by 3:

const product1 = BasicCalculations.multiply(2, 3);
console.log(product1); // Output: 6

Multiplying -4 by 5:

const product2 = BasicCalculations.multiply(-4, 5);
console.log(product2); // Output: -20

Multiplying decimal numbers 2.5 by 1.2:

const product3 = BasicCalculations.multiply(2.5, 1.2);
console.log(product3); // Output: 3

`divide(a, b)`

divide(a, b) Divides two numbers.

Parameters:

a (number): The dividend.
b (number): The divisor. Returns:

(number) The quotient of the division. Examples:

Dividing 10 by 2:

const quotient1 = BasicCalculations.divide(10, 2);
console.log(quotient1); // Output: 5

Dividing -8 by 4:

const quotient2 = BasicCalculations.divide(-8, 4);
console.log(quotient2); // Output: -2

Dividing decimal numbers 3.6 by 1.2:

const quotient3 = BasicCalculations.divide(3.6, 1.2);
console.log(quotient3); // Output: 3

`power(base, exponent)`

power(base, exponent) Raises a number to the given power.

Parameters:

base (number): The base number.
exponent (number): The exponent to raise the base to. Returns:

(number) The result of the exponentiation. Examples:

Raising 2 to the power of 3:

const power1 = BasicCalculations.power(2, 3);
console.log(power1); // Output: 8

Raising -2 to the power of 4:

const power2 = BasicCalculations.power(-2, 4);
console.log(power2); // Output: 16

Raising decimal number 1.5 to the power of 2:

const power3 = BasicCalculations.power(1.5, 2);
console.log(power3); // Output: 2.25

`squareRoot(number)`

square(number) Raises a number to the power of 2.

Parameters:

number (number): The number to square. Returns:

(number) The square of the number. Examples:

Squaring 4:

const square1 = BasicCalculations.square(4);
console.log(square1); // Output: 16

Squaring -3:

const square2 = BasicCalculations.square(-3);
console.log(square2); // Output: 9

Squaring decimal number 2.5:

const square3 = BasicCalculations.square(2.5);
console.log(square3); // Output: 6.25

`simplifyFraction(numerator, denominator)`

simplifyFraction(numerator, denominator) Simplifies a fraction.

Parameters:

numerator (number): The numerator of the fraction.
denominator (number): The denominator of the fraction. Returns:

(string) The simplified fraction as a string, or "Invalid fraction" if the denominator is zero. Examples:

Simplifying the fraction 4/8:

const fraction1 = BasicCalculations.simplifyFraction(4, 8);
console.log(fraction1); // Output: "1/2"

Simplifying the fraction -6/12:

const fraction2 = BasicCalculations.simplifyFraction(-6, 12);
console.log(fraction2); // Output: "-1/2"

Simplifying the fraction 3/0 (invalid fraction):

const fraction3 = BasicCalculations.simplifyFraction(3, 0);
console.log(fraction3); // Output: "Invalid fraction"

`gcd(a, b)`

Calculates the greatest common divisor (GCD) of two numbers using the Euclidean algorithm.

Parameters:

a (number): The first number.
b (number): The second number. Returns:

(number) The greatest common divisor (GCD) of the two numbers. Examples:

Calculating the GCD of 24 and 36:

const gcd1 = BasicCalculations.gcd(24, 36);
console.log(gcd1); // Output: 12

Calculating the GCD of 15 and 25:

const gcd2 = BasicCalculations.gcd(15, 25);
console.log(gcd2); // Output: 5

Calculating the GCD of -18 and 24:

const gcd3 = BasicCalculations.gcd(-18, 24);
console.log(gcd3); // Output: 6

`Documentation - Conversions Class`

Library for unit Conversions. Provides methods for converting between different units of measurement.

Conversions

`quetta(Q)`

Converts the given value to Quetta (Q).

Q (number): The value to be converted.
Returns (number): The value converted to Quetta.

Example:

const valueInQuetta = Conversions.quetta(10);
console.log(valueInQuetta); // 1e+31
//
const valueInQuetta = Conversions.quetta(1);
console.log(valueInQuetta); // 1e+30
//
const valueInQuetta = Conversions.quetta(0.5);
console.log(valueInQuetta); // 5e+29

Plausible Error Operations: quetta: Does not accept negative sign.

`ronna (R)`

Converts the given value to Ronna (R).

R (number): The value to be converted.
Returns (number): The value converted to Ronna. Example:

const valueInRonna = Conversions.ronna(10);
console.log(valueInRonna); // Output: 1e+28
//
const valueInRonna = Conversions.ronna(1);
console.log(valueInRonna); // Output: 1e+27
//
const valueInRonna = Conversions.ronna(0.5);
console.log(valueInRonna); // Output: 5e+26

Plausible Error Operations: ronna: Does not accept negative sign.

`yotta(Y)`

Y (number): The value to be converted.
Returns (number): The value converted to Yotta. Example:

const valueInYotta = Conversions.yotta(10);
console.log(valueInYotta); // Output: 10e+24
//
const valueInYotta = Conversions.yotta(1);
console.log(valueInYotta); // Output: 1e+24
//
const valueInYotta = Conversions.yotta(0.5);
console.log(valueInYotta); // Output: 5e+23

Plausible Error Operations: yotta: Does not accept negative sign.

`zetta(Z)`

Z (number): The value to be converted.
Returns (number): The value converted to Zetta. Example:

const valueInZetta = Conversions.zetta(10);
console.log(valueInZetta); // Output: 10e+21
//
const valueInZetta = Conversions.zetta(1);
console.log(valueInZetta); // Output: 1e+21
//
const valueInZetta = Conversions.zetta(0.5);
console.log(valueInZetta); // Output: 5e+20

Plausible Error Operations: zetta: Does not accept negative sign.

`exa(E)`

E (number): The value to be converted.
Returns (number): The value converted to Exa. Example:

const valueInExa = Conversions.exa(10);
console.log(valueInExa);
// Output: 10e+18
//10000000000000000000

const valueInExa = Conversions.exa(1);
console.log(valueInExa);
// Output: 1e+18
//1000000000000000000

const valueInExa = Conversions.exa(0.5);
console.log(valueInExa);
// Output: 5e+17
//500000000000000000

Plausible Error Operations: exa: Does not accept negative sign.

`peta(P)`

P (number): The value to be converted.
Returns (number): The value converted to Peta. Example:

const valueInPeta = Conversions.peta(10);
console.log(valueInPeta);
// Output: 10e+15
//10000000000000000

const valueInPeta = Conversions.peta(1);
console.log(valueInPeta);
// Output: 1e+15
//1000000000000000

const valueInPeta = Conversions.peta(0.5);
console.log(valueInPeta);
// Output: 5e+14
//500000000000000

Plausible Error Operations: peta: Does not accept negative sign.

`tera(T)`

T (number): The value to be converted.
Returns (number): The value converted to Tera. Example:

const valueInTera = Conversions.tera(10);
console.log(valueInTera);
// Output: 10e+12
//10000000000000

const valueInTera = Conversions.tera(1);
console.log(valueInTera);
// Output: 1e+12
//1000000000000

const valueInTera = Conversions.tera(0.5);
console.log(valueInTera);
// Output: 5e+11
//500000000000

Plausible Error Operations: tera: Does not accept negative sign.

`giga(G)`

G (number): The value to be converted.
Returns (number): The value converted to Giga. Example:

const valueInGiga = Conversions.giga(10);
console.log(valueInGiga);
// Output: 10e+9
//10000000000

const valueInGiga = Conversions.giga(1);
console.log(valueInGiga);
// Output: 1e+9
//1000000000

const valueInGiga = Conversions.giga(0.5);
console.log(valueInGiga);
// Output: 5e+8
//500000000

Plausible Error Operations: giga: Does not accept negative sign.

`mega(M)`

M (number): The value to be converted.
Returns (number): The value converted to Mega. Example:

const valueInMega = Conversions.mega(10);
console.log(valueInMega);
// Output: 10e+6
//10000000

const valueInMega = Conversions.mega(1);
console.log(valueInMega);
// Output: 1e+6
//1000000

const valueInMega = Conversions.mega(0.5);
console.log(valueInMega);
// Output: 5e+5
//500000

Plausible Error Operations: mega: Does not accept negative sign.

`kilo(k)`

k (number): The value to be converted.
Returns (number): The value converted to Kilo. Example:

const valueInKilo = Conversions.kilo(10);
console.log(valueInKilo);
// Output: 10000
//10000

const valueInKilo = Conversions.kilo(1);
console.log(valueInKilo);
// Output: 1000
//1000

const valueInKilo = Conversions.kilo(0.5);
console.log(valueInKilo);
// Output: 500
//500

Plausible Error Operations: kilo: Does not accept negative sign.

`hecto(h)`

h (number): The value to be converted.
Returns (number): The value converted to Hecto. Example:

const valueInHecto = Conversions.hecto(10);
console.log(valueInHecto);
// Output: 1000

const valueInHecto = Conversions.hecto(1);
console.log(valueInHecto);
// Output: 100

const valueInHecto = Conversions.hecto(0.5);
console.log(valueInHecto);
// Output: 50

Plausible Error Operations: hecto: Does not accept negative sign.

`deca(da)`

da (number): The value to be converted.
Returns (number): The value converted to Deca. Example:

const valueInDeca = Conversions.deca(10);
console.log(valueInDeca);
// Output: 100

const valueInDeca = Conversions.deca(1);
console.log(valueInDeca);
// Output: 10

const valueInDeca = Conversions.deca(0.5);
console.log(valueInDeca);
// Output: 5

Plausible Error Operations: deca: Does not accept negative sign.

`meter(m)`

m (number): The value to be converted.
Returns (number): The value converted to Meter. Example:

const valueInMeter = Conversions.meter(10);
console.log(valueInMeter);
// Output: 10

const valueInMeter = Conversions.meter(1);
console.log(valueInMeter);
// Output: 1

const valueInMeter = Conversions.meter(0.5);
console.log(valueInMeter);
// Output: 0.5

`deci(d)`

d (number): The value to be converted.
Returns (number): The value converted to Deci. Example:

const valueInDeci = Conversions.deci(10);
console.log(valueInDeci);
// Output: 1

const valueInDeci = Conversions.deci(1);
console.log(valueInDeci);
// Output: 0.1

const valueInDeci = Conversions.deci(0.5);
console.log(valueInDeci);
// Output: 0.05

Plausible Error Operations: deci: Does not allow any input of signs.

`centi(c)`

c (number): The value to be converted.
Returns (number): The value converted to Centi. Example:

const valueInCenti = Conversions.centi(10);
console.log(valueInCenti);
// Output: 0.1

const valueInCenti = Conversions.centi(1);
console.log(valueInCenti);
// Output: 0.01

const valueInCenti = Conversions.centi(0.5);
console.log(valueInCenti);
// Output: 0.005

Plausible Error Operations: centi: Does not allow any input of signs.

`milli(m)`

m (number): The value to be converted.
Returns (number): The value converted to Milli. Example:

const valueInMilli = Conversions.milli(10);
console.log(valueInMilli);
// Output: 0.01

const valueInMilli = Conversions.milli(1);
console.log(valueInMilli);
// Output: 0.001

const valueInMilli = Conversions.milli(0.5);
console.log(valueInMilli);
// Output: 0.0005

Plausible Error Operations: milli: Does not allow any input of signs.

`micro(µ)`

µ (number): The value to be converted.
Returns (number): The value converted to Micro. Example:

const valueInMicro = Conversions.micro(10);
console.log(valueInMicro);
// Output: 0.00001

const valueInMicro = Conversions.micro(1);
console.log(valueInMicro);
// Output: 0.000001

const valueInMicro = Conversions.micro(0.5);
console.log(valueInMicro);
// Output: 0.0000005

Plausible Error Operations: micro: Does not allow any input of signs.

`nano(n)`

n (number): The value to be converted.
Returns (number): The value converted to Nano. Example:

const valueInNano = Conversions.nano(10);
console.log(valueInNano);
// Output: 1e-8

const valueInNano = Conversions.nano(1);
console.log(valueInNano);
// Output: 1e-9

const valueInNano = Conversions.nano(0.5);
console.log(valueInNano);
// Output: 5e-10

Plausible Error Operations: nano: Does not allow any input of signs.

`pico(p)`

p (number): The value to be converted.
Returns (number): The value converted to Pico. Example:

const valueInPico = Conversions.p

@everything-registry/sub-chunk-2140

12 months ago

12 months ago

12 months ago

12 months ago

12 months ago

12 months ago

12 months ago

12 months ago

12 months ago

MathLab-Pro

Dive into Calculations 🎲

This library is a practical project from my web development course - thank you.

Installation

Usage

Documentation

Mathalphabets

getGreekAlphabetUppercase(indexOrText)

Parameters:

Returns:

Throws:

Example

getGreekAlphabetLowercase(indexOrText)

Parameters:

Returns:

Throws:

Example

getLatexAlphabetSymbol(index)

Parameters:

Return

Exceptions

Examples

Fraktur Alphabet

getFrakturAlphabetSymbol(indexOrText)

Returns:

Throws:

Example

mathematicalOperators(index)

Parameters

Return

Error Handling

Examples

∀ - index [ 000 ] - for all'

∁ - index [ 001 ] - complement'

∂ - index [ 002 ] - partial differential

∃ - index [ 003 ] - there exists

∄ - index [ 004 ] - there does not exist

∅ - index [ 005 ] - empty set

∆ - index [ 006 ] - increment

∇ - index [ 007 ] - nabla

∈ - index [ 008 ] - element of

∉ - index [ 009 ] - not an element of

∊ - index [ 010 ] - small element of

∋ - index [ 011 ] - contains as member

∌ - index [ 012 ] - does not contain as member

∍ - index [ 013 ] - small contains as member

∎ - index [ 014 ] - end of proof

∏ - index [ 015 ] - n-ary product

∐ - index [ 016 ] - n-ary coproduct

∑ - index [ 017 ] - n-ary summation

− - index [ 018 ] - minus sign

∓ - index [ 019 ] - minus-or-plus sign

∔ - index [ 020 ] - dot plus

∕ - index [ 021 ] - division slash

∖ - index [ 022 ] - set minus

∗ - index [ 023 ] - asterisk operator

∘ - index [ 024 ] - ring operator

∙ - index [ 025 ] - bullet operator

√ - index [ 026 ] - square root

∛ - index [ 027 ] - cube root

∜ - index [ 028 ] - fourth root

∝ - index [ 029 ] - proportional to

∞ - index [ 030 ] - infinity

∟ - index [ 031 ] - right angle

∠ - index [ 032 ] - angle

∡ - index [ 033 ] - measured angle

∢ - index [ 034 ] - spherical angle

∣ - index [ 035 ] - divides

∤ - index [ 036 ] - does not divide

∥ - index [ 037 ] - parallel to

∦ - index [ 038 ] - not parallel to

∧ - index [ 039 ] - logical and

∨ - index [ 040 ] - logical or

∩ - index [ 041 ] - intersection

∪ - index [ 042 ] - union

∫ - index [ 043 ] - integral

∬ - index [ 044 ] - double integral

∭ - index [ 045 ] - triple integral

∮ - index [ 046 ] - contour integral

∯ - index [ 047 ] - surface integral

`This library is a practical project from my web development course - thank you.`

`Mathalphabets`

`getGreekAlphabetUppercase(indexOrText)`

`getGreekAlphabetLowercase(indexOrText)`

`getLatexAlphabetSymbol(index)`

`Fraktur Alphabet`

`getFrakturAlphabetSymbol(indexOrText)`

`mathematicalOperators(index)`

∀ - `index [ 000 ] - for all'`

∁ - `index [ 001 ] - complement'`

∂ - `index [ 002 ] - partial differential`

∃ - `index [ 003 ] - there exists`

∄ - `index [ 004 ] - there does not exist`

∅ - `index [ 005 ] - empty set`

∆ - `index [ 006 ] - increment`

∇ - `index [ 007 ] - nabla`

∈ - `index [ 008 ] - element of`

∉ - `index [ 009 ] - not an element of`

∊ - `index [ 010 ] - small element of`

∋ - `index [ 011 ] - contains as member`

∌ - `index [ 012 ] - does not contain as member`

∍ - `index [ 013 ] - small contains as member`

∎ - `index [ 014 ] - end of proof`

∏ - `index [ 015 ] - n-ary product`

∐ - `index [ 016 ] - n-ary coproduct`

∑ - `index [ 017 ] - n-ary summation`

− - `index [ 018 ] - minus sign`

∓ - `index [ 019 ] - minus-or-plus sign`

∔ - `index [ 020 ] - dot plus`

∕ - `index [ 021 ] - division slash`

∖ - `index [ 022 ] - set minus`

∗ - `index [ 023 ] - asterisk operator`

∘ - `index [ 024 ] - ring operator`

∙ - `index [ 025 ] - bullet operator`

√ - `index [ 026 ] - square root`

∛ - `index [ 027 ] - cube root`

∜ - `index [ 028 ] - fourth root`

∝ - `index [ 029 ] - proportional to`

∞ - `index [ 030 ] - infinity`

∟ - `index [ 031 ] - right angle`

∠ - `index [ 032 ] - angle`

∡ - `index [ 033 ] - measured angle`

∢ - `index [ 034 ] - spherical angle`

∣ - `index [ 035 ] - divides`

∤ - `index [ 036 ] - does not divide`

∥ - `index [ 037 ] - parallel to`

∦ - `index [ 038 ] - not parallel to`

∧ - `index [ 039 ] - logical and`

∨ - `index [ 040 ] - logical or`

∩ - `index [ 041 ] - intersection`

∪ - `index [ 042 ] - union`

∫ - `index [ 043 ] - integral`

∬ - `index [ 044 ] - double integral`

∭ - `index [ 045 ] - triple integral`

∮ - `index [ 046 ] - contour integral`

∯ - `index [ 047 ] - surface integral`

∰ - `index [ 048 ] - volume integral`

∱ - `index [ 049 ] - clockwise integral`

∲ - `index [ 050 ] - clockwise contour integral`

∳ - `index [ 051 ] - anticlockwise contour integral`

∴ - `index [ 052 ] - therefore`

∵ - `index [ 053 ] - because`

∶ - `index [ 054 ] - ratio`

∷ - `index [ 055 ] - proportion`

∸ - `index [ 056 ] - dot minus`

∹ - `index [ 057 ] - excess`

∺ - `index [ 058 ] - geometric proportion`

∻ - `index [ 059 ] - homothetic`

∼ - `index [ 060 ] - tilde operator`

∽ - `index [ 061 ] - reversed tilde`

∾ - `index [ 062 ] - inverted lazy`

∿ - `index [ 063 ] - sine wave`

≀ - `index [ 064 ] - wreath product`

≁ - `index [ 065 ] - not tilde`

≂ - `index [ 066 ] - minus tilde`

≃ - `index [ 067 ] - asymptotically equal to`

≄ - `index [ 068 ] - not asymptotically equal to`

≅ - `index [ 069 ] - approximately equal to`

≆ - `index [ 070 ] - approximately but not actually equal to`

≇ - `index [ 071 ] - neither approximately nor actually equal to`