fraction.js
Advanced tools
Comparing version 4.3.4 to 4.3.5
1310
fraction.js
/** | ||
* @license Fraction.js v4.3.0 20/08/2023 | ||
* @license Fraction.js v4.3.5 31/08/2023 | ||
* https://www.xarg.org/2014/03/rational-numbers-in-javascript/ | ||
@@ -40,849 +40,835 @@ * | ||
(function(root) { | ||
"use strict"; | ||
// Maximum search depth for cyclic rational numbers. 2000 should be more than enough. | ||
// Example: 1/7 = 0.(142857) has 6 repeating decimal places. | ||
// If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits | ||
var MAX_CYCLE_LEN = 2000; | ||
// Maximum search depth for cyclic rational numbers. 2000 should be more than enough. | ||
// Example: 1/7 = 0.(142857) has 6 repeating decimal places. | ||
// If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits | ||
var MAX_CYCLE_LEN = 2000; | ||
// Parsed data to avoid calling "new" all the time | ||
var P = { | ||
"s": 1, | ||
"n": 0, | ||
"d": 1 | ||
}; | ||
// Parsed data to avoid calling "new" all the time | ||
var P = { | ||
"s": 1, | ||
"n": 0, | ||
"d": 1 | ||
}; | ||
function assign(n, s) { | ||
function assign(n, s) { | ||
if (isNaN(n = parseInt(n, 10))) { | ||
throw InvalidParameter(); | ||
} | ||
return n * s; | ||
if (isNaN(n = parseInt(n, 10))) { | ||
throw InvalidParameter(); | ||
} | ||
return n * s; | ||
} | ||
// Creates a new Fraction internally without the need of the bulky constructor | ||
function newFraction(n, d) { | ||
// Creates a new Fraction internally without the need of the bulky constructor | ||
function newFraction(n, d) { | ||
if (d === 0) { | ||
throw DivisionByZero(); | ||
} | ||
if (d === 0) { | ||
throw DivisionByZero(); | ||
} | ||
var f = Object.create(Fraction.prototype); | ||
f["s"] = n < 0 ? -1 : 1; | ||
var f = Object.create(Fraction.prototype); | ||
f["s"] = n < 0 ? -1 : 1; | ||
n = n < 0 ? -n : n; | ||
n = n < 0 ? -n : n; | ||
var a = gcd(n, d); | ||
var a = gcd(n, d); | ||
f["n"] = n / a; | ||
f["d"] = d / a; | ||
return f; | ||
} | ||
f["n"] = n / a; | ||
f["d"] = d / a; | ||
return f; | ||
} | ||
function factorize(num) { | ||
function factorize(num) { | ||
var factors = {}; | ||
var factors = {}; | ||
var n = num; | ||
var i = 2; | ||
var s = 4; | ||
var n = num; | ||
var i = 2; | ||
var s = 4; | ||
while (s <= n) { | ||
while (s <= n) { | ||
while (n % i === 0) { | ||
n/= i; | ||
factors[i] = (factors[i] || 0) + 1; | ||
} | ||
s+= 1 + 2 * i++; | ||
while (n % i === 0) { | ||
n/= i; | ||
factors[i] = (factors[i] || 0) + 1; | ||
} | ||
s+= 1 + 2 * i++; | ||
} | ||
if (n !== num) { | ||
if (n > 1) | ||
factors[n] = (factors[n] || 0) + 1; | ||
} else { | ||
factors[num] = (factors[num] || 0) + 1; | ||
} | ||
return factors; | ||
if (n !== num) { | ||
if (n > 1) | ||
factors[n] = (factors[n] || 0) + 1; | ||
} else { | ||
factors[num] = (factors[num] || 0) + 1; | ||
} | ||
return factors; | ||
} | ||
var parse = function(p1, p2) { | ||
var parse = function(p1, p2) { | ||
var n = 0, d = 1, s = 1; | ||
var v = 0, w = 0, x = 0, y = 1, z = 1; | ||
var n = 0, d = 1, s = 1; | ||
var v = 0, w = 0, x = 0, y = 1, z = 1; | ||
var A = 0, B = 1; | ||
var C = 1, D = 1; | ||
var A = 0, B = 1; | ||
var C = 1, D = 1; | ||
var N = 10000000; | ||
var M; | ||
var N = 10000000; | ||
var M; | ||
if (p1 === undefined || p1 === null) { | ||
/* void */ | ||
} else if (p2 !== undefined) { | ||
n = p1; | ||
d = p2; | ||
s = n * d; | ||
if (p1 === undefined || p1 === null) { | ||
/* void */ | ||
} else if (p2 !== undefined) { | ||
n = p1; | ||
d = p2; | ||
s = n * d; | ||
if (n % 1 !== 0 || d % 1 !== 0) { | ||
throw NonIntegerParameter(); | ||
} | ||
if (n % 1 !== 0 || d % 1 !== 0) { | ||
throw NonIntegerParameter(); | ||
} | ||
} else | ||
switch (typeof p1) { | ||
} else | ||
switch (typeof p1) { | ||
case "object": | ||
{ | ||
if ("d" in p1 && "n" in p1) { | ||
n = p1["n"]; | ||
d = p1["d"]; | ||
if ("s" in p1) | ||
n*= p1["s"]; | ||
} else if (0 in p1) { | ||
n = p1[0]; | ||
if (1 in p1) | ||
d = p1[1]; | ||
} else { | ||
throw InvalidParameter(); | ||
} | ||
s = n * d; | ||
break; | ||
case "object": | ||
{ | ||
if ("d" in p1 && "n" in p1) { | ||
n = p1["n"]; | ||
d = p1["d"]; | ||
if ("s" in p1) | ||
n*= p1["s"]; | ||
} else if (0 in p1) { | ||
n = p1[0]; | ||
if (1 in p1) | ||
d = p1[1]; | ||
} else { | ||
throw InvalidParameter(); | ||
} | ||
case "number": | ||
{ | ||
if (p1 < 0) { | ||
s = p1; | ||
p1 = -p1; | ||
} | ||
s = n * d; | ||
break; | ||
} | ||
case "number": | ||
{ | ||
if (p1 < 0) { | ||
s = p1; | ||
p1 = -p1; | ||
} | ||
if (p1 % 1 === 0) { | ||
n = p1; | ||
} else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow | ||
if (p1 % 1 === 0) { | ||
n = p1; | ||
} else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow | ||
if (p1 >= 1) { | ||
z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10)); | ||
p1/= z; | ||
} | ||
if (p1 >= 1) { | ||
z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10)); | ||
p1/= z; | ||
} | ||
// Using Farey Sequences | ||
// http://www.johndcook.com/blog/2010/10/20/best-rational-approximation/ | ||
// Using Farey Sequences | ||
// http://www.johndcook.com/blog/2010/10/20/best-rational-approximation/ | ||
while (B <= N && D <= N) { | ||
M = (A + C) / (B + D); | ||
while (B <= N && D <= N) { | ||
M = (A + C) / (B + D); | ||
if (p1 === M) { | ||
if (B + D <= N) { | ||
n = A + C; | ||
d = B + D; | ||
} else if (D > B) { | ||
n = C; | ||
d = D; | ||
} else { | ||
n = A; | ||
d = B; | ||
} | ||
break; | ||
if (p1 === M) { | ||
if (B + D <= N) { | ||
n = A + C; | ||
d = B + D; | ||
} else if (D > B) { | ||
n = C; | ||
d = D; | ||
} else { | ||
n = A; | ||
d = B; | ||
} | ||
break; | ||
if (p1 > M) { | ||
A+= C; | ||
B+= D; | ||
} else { | ||
C+= A; | ||
D+= B; | ||
} | ||
} else { | ||
if (B > N) { | ||
n = C; | ||
d = D; | ||
} else { | ||
n = A; | ||
d = B; | ||
} | ||
if (p1 > M) { | ||
A+= C; | ||
B+= D; | ||
} else { | ||
C+= A; | ||
D+= B; | ||
} | ||
if (B > N) { | ||
n = C; | ||
d = D; | ||
} else { | ||
n = A; | ||
d = B; | ||
} | ||
} | ||
n*= z; | ||
} else if (isNaN(p1) || isNaN(p2)) { | ||
d = n = NaN; | ||
} | ||
break; | ||
n*= z; | ||
} else if (isNaN(p1) || isNaN(p2)) { | ||
d = n = NaN; | ||
} | ||
case "string": | ||
{ | ||
B = p1.match(/\d+|./g); | ||
break; | ||
} | ||
case "string": | ||
{ | ||
B = p1.match(/\d+|./g); | ||
if (B === null) | ||
throw InvalidParameter(); | ||
if (B === null) | ||
throw InvalidParameter(); | ||
if (B[A] === '-') {// Check for minus sign at the beginning | ||
s = -1; | ||
A++; | ||
} else if (B[A] === '+') {// Check for plus sign at the beginning | ||
A++; | ||
} | ||
if (B[A] === '-') {// Check for minus sign at the beginning | ||
s = -1; | ||
A++; | ||
} else if (B[A] === '+') {// Check for plus sign at the beginning | ||
A++; | ||
} | ||
if (B.length === A + 1) { // Check if it's just a simple number "1234" | ||
w = assign(B[A++], s); | ||
} else if (B[A + 1] === '.' || B[A] === '.') { // Check if it's a decimal number | ||
if (B.length === A + 1) { // Check if it's just a simple number "1234" | ||
w = assign(B[A++], s); | ||
} else if (B[A + 1] === '.' || B[A] === '.') { // Check if it's a decimal number | ||
if (B[A] !== '.') { // Handle 0.5 and .5 | ||
v = assign(B[A++], s); | ||
} | ||
A++; | ||
if (B[A] !== '.') { // Handle 0.5 and .5 | ||
v = assign(B[A++], s); | ||
} | ||
A++; | ||
// Check for decimal places | ||
if (A + 1 === B.length || B[A + 1] === '(' && B[A + 3] === ')' || B[A + 1] === "'" && B[A + 3] === "'") { | ||
w = assign(B[A], s); | ||
y = Math.pow(10, B[A].length); | ||
A++; | ||
} | ||
// Check for repeating places | ||
if (B[A] === '(' && B[A + 2] === ')' || B[A] === "'" && B[A + 2] === "'") { | ||
x = assign(B[A + 1], s); | ||
z = Math.pow(10, B[A + 1].length) - 1; | ||
A+= 3; | ||
} | ||
} else if (B[A + 1] === '/' || B[A + 1] === ':') { // Check for a simple fraction "123/456" or "123:456" | ||
// Check for decimal places | ||
if (A + 1 === B.length || B[A + 1] === '(' && B[A + 3] === ')' || B[A + 1] === "'" && B[A + 3] === "'") { | ||
w = assign(B[A], s); | ||
y = assign(B[A + 2], 1); | ||
A+= 3; | ||
} else if (B[A + 3] === '/' && B[A + 1] === ' ') { // Check for a complex fraction "123 1/2" | ||
v = assign(B[A], s); | ||
w = assign(B[A + 2], s); | ||
y = assign(B[A + 4], 1); | ||
A+= 5; | ||
y = Math.pow(10, B[A].length); | ||
A++; | ||
} | ||
if (B.length <= A) { // Check for more tokens on the stack | ||
d = y * z; | ||
s = /* void */ | ||
n = x + d * v + z * w; | ||
break; | ||
// Check for repeating places | ||
if (B[A] === '(' && B[A + 2] === ')' || B[A] === "'" && B[A + 2] === "'") { | ||
x = assign(B[A + 1], s); | ||
z = Math.pow(10, B[A + 1].length) - 1; | ||
A+= 3; | ||
} | ||
/* Fall through on error */ | ||
} else if (B[A + 1] === '/' || B[A + 1] === ':') { // Check for a simple fraction "123/456" or "123:456" | ||
w = assign(B[A], s); | ||
y = assign(B[A + 2], 1); | ||
A+= 3; | ||
} else if (B[A + 3] === '/' && B[A + 1] === ' ') { // Check for a complex fraction "123 1/2" | ||
v = assign(B[A], s); | ||
w = assign(B[A + 2], s); | ||
y = assign(B[A + 4], 1); | ||
A+= 5; | ||
} | ||
default: | ||
throw InvalidParameter(); | ||
} | ||
if (d === 0) { | ||
throw DivisionByZero(); | ||
if (B.length <= A) { // Check for more tokens on the stack | ||
d = y * z; | ||
s = /* void */ | ||
n = x + d * v + z * w; | ||
break; | ||
} | ||
/* Fall through on error */ | ||
} | ||
default: | ||
throw InvalidParameter(); | ||
} | ||
P["s"] = s < 0 ? -1 : 1; | ||
P["n"] = Math.abs(n); | ||
P["d"] = Math.abs(d); | ||
}; | ||
if (d === 0) { | ||
throw DivisionByZero(); | ||
} | ||
function modpow(b, e, m) { | ||
P["s"] = s < 0 ? -1 : 1; | ||
P["n"] = Math.abs(n); | ||
P["d"] = Math.abs(d); | ||
}; | ||
var r = 1; | ||
for (; e > 0; b = (b * b) % m, e >>= 1) { | ||
function modpow(b, e, m) { | ||
if (e & 1) { | ||
r = (r * b) % m; | ||
} | ||
var r = 1; | ||
for (; e > 0; b = (b * b) % m, e >>= 1) { | ||
if (e & 1) { | ||
r = (r * b) % m; | ||
} | ||
return r; | ||
} | ||
return r; | ||
} | ||
function cycleLen(n, d) { | ||
function cycleLen(n, d) { | ||
for (; d % 2 === 0; | ||
d/= 2) { | ||
} | ||
for (; d % 2 === 0; | ||
d/= 2) { | ||
} | ||
for (; d % 5 === 0; | ||
d/= 5) { | ||
} | ||
for (; d % 5 === 0; | ||
d/= 5) { | ||
} | ||
if (d === 1) // Catch non-cyclic numbers | ||
return 0; | ||
if (d === 1) // Catch non-cyclic numbers | ||
return 0; | ||
// If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem: | ||
// 10^(d-1) % d == 1 | ||
// However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone, | ||
// as we want to translate the numbers to strings. | ||
// If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem: | ||
// 10^(d-1) % d == 1 | ||
// However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone, | ||
// as we want to translate the numbers to strings. | ||
var rem = 10 % d; | ||
var t = 1; | ||
var rem = 10 % d; | ||
var t = 1; | ||
for (; rem !== 1; t++) { | ||
rem = rem * 10 % d; | ||
for (; rem !== 1; t++) { | ||
rem = rem * 10 % d; | ||
if (t > MAX_CYCLE_LEN) | ||
return 0; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1` | ||
} | ||
return t; | ||
if (t > MAX_CYCLE_LEN) | ||
return 0; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1` | ||
} | ||
return t; | ||
} | ||
function cycleStart(n, d, len) { | ||
function cycleStart(n, d, len) { | ||
var rem1 = 1; | ||
var rem2 = modpow(10, len, d); | ||
var rem1 = 1; | ||
var rem2 = modpow(10, len, d); | ||
for (var t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE) | ||
// Solve 10^s == 10^(s+t) (mod d) | ||
for (var t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE) | ||
// Solve 10^s == 10^(s+t) (mod d) | ||
if (rem1 === rem2) | ||
return t; | ||
if (rem1 === rem2) | ||
return t; | ||
rem1 = rem1 * 10 % d; | ||
rem2 = rem2 * 10 % d; | ||
} | ||
return 0; | ||
rem1 = rem1 * 10 % d; | ||
rem2 = rem2 * 10 % d; | ||
} | ||
return 0; | ||
} | ||
function gcd(a, b) { | ||
function gcd(a, b) { | ||
if (!a) | ||
return b; | ||
if (!b) | ||
return a; | ||
while (1) { | ||
a%= b; | ||
if (!a) | ||
return b; | ||
b%= a; | ||
if (!b) | ||
return a; | ||
} | ||
}; | ||
while (1) { | ||
a%= b; | ||
if (!a) | ||
return b; | ||
b%= a; | ||
if (!b) | ||
return a; | ||
} | ||
}; | ||
/** | ||
* Module constructor | ||
* | ||
* @constructor | ||
* @param {number|Fraction=} a | ||
* @param {number=} b | ||
*/ | ||
export default function Fraction(a, b) { | ||
/** | ||
* Module constructor | ||
* | ||
* @constructor | ||
* @param {number|Fraction=} a | ||
* @param {number=} b | ||
*/ | ||
function Fraction(a, b) { | ||
parse(a, b); | ||
parse(a, b); | ||
if (this instanceof Fraction) { | ||
a = gcd(P["d"], P["n"]); // Abuse variable a | ||
this["s"] = P["s"]; | ||
this["n"] = P["n"] / a; | ||
this["d"] = P["d"] / a; | ||
} else { | ||
return newFraction(P['s'] * P['n'], P['d']); | ||
} | ||
if (this instanceof Fraction) { | ||
a = gcd(P["d"], P["n"]); // Abuse variable a | ||
this["s"] = P["s"]; | ||
this["n"] = P["n"] / a; | ||
this["d"] = P["d"] / a; | ||
} else { | ||
return newFraction(P['s'] * P['n'], P['d']); | ||
} | ||
} | ||
var DivisionByZero = function() { return new Error("Division by Zero"); }; | ||
var InvalidParameter = function() { return new Error("Invalid argument"); }; | ||
var NonIntegerParameter = function() { return new Error("Parameters must be integer"); }; | ||
var DivisionByZero = function() { return new Error("Division by Zero"); }; | ||
var InvalidParameter = function() { return new Error("Invalid argument"); }; | ||
var NonIntegerParameter = function() { return new Error("Parameters must be integer"); }; | ||
Fraction.prototype = { | ||
Fraction.prototype = { | ||
"s": 1, | ||
"n": 0, | ||
"d": 1, | ||
"s": 1, | ||
"n": 0, | ||
"d": 1, | ||
/** | ||
* Calculates the absolute value | ||
* | ||
* Ex: new Fraction(-4).abs() => 4 | ||
**/ | ||
"abs": function() { | ||
/** | ||
* Calculates the absolute value | ||
* | ||
* Ex: new Fraction(-4).abs() => 4 | ||
**/ | ||
"abs": function() { | ||
return newFraction(this["n"], this["d"]); | ||
}, | ||
return newFraction(this["n"], this["d"]); | ||
}, | ||
/** | ||
* Inverts the sign of the current fraction | ||
* | ||
* Ex: new Fraction(-4).neg() => 4 | ||
**/ | ||
"neg": function() { | ||
/** | ||
* Inverts the sign of the current fraction | ||
* | ||
* Ex: new Fraction(-4).neg() => 4 | ||
**/ | ||
"neg": function() { | ||
return newFraction(-this["s"] * this["n"], this["d"]); | ||
}, | ||
return newFraction(-this["s"] * this["n"], this["d"]); | ||
}, | ||
/** | ||
* Adds two rational numbers | ||
* | ||
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30 | ||
**/ | ||
"add": function(a, b) { | ||
/** | ||
* Adds two rational numbers | ||
* | ||
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30 | ||
**/ | ||
"add": function(a, b) { | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"], | ||
this["d"] * P["d"] | ||
); | ||
}, | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"], | ||
this["d"] * P["d"] | ||
); | ||
}, | ||
/** | ||
* Subtracts two rational numbers | ||
* | ||
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30 | ||
**/ | ||
"sub": function(a, b) { | ||
/** | ||
* Subtracts two rational numbers | ||
* | ||
* Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30 | ||
**/ | ||
"sub": function(a, b) { | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"], | ||
this["d"] * P["d"] | ||
); | ||
}, | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"], | ||
this["d"] * P["d"] | ||
); | ||
}, | ||
/** | ||
* Multiplies two rational numbers | ||
* | ||
* Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111 | ||
**/ | ||
"mul": function(a, b) { | ||
/** | ||
* Multiplies two rational numbers | ||
* | ||
* Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111 | ||
**/ | ||
"mul": function(a, b) { | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * P["s"] * this["n"] * P["n"], | ||
this["d"] * P["d"] | ||
); | ||
}, | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * P["s"] * this["n"] * P["n"], | ||
this["d"] * P["d"] | ||
); | ||
}, | ||
/** | ||
* Divides two rational numbers | ||
* | ||
* Ex: new Fraction("-17.(345)").inverse().div(3) | ||
**/ | ||
"div": function(a, b) { | ||
/** | ||
* Divides two rational numbers | ||
* | ||
* Ex: new Fraction("-17.(345)").inverse().div(3) | ||
**/ | ||
"div": function(a, b) { | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * P["s"] * this["n"] * P["d"], | ||
this["d"] * P["n"] | ||
); | ||
}, | ||
parse(a, b); | ||
return newFraction( | ||
this["s"] * P["s"] * this["n"] * P["d"], | ||
this["d"] * P["n"] | ||
); | ||
}, | ||
/** | ||
* Clones the actual object | ||
* | ||
* Ex: new Fraction("-17.(345)").clone() | ||
**/ | ||
"clone": function() { | ||
return newFraction(this['s'] * this['n'], this['d']); | ||
}, | ||
/** | ||
* Clones the actual object | ||
* | ||
* Ex: new Fraction("-17.(345)").clone() | ||
**/ | ||
"clone": function() { | ||
return newFraction(this['s'] * this['n'], this['d']); | ||
}, | ||
/** | ||
* Calculates the modulo of two rational numbers - a more precise fmod | ||
* | ||
* Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6) | ||
**/ | ||
"mod": function(a, b) { | ||
/** | ||
* Calculates the modulo of two rational numbers - a more precise fmod | ||
* | ||
* Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6) | ||
**/ | ||
"mod": function(a, b) { | ||
if (isNaN(this['n']) || isNaN(this['d'])) { | ||
return new Fraction(NaN); | ||
} | ||
if (isNaN(this['n']) || isNaN(this['d'])) { | ||
return new Fraction(NaN); | ||
} | ||
if (a === undefined) { | ||
return newFraction(this["s"] * this["n"] % this["d"], 1); | ||
} | ||
if (a === undefined) { | ||
return newFraction(this["s"] * this["n"] % this["d"], 1); | ||
} | ||
parse(a, b); | ||
if (0 === P["n"] && 0 === this["d"]) { | ||
throw DivisionByZero(); | ||
} | ||
parse(a, b); | ||
if (0 === P["n"] && 0 === this["d"]) { | ||
throw DivisionByZero(); | ||
} | ||
/* | ||
* First silly attempt, kinda slow | ||
* | ||
return that["sub"]({ | ||
"n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)), | ||
"d": num["d"], | ||
"s": this["s"] | ||
});*/ | ||
/* | ||
* First silly attempt, kinda slow | ||
* | ||
return that["sub"]({ | ||
"n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)), | ||
"d": num["d"], | ||
"s": this["s"] | ||
});*/ | ||
/* | ||
* New attempt: a1 / b1 = a2 / b2 * q + r | ||
* => b2 * a1 = a2 * b1 * q + b1 * b2 * r | ||
* => (b2 * a1 % a2 * b1) / (b1 * b2) | ||
*/ | ||
return newFraction( | ||
this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]), | ||
P["d"] * this["d"] | ||
); | ||
}, | ||
/** | ||
* Calculates the fractional gcd of two rational numbers | ||
* | ||
* Ex: new Fraction(5,8).gcd(3,7) => 1/56 | ||
/* | ||
* New attempt: a1 / b1 = a2 / b2 * q + r | ||
* => b2 * a1 = a2 * b1 * q + b1 * b2 * r | ||
* => (b2 * a1 % a2 * b1) / (b1 * b2) | ||
*/ | ||
"gcd": function(a, b) { | ||
return newFraction( | ||
this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]), | ||
P["d"] * this["d"] | ||
); | ||
}, | ||
parse(a, b); | ||
/** | ||
* Calculates the fractional gcd of two rational numbers | ||
* | ||
* Ex: new Fraction(5,8).gcd(3,7) => 1/56 | ||
*/ | ||
"gcd": function(a, b) { | ||
// gcd(a / b, c / d) = gcd(a, c) / lcm(b, d) | ||
parse(a, b); | ||
return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]); | ||
}, | ||
// gcd(a / b, c / d) = gcd(a, c) / lcm(b, d) | ||
/** | ||
* Calculates the fractional lcm of two rational numbers | ||
* | ||
* Ex: new Fraction(5,8).lcm(3,7) => 15 | ||
*/ | ||
"lcm": function(a, b) { | ||
return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]); | ||
}, | ||
parse(a, b); | ||
/** | ||
* Calculates the fractional lcm of two rational numbers | ||
* | ||
* Ex: new Fraction(5,8).lcm(3,7) => 15 | ||
*/ | ||
"lcm": function(a, b) { | ||
// lcm(a / b, c / d) = lcm(a, c) / gcd(b, d) | ||
parse(a, b); | ||
if (P["n"] === 0 && this["n"] === 0) { | ||
return newFraction(0, 1); | ||
} | ||
return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"])); | ||
}, | ||
// lcm(a / b, c / d) = lcm(a, c) / gcd(b, d) | ||
/** | ||
* Calculates the ceil of a rational number | ||
* | ||
* Ex: new Fraction('4.(3)').ceil() => (5 / 1) | ||
**/ | ||
"ceil": function(places) { | ||
if (P["n"] === 0 && this["n"] === 0) { | ||
return newFraction(0, 1); | ||
} | ||
return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"])); | ||
}, | ||
places = Math.pow(10, places || 0); | ||
/** | ||
* Calculates the ceil of a rational number | ||
* | ||
* Ex: new Fraction('4.(3)').ceil() => (5 / 1) | ||
**/ | ||
"ceil": function(places) { | ||
if (isNaN(this["n"]) || isNaN(this["d"])) { | ||
return new Fraction(NaN); | ||
} | ||
return newFraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places); | ||
}, | ||
places = Math.pow(10, places || 0); | ||
/** | ||
* Calculates the floor of a rational number | ||
* | ||
* Ex: new Fraction('4.(3)').floor() => (4 / 1) | ||
**/ | ||
"floor": function(places) { | ||
if (isNaN(this["n"]) || isNaN(this["d"])) { | ||
return new Fraction(NaN); | ||
} | ||
return newFraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places); | ||
}, | ||
places = Math.pow(10, places || 0); | ||
/** | ||
* Calculates the floor of a rational number | ||
* | ||
* Ex: new Fraction('4.(3)').floor() => (4 / 1) | ||
**/ | ||
"floor": function(places) { | ||
if (isNaN(this["n"]) || isNaN(this["d"])) { | ||
return new Fraction(NaN); | ||
} | ||
return newFraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places); | ||
}, | ||
places = Math.pow(10, places || 0); | ||
/** | ||
* Rounds a rational numbers | ||
* | ||
* Ex: new Fraction('4.(3)').round() => (4 / 1) | ||
**/ | ||
"round": function(places) { | ||
if (isNaN(this["n"]) || isNaN(this["d"])) { | ||
return new Fraction(NaN); | ||
} | ||
return newFraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places); | ||
}, | ||
places = Math.pow(10, places || 0); | ||
/** | ||
* Rounds a rational numbers | ||
* | ||
* Ex: new Fraction('4.(3)').round() => (4 / 1) | ||
**/ | ||
"round": function(places) { | ||
if (isNaN(this["n"]) || isNaN(this["d"])) { | ||
return new Fraction(NaN); | ||
} | ||
return newFraction(Math.round(places * this["s"] * this["n"] / this["d"]), places); | ||
}, | ||
places = Math.pow(10, places || 0); | ||
/** | ||
* Gets the inverse of the fraction, means numerator and denominator are exchanged | ||
* | ||
* Ex: new Fraction([-3, 4]).inverse() => -4 / 3 | ||
**/ | ||
"inverse": function() { | ||
if (isNaN(this["n"]) || isNaN(this["d"])) { | ||
return new Fraction(NaN); | ||
} | ||
return newFraction(Math.round(places * this["s"] * this["n"] / this["d"]), places); | ||
}, | ||
return newFraction(this["s"] * this["d"], this["n"]); | ||
}, | ||
/** | ||
* Gets the inverse of the fraction, means numerator and denominator are exchanged | ||
* | ||
* Ex: new Fraction([-3, 4]).inverse() => -4 / 3 | ||
**/ | ||
"inverse": function() { | ||
/** | ||
* Calculates the fraction to some rational exponent, if possible | ||
* | ||
* Ex: new Fraction(-1,2).pow(-3) => -8 | ||
*/ | ||
"pow": function(a, b) { | ||
return newFraction(this["s"] * this["d"], this["n"]); | ||
}, | ||
parse(a, b); | ||
/** | ||
* Calculates the fraction to some rational exponent, if possible | ||
* | ||
* Ex: new Fraction(-1,2).pow(-3) => -8 | ||
*/ | ||
"pow": function(a, b) { | ||
// Trivial case when exp is an integer | ||
parse(a, b); | ||
if (P['d'] === 1) { | ||
// Trivial case when exp is an integer | ||
if (P['s'] < 0) { | ||
return newFraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n'])); | ||
} else { | ||
return newFraction(Math.pow(this['s'] * this["n"], P['n']), Math.pow(this["d"], P['n'])); | ||
} | ||
if (P['d'] === 1) { | ||
if (P['s'] < 0) { | ||
return newFraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n'])); | ||
} else { | ||
return newFraction(Math.pow(this['s'] * this["n"], P['n']), Math.pow(this["d"], P['n'])); | ||
} | ||
} | ||
// Negative roots become complex | ||
// (-a/b)^(c/d) = x | ||
// <=> (-1)^(c/d) * (a/b)^(c/d) = x | ||
// <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x # rotate 1 by 180° | ||
// <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x # DeMoivre's formula in Q ( https://proofwiki.org/wiki/De_Moivre%27s_Formula/Rational_Index ) | ||
// From which follows that only for c=0 the root is non-complex. c/d is a reduced fraction, so that sin(c/dpi)=0 occurs for d=1, which is handled by our trivial case. | ||
if (this['s'] < 0) return null; | ||
// Negative roots become complex | ||
// (-a/b)^(c/d) = x | ||
// <=> (-1)^(c/d) * (a/b)^(c/d) = x | ||
// <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x # rotate 1 by 180° | ||
// <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x # DeMoivre's formula in Q ( https://proofwiki.org/wiki/De_Moivre%27s_Formula/Rational_Index ) | ||
// From which follows that only for c=0 the root is non-complex. c/d is a reduced fraction, so that sin(c/dpi)=0 occurs for d=1, which is handled by our trivial case. | ||
if (this['s'] < 0) return null; | ||
// Now prime factor n and d | ||
var N = factorize(this['n']); | ||
var D = factorize(this['d']); | ||
// Now prime factor n and d | ||
var N = factorize(this['n']); | ||
var D = factorize(this['d']); | ||
// Exponentiate and take root for n and d individually | ||
var n = 1; | ||
var d = 1; | ||
for (var k in N) { | ||
if (k === '1') continue; | ||
if (k === '0') { | ||
n = 0; | ||
break; | ||
} | ||
N[k]*= P['n']; | ||
if (N[k] % P['d'] === 0) { | ||
N[k]/= P['d']; | ||
} else return null; | ||
n*= Math.pow(k, N[k]); | ||
// Exponentiate and take root for n and d individually | ||
var n = 1; | ||
var d = 1; | ||
for (var k in N) { | ||
if (k === '1') continue; | ||
if (k === '0') { | ||
n = 0; | ||
break; | ||
} | ||
N[k]*= P['n']; | ||
for (var k in D) { | ||
if (k === '1') continue; | ||
D[k]*= P['n']; | ||
if (N[k] % P['d'] === 0) { | ||
N[k]/= P['d']; | ||
} else return null; | ||
n*= Math.pow(k, N[k]); | ||
} | ||
if (D[k] % P['d'] === 0) { | ||
D[k]/= P['d']; | ||
} else return null; | ||
d*= Math.pow(k, D[k]); | ||
} | ||
for (var k in D) { | ||
if (k === '1') continue; | ||
D[k]*= P['n']; | ||
if (P['s'] < 0) { | ||
return newFraction(d, n); | ||
} | ||
return newFraction(n, d); | ||
}, | ||
if (D[k] % P['d'] === 0) { | ||
D[k]/= P['d']; | ||
} else return null; | ||
d*= Math.pow(k, D[k]); | ||
} | ||
/** | ||
* Check if two rational numbers are the same | ||
* | ||
* Ex: new Fraction(19.6).equals([98, 5]); | ||
**/ | ||
"equals": function(a, b) { | ||
if (P['s'] < 0) { | ||
return newFraction(d, n); | ||
} | ||
return newFraction(n, d); | ||
}, | ||
parse(a, b); | ||
return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0 | ||
}, | ||
/** | ||
* Check if two rational numbers are the same | ||
* | ||
* Ex: new Fraction(19.6).equals([98, 5]); | ||
**/ | ||
"equals": function(a, b) { | ||
/** | ||
* Check if two rational numbers are the same | ||
* | ||
* Ex: new Fraction(19.6).equals([98, 5]); | ||
**/ | ||
"compare": function(a, b) { | ||
parse(a, b); | ||
return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0 | ||
}, | ||
parse(a, b); | ||
var t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]); | ||
return (0 < t) - (t < 0); | ||
}, | ||
/** | ||
* Check if two rational numbers are the same | ||
* | ||
* Ex: new Fraction(19.6).equals([98, 5]); | ||
**/ | ||
"compare": function(a, b) { | ||
"simplify": function(eps) { | ||
parse(a, b); | ||
var t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]); | ||
return (0 < t) - (t < 0); | ||
}, | ||
if (isNaN(this['n']) || isNaN(this['d'])) { | ||
return this; | ||
} | ||
"simplify": function(eps) { | ||
eps = eps || 0.001; | ||
if (isNaN(this['n']) || isNaN(this['d'])) { | ||
return this; | ||
} | ||
var thisABS = this['abs'](); | ||
var cont = thisABS['toContinued'](); | ||
eps = eps || 0.001; | ||
for (var i = 1; i < cont.length; i++) { | ||
var thisABS = this['abs'](); | ||
var cont = thisABS['toContinued'](); | ||
var s = newFraction(cont[i - 1], 1); | ||
for (var k = i - 2; k >= 0; k--) { | ||
s = s['inverse']()['add'](cont[k]); | ||
} | ||
for (var i = 1; i < cont.length; i++) { | ||
if (Math.abs(s['sub'](thisABS).valueOf()) < eps) { | ||
return s['mul'](this['s']); | ||
} | ||
var s = newFraction(cont[i - 1], 1); | ||
for (var k = i - 2; k >= 0; k--) { | ||
s = s['inverse']()['add'](cont[k]); | ||
} | ||
return this; | ||
}, | ||
/** | ||
* Check if two rational numbers are divisible | ||
* | ||
* Ex: new Fraction(19.6).divisible(1.5); | ||
*/ | ||
"divisible": function(a, b) { | ||
if (Math.abs(s['sub'](thisABS).valueOf()) < eps) { | ||
return s['mul'](this['s']); | ||
} | ||
} | ||
return this; | ||
}, | ||
parse(a, b); | ||
return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"]))); | ||
}, | ||
/** | ||
* Check if two rational numbers are divisible | ||
* | ||
* Ex: new Fraction(19.6).divisible(1.5); | ||
*/ | ||
"divisible": function(a, b) { | ||
/** | ||
* Returns a decimal representation of the fraction | ||
* | ||
* Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183 | ||
**/ | ||
'valueOf': function() { | ||
parse(a, b); | ||
return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"]))); | ||
}, | ||
return this["s"] * this["n"] / this["d"]; | ||
}, | ||
/** | ||
* Returns a decimal representation of the fraction | ||
* | ||
* Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183 | ||
**/ | ||
'valueOf': function() { | ||
/** | ||
* Returns a string-fraction representation of a Fraction object | ||
* | ||
* Ex: new Fraction("1.'3'").toFraction(true) => "4 1/3" | ||
**/ | ||
'toFraction': function(excludeWhole) { | ||
return this["s"] * this["n"] / this["d"]; | ||
}, | ||
var whole, str = ""; | ||
var n = this["n"]; | ||
var d = this["d"]; | ||
if (this["s"] < 0) { | ||
str+= '-'; | ||
} | ||
/** | ||
* Returns a string-fraction representation of a Fraction object | ||
* | ||
* Ex: new Fraction("1.'3'").toFraction(true) => "4 1/3" | ||
**/ | ||
'toFraction': function(excludeWhole) { | ||
if (d === 1) { | ||
str+= n; | ||
} else { | ||
var whole, str = ""; | ||
var n = this["n"]; | ||
var d = this["d"]; | ||
if (this["s"] < 0) { | ||
str+= '-'; | ||
} | ||
if (excludeWhole && (whole = Math.floor(n / d)) > 0) { | ||
str+= whole; | ||
str+= " "; | ||
n%= d; | ||
} | ||
if (d === 1) { | ||
str+= n; | ||
} else { | ||
str+= n; | ||
str+= '/'; | ||
str+= d; | ||
if (excludeWhole && (whole = Math.floor(n / d)) > 0) { | ||
str+= whole; | ||
str+= " "; | ||
n%= d; | ||
} | ||
return str; | ||
}, | ||
/** | ||
* Returns a latex representation of a Fraction object | ||
* | ||
* Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}" | ||
**/ | ||
'toLatex': function(excludeWhole) { | ||
str+= n; | ||
str+= '/'; | ||
str+= d; | ||
} | ||
return str; | ||
}, | ||
var whole, str = ""; | ||
var n = this["n"]; | ||
var d = this["d"]; | ||
if (this["s"] < 0) { | ||
str+= '-'; | ||
} | ||
/** | ||
* Returns a latex representation of a Fraction object | ||
* | ||
* Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}" | ||
**/ | ||
'toLatex': function(excludeWhole) { | ||
if (d === 1) { | ||
str+= n; | ||
} else { | ||
var whole, str = ""; | ||
var n = this["n"]; | ||
var d = this["d"]; | ||
if (this["s"] < 0) { | ||
str+= '-'; | ||
} | ||
if (excludeWhole && (whole = Math.floor(n / d)) > 0) { | ||
str+= whole; | ||
n%= d; | ||
} | ||
if (d === 1) { | ||
str+= n; | ||
} else { | ||
str+= "\\frac{"; | ||
str+= n; | ||
str+= '}{'; | ||
str+= d; | ||
str+= '}'; | ||
if (excludeWhole && (whole = Math.floor(n / d)) > 0) { | ||
str+= whole; | ||
n%= d; | ||
} | ||
return str; | ||
}, | ||
/** | ||
* Returns an array of continued fraction elements | ||
* | ||
* Ex: new Fraction("7/8").toContinued() => [0,1,7] | ||
*/ | ||
'toContinued': function() { | ||
str+= "\\frac{"; | ||
str+= n; | ||
str+= '}{'; | ||
str+= d; | ||
str+= '}'; | ||
} | ||
return str; | ||
}, | ||
var t; | ||
var a = this['n']; | ||
var b = this['d']; | ||
var res = []; | ||
/** | ||
* Returns an array of continued fraction elements | ||
* | ||
* Ex: new Fraction("7/8").toContinued() => [0,1,7] | ||
*/ | ||
'toContinued': function() { | ||
if (isNaN(a) || isNaN(b)) { | ||
return res; | ||
} | ||
var t; | ||
var a = this['n']; | ||
var b = this['d']; | ||
var res = []; | ||
do { | ||
res.push(Math.floor(a / b)); | ||
t = a % b; | ||
a = b; | ||
b = t; | ||
} while (a !== 1); | ||
if (isNaN(a) || isNaN(b)) { | ||
return res; | ||
}, | ||
} | ||
/** | ||
* Creates a string representation of a fraction with all digits | ||
* | ||
* Ex: new Fraction("100.'91823'").toString() => "100.(91823)" | ||
**/ | ||
'toString': function(dec) { | ||
do { | ||
res.push(Math.floor(a / b)); | ||
t = a % b; | ||
a = b; | ||
b = t; | ||
} while (a !== 1); | ||
var N = this["n"]; | ||
var D = this["d"]; | ||
return res; | ||
}, | ||
if (isNaN(N) || isNaN(D)) { | ||
return "NaN"; | ||
} | ||
/** | ||
* Creates a string representation of a fraction with all digits | ||
* | ||
* Ex: new Fraction("100.'91823'").toString() => "100.(91823)" | ||
**/ | ||
'toString': function(dec) { | ||
dec = dec || 15; // 15 = decimal places when no repetation | ||
var N = this["n"]; | ||
var D = this["d"]; | ||
var cycLen = cycleLen(N, D); // Cycle length | ||
var cycOff = cycleStart(N, D, cycLen); // Cycle start | ||
if (isNaN(N) || isNaN(D)) { | ||
return "NaN"; | ||
} | ||
var str = this['s'] < 0 ? "-" : ""; | ||
dec = dec || 15; // 15 = decimal places when no repetation | ||
str+= N / D | 0; | ||
var cycLen = cycleLen(N, D); // Cycle length | ||
var cycOff = cycleStart(N, D, cycLen); // Cycle start | ||
N%= D; | ||
N*= 10; | ||
var str = this['s'] < 0 ? "-" : ""; | ||
if (N) | ||
str+= "."; | ||
str+= N / D | 0; | ||
if (cycLen) { | ||
N%= D; | ||
N*= 10; | ||
for (var i = cycOff; i--;) { | ||
str+= N / D | 0; | ||
N%= D; | ||
N*= 10; | ||
} | ||
str+= "("; | ||
for (var i = cycLen; i--;) { | ||
str+= N / D | 0; | ||
N%= D; | ||
N*= 10; | ||
} | ||
str+= ")"; | ||
} else { | ||
for (var i = dec; N && i--;) { | ||
str+= N / D | 0; | ||
N%= D; | ||
N*= 10; | ||
} | ||
if (N) | ||
str+= "."; | ||
if (cycLen) { | ||
for (var i = cycOff; i--;) { | ||
str+= N / D | 0; | ||
N%= D; | ||
N*= 10; | ||
} | ||
return str; | ||
str+= "("; | ||
for (var i = cycLen; i--;) { | ||
str+= N / D | 0; | ||
N%= D; | ||
N*= 10; | ||
} | ||
str+= ")"; | ||
} else { | ||
for (var i = dec; N && i--;) { | ||
str+= N / D | 0; | ||
N%= D; | ||
N*= 10; | ||
} | ||
} | ||
}; | ||
if (typeof exports === "object") { | ||
Object.defineProperty(Fraction, "__esModule", { 'value': true }); | ||
Fraction['default'] = Fraction; | ||
Fraction['Fraction'] = Fraction; | ||
module['exports'] = Fraction; | ||
} else { | ||
root['Fraction'] = Fraction; | ||
return str; | ||
} | ||
})(this); | ||
}; |
/* | ||
Fraction.js v4.3.0 20/08/2023 | ||
Fraction.js v4.3.5 31/08/2023 | ||
https://www.xarg.org/2014/03/rational-numbers-in-javascript/ | ||
@@ -4,0 +4,0 @@ |
{ | ||
"name": "fraction.js", | ||
"title": "fraction.js", | ||
"version": "4.3.4", | ||
"version": "4.3.5", | ||
"homepage": "https://www.xarg.org/2014/03/rational-numbers-in-javascript/", | ||
@@ -22,3 +22,11 @@ "bugs": "https://github.com/rawify/Fraction.js/issues", | ||
}, | ||
"type": "module", | ||
"main": "fraction.js", | ||
"exports": { | ||
".": { | ||
"import": "./fraction.js", | ||
"require": "./fraction.cjs", | ||
"types": "./fraction.d.ts" | ||
} | ||
}, | ||
"types": "./fraction.d.ts", | ||
@@ -48,2 +56,2 @@ "private": false, | ||
} | ||
} | ||
} |
85609
8
2229
Yes