@khanacademy/perseus 0.0.1 → 0.1.0

package/src/sigfigs.jsx

@@ -0,0 +1,492 @@
+/* eslint-disable eqeqeq, no-unused-vars */
+// @flow
+/*
+ * A class for formatting number to significant digits.
+ * Copyright (C) 2001 Stephen Ostermiller
+ * http://ostermiller.org/contact.pl?regarding?JavaScript+Significant+Figures
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+/**
+ * An object tho both scans floating points to
+ * determine the number of significant figures.
+ * and can display a floating point using any number
+ * of significant figures.
+ *
+ * @param s A string representation of a floating point.
+ */
+export class SignificantFigures {
+    order: number;
+    mantissa: string;
+    positive: boolean;
+    sigFigs: number;
+    sigDecs: number;
+
+    constructor(s: string) {
+        this.order = parseOrder(s);
+        this.mantissa = parseMantissa(s);
+        this.positive = parseSign(s);
+
+        /**
+         * Get the number of significant figures this object uses.
+         * Leading zeros are not significant.  Traling zeros up to
+         * and after the decimal point are significant.
+         * Significant figures is good to know when the number is
+         * used in multiplication.
+         *
+         * @return the number of significant figures.
+         */
+        this.sigFigs = this.mantissa.length;
+
+        /**
+         * Get the least significant decimal this object uses.
+         * This is useful to know if a number is being used
+         * in addition.
+         * 400 - 2 the hundreds place (10^2) is the least significant decimal.
+         * 75 - 0 the ones place (10^0) is the least significant decimal.
+         * .543 - -3 the 1/1000's place (10^-3) is the least significant decimal.
+         *
+         * @return an integer representing the least significant decimal place.
+         */
+        this.sigDecs = this.order - this.mantissa.length;
+    }
+}
+
+/**
+ * Format a floating point for display using the specified
+ * number of significant figures and least significant decimal.
+ * Scientific notation may used by this method if this
+ * object is very small, very large, has many significant
+ * figures, or the number of significant figures would be
+ * ambiguous in the output if scientific notation were not
+ * used.
+ *
+ * @param f A floating point number that should be displayed
+ * @param sigFigs desired number of significant figures (integer).
+ * @param sigDecs the least significant decimal place (integer).
+ * @param scientific true iff scientific notation should always be used.
+ * @return a string of this object formatted correctly.
+ */
+export function displaySigFigs(
+    f: number,
+    sigFigs: number,
+    sigDecs: number,
+    scientific: boolean,
+): string {
+    const s = "" + f;
+    let order = parseOrder(s);
+    let mantissa = parseMantissa(s);
+    let positive = parseSign(s);
+    let add;
+    let decAdd;
+    let sigAdd;
+    let zeroScientific = false;
+    if (f == 0 || mantissa == "" || mantissa == "0") {
+        mantissa = "";
+        for (let i = 0; i < sigFigs; i++) {
+            mantissa += "0";
+        }
+        order = sigFigs + sigDecs;
+        if (sigDecs < 0 && -sigDecs >= sigFigs) {
+            zeroScientific = true;
+        }
+    } else {
+        decAdd = order - mantissa.length - sigDecs;
+        sigAdd = sigFigs - mantissa.length;
+        add = Math.min(sigAdd, decAdd);
+        if (add < 0) {
+            let rounded = round(mantissa, -add);
+            if (rounded.length > mantissa.length + add) {
+                order++;
+                if (decAdd > sigAdd) {
+                    rounded = round(rounded, 1);
+                }
+            }
+            mantissa = rounded;
+        } else if (add > 0) {
+            for (let i = 0; i < add; i++) {
+                mantissa += "0";
+            }
+        }
+        if (mantissa == "" || mantissa == "0") {
+            mantissa = "0";
+            positive = true;
+            order = 1 + sigDecs;
+            if (order != 0) {
+                zeroScientific = true;
+            }
+        }
+    }
+    const useScientific =
+        scientific ||
+        mantissa.length > 20 ||
+        order > 4 ||
+        order < -2 ||
+        (order - mantissa.length > 0 && trailingZeros(mantissa) > 0) ||
+        zeroScientific;
+    let returnVal = "";
+    if (!positive) {
+        returnVal += "-";
+    }
+    if (useScientific) {
+        returnVal += mantissa.charAt(0);
+        if (mantissa.length > 1) {
+            returnVal += "." + mantissa.substring(1, mantissa.length);
+        }
+        if (order - 1 != 0) {
+            returnVal += " x 10^" + (order - 1);
+        }
+    } else {
+        let wholePart = "";
+        let fractPart = "";
+        let needDot = true;
+        if (order > 0) {
+            if (mantissa.length > order) {
+                wholePart = mantissa.substring(0, order);
+                fractPart = mantissa.substring(order, mantissa.length);
+            } else {
+                wholePart = mantissa;
+                needDot = trailingZeros(mantissa) != 0;
+                for (let i = 0; i < order - mantissa.length; i++) {
+                    wholePart += "0";
+                }
+            }
+        } else {
+            for (let i = 0; i < -order; i++) {
+                fractPart += "0";
+            }
+            fractPart += mantissa;
+        }
+        returnVal +=
+            (wholePart == "" ? "0" : wholePart) +
+            (needDot ? "." : "") +
+            fractPart;
+    }
+    return returnVal;
+}
+
+/**
+ * Count the significant trailing zeros on this object.
+ *
+ * @return the number of trailing zeros
+ */
+function trailingZeros(mantissa) {
+    let zeros = 0;
+    for (let i = mantissa.length - 1; i >= 0; i--) {
+        const c = mantissa.charAt(i);
+        if (c == "0") {
+            zeros++;
+        } else {
+            return zeros;
+        }
+    }
+    return zeros;
+}
+
+/**
+ * Parse a string representation of a floating point
+ * and pull out the sign.
+ *
+ * @param s the string representation of a floating point.
+ * @return true iff this is a positive number
+ */
+function parseSign(s) {
+    let beginning = true;
+    let seenDot = false;
+    let seenSomething = false;
+    let zeros = "";
+    let leadZeros = "";
+    let all = "";
+    let decPlaces = 0;
+    let totalDecs = 0;
+    let pos = true;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charAt(i);
+        if (c >= "1" && c <= "9") {
+            all += zeros + c;
+            zeros = "";
+            seenSomething = true;
+            if (!seenDot) {
+                totalDecs++;
+                decPlaces++;
+            }
+            beginning = false;
+        } else if (c == "0") {
+            if (seenDot) {
+                if (seenSomething) {
+                    all += zeros + c;
+                    zeros = "";
+                } else {
+                    leadZeros += c;
+                    decPlaces--;
+                }
+            } else {
+                totalDecs++;
+                if (seenSomething) {
+                    leadZeros += c;
+                    decPlaces++;
+                    zeros += c;
+                } else {
+                    leadZeros += c;
+                }
+            }
+            beginning = false;
+        } else if (!seenDot && c == ".") {
+            all += zeros;
+            zeros = "";
+            seenDot = true;
+            beginning = false;
+        } else if (c == "e" || (c == "E" && i + 1 < s.length)) {
+            const raised = parseInt(s.substring(i + 1, s.length));
+            decPlaces += raised;
+            totalDecs += raised;
+            i = s.length;
+        } else if (beginning && (c == "+" || c == "-")) {
+            if (c == "-") {
+                pos = !pos;
+            }
+        }
+    }
+    if (all == "") {
+        return true;
+    }
+    return pos;
+}
+
+/**
+ * Parse a string representation of a floating point
+ * and pull out the mantissa.
+ *
+ * @param s the string representation of a floating point.
+ * @return the mantissa of this number.
+ */
+function parseMantissa(s) {
+    let beginning = true;
+    let seenDot = false;
+    let seenSomething = false;
+    let zeros = "";
+    let leadZeros = "";
+    let all = "";
+    let decPlaces = 0;
+    let totalDecs = 0;
+    let pos = true;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charAt(i);
+        if (c >= "1" && c <= "9") {
+            all += zeros + c;
+            zeros = "";
+            seenSomething = true;
+            if (!seenDot) {
+                totalDecs++;
+                decPlaces++;
+            }
+            beginning = false;
+        } else if (c == "0") {
+            if (seenDot) {
+                if (seenSomething) {
+                    all += zeros + c;
+                    zeros = "";
+                } else {
+                    leadZeros += c;
+                    decPlaces--;
+                }
+            } else {
+                totalDecs++;
+                if (seenSomething) {
+                    leadZeros += c;
+                    decPlaces++;
+                    zeros += c;
+                } else {
+                    leadZeros += c;
+                }
+            }
+            beginning = false;
+        } else if (!seenDot && c == ".") {
+            all += zeros;
+            zeros = "";
+            seenDot = true;
+            beginning = false;
+        } else if (c == "e" || (c == "E" && i + 1 < s.length)) {
+            const raised = parseInt(s.substring(i + 1, s.length));
+            decPlaces += raised;
+            totalDecs += raised;
+            i = s.length;
+        } else if (beginning && (c == "+" || c == "-")) {
+            if (c == "-") {
+                pos = !pos;
+            }
+        }
+    }
+    if (all == "") {
+        return leadZeros;
+    }
+    return all;
+}
+
+/**
+ * Parse a string representation of a floating point
+ * and pull out the exponent.
+ *
+ * @param s the string representation of a floating point.
+ * @return (integer) the number after the e.
+ */
+function parseOrder(s) {
+    let beginning = true;
+    let seenDot = false;
+    let seenSomething = false;
+    let zeros = "";
+    let leadZeros = "";
+    let all = "";
+    let decPlaces = 0;
+    let totalDecs = 0;
+    let pos = true;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charAt(i);
+        if (c >= "1" && c <= "9") {
+            all += zeros + c;
+            zeros = "";
+            seenSomething = true;
+            if (!seenDot) {
+                totalDecs++;
+                decPlaces++;
+            }
+            beginning = false;
+        } else if (c == "0") {
+            if (seenDot) {
+                if (seenSomething) {
+                    all += zeros + c;
+                    zeros = "";
+                } else {
+                    leadZeros += c;
+                    decPlaces--;
+                }
+            } else {
+                totalDecs++;
+                if (seenSomething) {
+                    leadZeros += c;
+                    decPlaces++;
+                    zeros += c;
+                } else {
+                    leadZeros += c;
+                }
+            }
+            beginning = false;
+        } else if (!seenDot && c == ".") {
+            all += zeros;
+            zeros = "";
+            seenDot = true;
+            beginning = false;
+        } else if (c == "e" || (c == "E" && i + 1 < s.length)) {
+            const raised = parseInt(s.substring(i + 1, s.length));
+            decPlaces += raised;
+            totalDecs += raised;
+            i = s.length;
+        } else if (beginning && (c == "+" || c == "-")) {
+            if (c == "-") {
+                pos = !pos;
+            }
+        }
+    }
+    if (all == "") {
+        return totalDecs;
+    }
+    return decPlaces;
+}
+
+/**
+ * Remove the specified number of digits from string by
+ * rounding.  Proper rounding rules for scientific purposes
+ * are followed.
+ * This method may cause an extra significant figure
+ * to be added to the number.  For example, if 999999
+ * were rounded, A one would carry over and become
+ * a significant figure.  Those who call this method
+ * should check for this and call round again if needed.
+ *
+ * @param mantissa A string representing an whole number of arbitrary length.
+ * @param digits A number of digits to remove
+ * @return A string represted the rounded version of mantissa
+ */
+function round(mantissa: string, digits: number): string {
+    const last = mantissa.length - digits - 1;
+    if (last < 0) {
+        return "";
+    }
+    if (last >= mantissa.length - 1) {
+        return mantissa;
+    }
+    const nextToLast = mantissa.charAt(last + 1);
+    const lastChar = mantissa.charAt(last);
+    let roundUp = false;
+    if (nextToLast > "5") {
+        roundUp = true;
+    } else if (nextToLast == "5") {
+        for (let j = last + 2; j < mantissa.length; j++) {
+            if (mantissa.charAt(j) != "0") {
+                roundUp = true;
+            }
+        }
+        // $FlowIgnore[unsafe-addition]: lashChar gets coerced from a string to a number here
+        if (lastChar % 2 == 1) {
+            roundUp = true;
+        }
+    }
+    let result = "";
+    for (let i = last; i >= 0; i--) {
+        const c = mantissa.charAt(i);
+        if (roundUp) {
+            let nextChar;
+            if (c == "9") {
+                nextChar = "0";
+            } else {
+                switch (c) {
+                    case "0":
+                        nextChar = "1";
+                        break;
+                    case "1":
+                        nextChar = "2";
+                        break;
+                    case "2":
+                        nextChar = "3";
+                        break;
+                    case "3":
+                        nextChar = "4";
+                        break;
+                    case "4":
+                        nextChar = "5";
+                        break;
+                    case "5":
+                        nextChar = "6";
+                        break;
+                    case "6":
+                        nextChar = "7";
+                        break;
+                    case "7":
+                        nextChar = "8";
+                        break;
+                    case "8":
+                        nextChar = "9";
+                        break;
+                }
+                roundUp = false;
+            }
+            // $FlowIgnore[incompatible-type]: switch case isn't exhaustive so Flow doesn't know nextChar is defined
+            result = nextChar + result;
+        } else {
+            result = c + result;
+        }
+    }
+    if (roundUp) {
+        result = "1" + result;
+    }
+    return result;
+}