2d:null 2e:["$","title",null,{"children":"Big Rationals | David Hall | Observable"}] 33:T2328,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; };34:[] 31:{"id":"54e8989481326941","slug":"big-rationals","title":"Big Rationals","thumbnail":"e70b281d0debdc64f1223b1db93a6fb4c98d4be3bdeab221a71e836aab96a52c","access_level":"public","create_time":"$D2019-07-24T09:36:55.465Z","update_time":"$D2019-07-27T02:16:30.713Z","view_time":null,"first_public_time":"$D2019-07-24T11:39:41.298Z","has_unpublished_edits":null,"fork":false,"stars":2,"starred":false,"owner":{"type":"team","id":"e03a1f35385e7271","login":"david-hall","name":"David Hall","avatar_url":"https://avatars-next.observableusercontent.com/afa38c46229fd6d9c4426dfd17e3359afcc7eb8787d0a9c48fafda7bc081c359","tier":"starter_2024"},"version":1377,"publish_version":1377,"role":null,"authored":false,"authors":[{"type":"individual","id":"0d8260f2c3b197fd","login":"david-hall","name":"David Hall","avatar_url":"https://avatars-next.observableusercontent.com/afa38c46229fd6d9c4426dfd17e3359afcc7eb8787d0a9c48fafda7bc081c359","tier":null}],"members":[{"type":"individual","id":"0d8260f2c3b197fd","login":"david-hall","name":"David Hall","avatar_url":"https://avatars-next.observableusercontent.com/afa38c46229fd6d9c4426dfd17e3359afcc7eb8787d0a9c48fafda7bc081c359","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":1,"collection":null,"type":"notebook","body":{"title":"Big Rationals","cells":[{"id":0,"value":"md`# Big Rationals`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1022,"value":"md`### [Test Cases](/@david-hall/big-rational-test-cases) have been moved to a separate notebook. ###`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":1375,"value":"bigNote","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":13,"value":"$33","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":311,"value":"zero = new BigRational();","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":308,"value":"one = new BigRational(1);","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":6,"value":"md `# Imports`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":5,"value":"import {bigGcd} from \"@david-hall/gcd-algorithms\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"},{"id":11,"value":"import {bigNote, abs, isBig, isOne, isNumber, isZero, negate, signum} from \"@david-hall/numeric-methods\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W34","stdlib":"1","titling":"auto"}} 32:"$31:body"