function BigRational(n=0, d=1) { switch(signum(d)) { case 0: throw new Error("Denominator is zero", d); case -1: // ensure that d is always positive n = negate(n); d = negate(d); break; } // if d == 1 and n is a Number with a valid decimal part, then convert n to a fraction if(d == 1 && isNumber(n) && !Number.isInteger(n) && isFinite(n) ) { var parts = n.toString().split("."); if(parts.length == 2) { var whole = new BigRational(parseInt(parts[0])); var fracNum = parseInt(parts[1]); var fracDen = Math.pow(10, parts[1].length); var fraction = new BigRational(fracNum, fracDen); fraction = whole.plus(fraction.times(signum(n))); // console.log(n + " as standard fraction = " + fraction); // console.log(n + " as a mixed fraction = " + fraction.wholePart() + " " + fraction.fractionalPart()); n = fraction.num(); d = fraction.den(); } } // Ensure that both n and d are BigInt so that any non-integer Number throws a conversion error n = isBig(n) ? n : BigInt(n); d = isBig(d) ? d : BigInt(d); var gcd = bigGcd(n, d); // gcd could be non-big if it came from cache, so use bigGcd if(!isOne(gcd)) { // reduce to lowest terms n /= gcd; d /= gcd; } // Reduce to Number if possible. Only use BigInt if necessary const max = Number.MAX_SAFE_INTEGER; // not Number.MAX_VALUE !!! const min = Number.MIN_SAFE_INTEGER; // not Number.MIN_VALUE !!! if(n >= min && d >= min && n <= max && d <= max) { n = Number(n); d = Number(d); } // getter methods this.num = function() { return n; } this.den = function() { return d; } this.bigNum = function() { return this.isBig() ? this.num() : BigInt(this.num()); } this.bigDen = function() { return this.isBig() ? this.den() : BigInt(this.den()); } // boolean methods this.isBig = function() { return isBig(this.num()); } this.isOne = function() { return isOne(this.num()) && isOne(this.den()); } this.isWhole = function() { return isOne(this.den()); }; this.isMixedFraction = function() { return abs(this.num()) > this.den() && ! this.isWhole(); }; this.isNegative = function() { return this.signum() == -1; } this.isPositive = function() { return this.signum() == 1; } this.isZero = function() { return isZero(this.num()); } // conversion methods // if this.isBig(), then evaluate() will return a rounded BigInt with NO decimal part included. // Otherwise, it will return a Number, possibly with a decimal part. // TODO: Scale BigInts down to Number so we don't round the result so much (should be monotonic). this.evaluate = function() { return this.num() / this.den(); } this.toBig = function() { return this.isBig() ? this : new BigRational(new BigInt(this.num()), new BigInt(this.den())); } // unary math operations this.abs = function() { return this.signum() == -1 ? this.negate() : this; } this.negate = function() { return this.isZero() ? this : new BigRational(negate(this.num()), this.den()); } this.reciprocal = function() { return this.isOne() ? this : new BigRational(this.den(), this.num()); } this.signum = function() { return this.isZero() ? 0 : this.num() < 0 ? -1 : 1; } // Return the signed fractional part of this BigRational. // The value returned will always be between 1 and -1 non-inclusive. this.fractionalPart = function() { if(this.isWhole()) { return new BigRational(); } var n = this.abs().bigNum(); var d = this.bigDen(); n = n % d; // this multiplication has intermittent problems when n is big and signum isn't, // so we'll make n, d, and signum all big n = n * BigInt(this.signum()); return new BigRational(n, d); } this.wholePart = function() { if(this.isWhole()) { return this; } var pos = this.abs(); return pos.minus(pos.fractionalPart()).times(this.signum()); } // single arg comparison operations should allow parmeters to be either Number or BigInt this.compareTo = function(that) { if(that instanceof BigRational) { return this.minus(that).signum(); } // recursive call with the correct type return this.compareTo(new BigRational(that)); } this.equals = function(that) { return this.compareTo(that) == 0; } this.greaterThan = function(that) { return this.compareTo(that) == 1; } this.lessThan = function(that) { return this.compareTo(that) == -1; } // single arg math operations should allow parmeters to be either Number or BigInt this.plus = function(that) { if(that instanceof BigRational) { if(this.isZero()) { return that; } if(that.isZero()) { return this; } var myNum = this.bigNum(); var myDen = this.bigDen(); var thatNum = that.bigNum(); var thatDen = that.bigDen(); if(myDen == thatDen) { // just add numerators and use their common denominator return new BigRational(myNum + thatNum, myDen); } // different denominators var n1 = myNum * thatDen; var n2 = myDen * thatNum; var n = n1 + n2; var d = myDen * thatDen; return new BigRational(n, d) } if(that == 0) { return this; } // recursive call with the correct type return this.plus(new BigRational(that)); } this.minus = function(that) { if(that instanceof BigRational) { if(this.isZero()) { return that.negate(); } return that.isZero() ? this : this.plus(that.negate()); } if(that == 0) { return this; } // recursive call with the correct type return this.minus(new BigRational(that)); } this.times = function(that) { if(that instanceof BigRational) { if(this.isOne()) { return that; } if(that.isOne()) { return this; } if(this.isZero() || that.isZero()) { return new BigRational(); } return new BigRational(this.bigNum() * that.bigNum(), this.bigDen() * that.bigDen()) } if(isNumber(that)) { switch(that) { case 1: return this; case -1: return this.negate(); case 0: return new BigRational(); } } // recursive call with the correct type return this.times(new BigRational(that)); } this.dividedBy = function(that) { if(that instanceof BigRational) { return that.isOne() ? this : this.times(that.reciprocal()); } if(isNumber(that)) { switch(that) { case 1: return this; case -1: return this.negate; } } // recursive call with the correct type return this.dividedBy(new BigRational(that)); } // rendering methods this.toString = function(properForm = true) { if(properForm) { return this.num() + (this.isWhole() ? "" : ("/" + this.den())); } else { return this.isMixedFraction() ? (this.wholePart() + " " + this.abs().fractionalPart().num() + "/" + this.den()) : this.toString(); // whole number or a proper fraction between -1 and 1 } } this.asLatex = function(properForm = true) { var t = ""; if(this.isWhole()) { t = this.num().toString(); } else if((!properForm) && this.isMixedFraction()) { t = this.wholePart().num() + " \\frac{" + abs(this.fractionalPart().num()) + "}{" + this.den() + "}"; } else { // proper fraction // See https://tex.stackexchange.com/questions/79141/is-there-a-designated-symbol-for-the-negative-sign-in-say-16/79157 t = (this.isNegative() ? "-" : "") + "\\frac{" + abs(this.num()) + "}{" + this.den() + "}"; } return t; } this.toLatex = function(properForm = true) { return tex`${this.asLatex(properForm)}`; } this.asHtml = function(properForm = true) { // TODO: Use CSS to apply a nowrap style to all of these brat* classes if necessary var h = ""; const fractionBar = "⁄"; // See http://changelog.ca/log/2008/07/01/writing_fractions_in_html if(this.isWhole()) { h += "" + this.num().toString() + ""; } else if((!properForm) && this.isMixedFraction()) { h += ""; h += "" + this.wholePart().num() + " " + ""; h += "^{" + abs(this.fractionalPart().num()) + "}"; h += fractionBar; h += "_{" + this.den() + "}"; h += ""; } else { // proper fraction h += ""; h += "^{" + this.num() + "}"; h += fractionBar; h += "_{" + this.den() + "}"; h += ""; } h += ""; return h; } this.toHtml = function(properForm = true) { return html`${this.asHtml(properForm)}`; } // end of c'tor, so... return this; };