ixbrl-viewer 1.4.14__py3-none-any.whl → 1.4.16__py3-none-any.whl

iXBRLViewerPlugin/viewer/src/js/calculation.test.js

@@ -0,0 +1,306 @@
+// See COPYRIGHT.md for copyright information
+
+import Decimal from 'decimal.js';
+import { FactSet } from "./factset.js";
+import { Fact  } from "./fact.js";
+import { Interval  } from "./interval.js";
+import { NAMESPACE_ISO4217, viewerUniqueId } from "./util.js";
+import { ReportSet } from "./reportset.js";
+import { Calculation } from "./calculation.js";
+import './test-utils.js';
+
+const testReportData = {
+    "prefixes": {
+        "eg": "http://www.example.com",
+        "iso4217": NAMESPACE_ISO4217,
+        "e": "http://example.com/entity",
+        "group": "http://example.com/group",
+    },
+    "concepts": {
+        "eg:Total": {
+            "labels": {
+                "std": {
+                    "en": "Total"
+                }
+            }
+        },
+        "eg:Item1": {
+            "labels": {
+                "std": {
+                    "en": "Item 1"
+                }
+            }
+        },
+        "eg:Item2": {
+            "labels": {
+                "std": {
+                    "en": "Item 2"
+                }
+            }
+        },
+        "eg:Total2": {
+            "labels": {
+                "std": {
+                    "en": "Total 2"
+                }
+            }
+        },
+    },
+    "facts": {
+    },
+    "rels": {
+        "calc": {
+            "group": {
+                "eg:Total": [
+                    {"t": "eg:Item1", "w": 1},
+                    {"t": "eg:Item2", "w": -1}
+                ],
+                "eg:Total2": [
+                    {"t": "eg:Item1", "w": 2},
+                    {"t": "eg:Item2", "w": -2}
+                ]
+            }
+        }
+    }
+};
+
+function testReportSet(facts) {
+    // Deep copy of standing data
+    const data = JSON.parse(JSON.stringify(testReportData));
+    data.facts = facts;
+    const reportset = new ReportSet(data);
+    reportset._initialize();
+    return reportset;
+}
+
+function testFact(aspectData, value, decimals) {
+    const factData = { "a": aspectData, "v": value, "d": decimals};
+    return factData;
+}
+
+function getFact(reportSet, id) {
+  return reportSet.getItemById(viewerUniqueId(0, id));
+}
+
+describe("Simple consistent calculation", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 10000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 12000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 2000, -3),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9000, 11000));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(9500, 10500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(10000));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(true);
+    });
+});
+
+describe("Consistent only under 1.1", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 11000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 12000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 2000, -3),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9000, 11000));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(10500, 11500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+        expect(rCalc.rows[0].concept.name).toBe("eg:Item1");
+        expect(rCalc.rows[0].weight).toBe(1);
+        expect(rCalc.rows[0].weightSign).toBe("+");
+        expect(rCalc.rows[0].facts.size()).toBe(1);
+
+        expect(rCalc.rows[1].concept.name).toBe("eg:Item2");
+        expect(rCalc.rows[1].weight).toBe(-1);
+        expect(rCalc.rows[1].weightSign).toBe("-");
+        expect(rCalc.rows[1].facts.size()).toBe(1);
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(10000));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(false);
+    });
+
+});
+
+describe("Consistent duplicate contributor", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 10000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 12000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 2000, -3),
+        "f4": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 1990, -1),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9505, 10515));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(9500, 10500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+        expect(rCalc.rows[0].concept.name).toBe("eg:Item1");
+        expect(rCalc.rows[0].weight).toBe(1);
+        expect(rCalc.rows[0].weightSign).toBe("+");
+        expect(rCalc.rows[0].facts.size()).toBe(1);
+
+        expect(rCalc.rows[1].concept.name).toBe("eg:Item2");
+        expect(rCalc.rows[1].weight).toBe(-1);
+        expect(rCalc.rows[1].weightSign).toBe("-");
+        expect(rCalc.rows[1].facts.size()).toBe(2);
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(10000));
+        expect(rCalc.unchecked()).toBe(true);
+    });
+
+});
+
+
+describe("Single contributor", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total", "u": "iso2417:GBP"}, 10000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 9990, -1),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(9985, 9995));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(9500, 10500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(9990));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(false);
+    });
+});
+
+describe("Weights", () => {
+    const reportSet = testReportSet({
+        "f1": testFact({"c": "eg:Total2", "u": "iso2417:GBP"}, 4000, -3),
+        "f2": testFact({"c": "eg:Item1", "u": "iso2417:GBP"}, 3000, -3),
+        "f3": testFact({"c": "eg:Item2", "u": "iso2417:GBP"}, 1000, -3),
+    });
+
+    test("Calc 1.1 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), true);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotalInterval()).toEqual(new Interval(2000, 6000));
+        expect(Interval.fromFact(rCalc.totalFact)).toEqual(new Interval(3500, 4500));
+        expect(rCalc.isConsistent()).toBe(true);
+
+        expect(rCalc.rows[0].concept.name).toBe("eg:Item1");
+        expect(rCalc.rows[0].weight).toBe(2);
+        expect(rCalc.rows[0].weightSign).toBe("2");
+
+        expect(rCalc.rows[1].concept.name).toBe("eg:Item2");
+        expect(rCalc.rows[1].weight).toBe(-2);
+        expect(rCalc.rows[1].weightSign).toBe("-2");
+
+    });
+
+    test("Calc contributor", () => {
+        const calc11 = new Calculation(getFact(reportSet, "f2"), true);
+        expect(calc11.hasCalculations()).toBe(false);
+        const calc10 = new Calculation(getFact(reportSet, "f2"), false);
+        expect(calc10.hasCalculations()).toBe(false);
+    });
+
+    test("Calc 1.0 total", () => {
+        const calc = new Calculation(getFact(reportSet, "f1"), false);
+        expect(calc.hasCalculations()).toBe(true);
+        const rCalcs = calc.resolvedCalculations();
+        expect(rCalcs.length).toBe(1);
+        const rCalc = rCalcs[0];
+        expect(rCalc.elr).toBe("group");
+        expect(rCalc.calculatedTotal()).toEqual(new Decimal(4000));
+        expect(rCalc.unchecked()).toBe(false);
+        expect(rCalc.isConsistent()).toBe(true);
+    });
+});

iXBRLViewerPlugin/viewer/src/js/calculationInspector.js

@@ -0,0 +1,190 @@
+// Copyright 2021 Workiva Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import $ from 'jquery';
+import i18next from 'i18next';
+
+import { Dialog } from './dialog.js';
+import { ResolvedCalc11Calculation, ResolvedLegacyCalculation } from './calculation.js';
+
+export class CalculationInspector extends Dialog {
+    constructor() {
+        super(".dialog.calculation-inspector");
+        this.addButton("Dismiss", true);
+    }
+
+    duplicateFactIcons(factset) {
+        const icons = $("<td></td>").addClass("icons");
+        if (factset.size() > 1 && !factset.completeDuplicates()) {
+            if (factset.isConsistent()) {
+                icons.append(
+                    $("<span></span>")
+                    .addClass("duplicate-facts")
+                    .attr("title", i18next.t('calculation.consistent-duplicate-facts-present', {nfacts: factset.size()}))
+                );
+            }
+            else {
+                icons.append(
+                    $("<span></span>")
+                    .addClass("duplicate-facts")
+                    .attr("title", i18next.t('calculation.inconsistent-duplicate-facts-present', {nfacts: factset.size()}))
+                );
+            }
+        }
+        return icons;
+    }
+
+    populateCalc11Table(resolvedCalculation, table) {
+        table.addClass("calc11");
+        const tbody = table.find("tbody");
+        let hasIcons = false;
+        for (const row of resolvedCalculation.rows) {
+            let factText = "";
+            let minText = "";
+            let maxText = "";
+
+            if (!row.facts.isEmpty()) {
+                let f = row.facts.items()[0];
+                const reportedInterval = row.facts.valueIntersection();
+                if (reportedInterval === undefined) {
+                    factText = "n/a";
+                    minText = "n/a"; 
+                    maxText = "n/a";
+                }
+                else {
+                    factText = f.readableValue(reportedInterval.midpoint().toNumber());
+                    const contributionInterval = row.contributionInterval();
+                    minText = f.readableValue(contributionInterval.a.toNumber());
+                    maxText = f.readableValue(contributionInterval.b.toNumber());
+                }
+            }
+            const icons = this.duplicateFactIcons(row.facts);
+            hasIcons = hasIcons || icons.find("span").length > 0;
+            $("<tr></tr>")
+                .append($("<td></td>").addClass("weight").text(row.weightSign))
+                .append($("<td></td>").text(row.concept.label()).addClass("line-item"))
+                .append($("<td></td>").addClass("figure").text(factText))
+                .append(icons)
+                .append($("<td></td>").addClass("figure").text(minText))
+                .append($("<td></td>").addClass("figure").text(maxText))
+                .appendTo(tbody);
+        }
+        const fact = resolvedCalculation.totalFact;
+        const cvi = resolvedCalculation.calculatedTotalInterval();
+            $("<tr></tr>").addClass("total")
+                .append($("<td></td>"))
+                .append($("<td></td>").text(`${fact.concept().label()} (${i18next.t('calculation.calculated-total')})`).addClass("line-item"))
+                .append($("<td></td>").text(cvi === undefined ? 'n/a' : fact.readableValue(cvi.midpoint().toNumber())).addClass("figure"))
+                .append($("<td></td>").addClass("icons"))
+                .append($("<td></td>").text(cvi === undefined ? 'n/a' : fact.readableValue(cvi.a.toNumber())).addClass("figure"))
+                .append($("<td></td>").text(cvi === undefined ? 'n/a' : fact.readableValue(cvi.b.toNumber())).addClass("figure"))
+                .appendTo(tbody);
+
+        const tvi = resolvedCalculation.totalFactSet.valueIntersection();
+        const icons = this.duplicateFactIcons(resolvedCalculation.totalFactSet);
+        $("<tr></tr>")
+            .append($("<td></td>"))
+            .append($("<td></td>").text(`${fact.concept().label()} (${i18next.t('calculation.reported-total')})`).addClass("line-item"))
+            .append($("<td></td>").text(tvi === undefined ? 'n/a' : fact.readableValue(tvi.midpoint().toNumber())).addClass("figure"))
+            .append(icons)
+            .append($("<td></td>").text(tvi === undefined ? 'n/a' : fact.readableValue(tvi.a.toNumber())).addClass("figure"))
+            .append($("<td></td>").text(tvi === undefined ? 'n/a' : fact.readableValue(tvi.b.toNumber())).addClass("figure"))
+            .appendTo(tbody);
+        if (hasIcons) {
+            table.addClass("has-icons");
+        }
+    }
+
+    populateLegacyCalcTable(resolvedCalculation, table) {
+        table.removeClass("calc11");
+        const tbody = table.find("tbody");
+        let hasIcons = false;
+        for (const row of resolvedCalculation.rows) {
+            let factText = "";
+            let minText = "";
+            let maxText = "";
+
+            if (!row.facts.isEmpty()) {
+                let f = row.facts.items()[0];
+                const reportedInterval = row.facts.valueIntersection();
+                if (reportedInterval === undefined) {
+                    factText = "Inconsistent duplicates";
+                }
+                else if (!row.facts.completeDuplicates()) {
+                    factText = "Duplicate facts"; 
+                }
+                else {
+                    factText = f.readableValue();
+                }
+            }
+            const icons = this.duplicateFactIcons(row.facts);
+            hasIcons = hasIcons || icons.find("span").length > 0;
+            $("<tr></tr>")
+                .append($("<td></td>").addClass("weight").text(row.weightSign))
+                .append($("<td></td>").text(row.concept.label()).addClass("line-item"))
+                .append($("<td></td>").addClass("figure").text(factText))
+                .append(icons)
+                .appendTo(tbody);
+        }
+        const fact = resolvedCalculation.totalFact;
+        const ct = resolvedCalculation.calculatedTotal();
+        $("<tr></tr>").addClass("total")
+            .append($("<td></td>"))
+            .append($("<td></td>").text(`${fact.concept().label()} (${i18next.t('calculation.calculated-total')})`).addClass("line-item"))
+            .append($("<td></td>").text(fact.readableValue(ct)).addClass("figure"))
+            .append($("<td></td>").addClass("icons"))
+            .appendTo(tbody);
+
+        $("<tr></tr>")
+            .append($("<td></td>"))
+            .append($("<td></td>").text(`${fact.concept().label()} (${i18next.t('calculation.reported-total')})`).addClass("line-item"))
+            .append($("<td></td>").text(fact.readableValue()).addClass("figure"))
+            .append($("<td></td>").addClass("icons"))
+            .appendTo(tbody);
+        if (hasIcons) {
+            table.addClass("has-icons");
+        }
+    }
+
+    displayCalculation(resolvedCalculation) {
+        const table = this.node.find("table.calculation-trace");
+        const tbody = table.find("tbody");
+        // We remove the padding on the icons column (used to indicate
+        // duplicate facts) if it is empty to avoid an unsightly gap
+        var hasIcons = false;
+        tbody.empty();
+        table.removeClass("has-icons");
+        if (resolvedCalculation instanceof ResolvedCalc11Calculation) {
+            this.populateCalc11Table(resolvedCalculation, table);
+        }
+        else {
+            this.populateLegacyCalcTable(resolvedCalculation, table);
+        }
+
+
+        const messageCell = table.find("td.status");
+        messageCell.removeClass("inconsistent").removeClass("consistent").removeClass("unchecked");
+        if (resolvedCalculation.unchecked()) {
+            messageCell.addClass("unchecked").find(".message").text("Calculation does not bind");
+        } 
+        else if (resolvedCalculation.isConsistent()) {
+            messageCell.addClass("consistent").find(".message").text("Calculation is consistent");
+        }
+        else {
+            messageCell.addClass("inconsistent").find(".message").text("Calculation is inconsistent");
+        }
+    }
+}
+
+

iXBRLViewerPlugin/viewer/src/js/concept.js

@@ -5,6 +5,8 @@ import $ from 'jquery'
 export class Concept {
     constructor(report, name) {
         this._c = report.concepts()[name] || {};
+        this.name = name;
+        this.report = report;
     }
 
     /*
@@ -48,7 +50,11 @@ export class Concept {
     }
 
     isEnumeration() {
-        return Boolean(this._c.e);
+        return Boolean(this._c && this._c.e);
+    }
+
+    label() {
+        return this.report.getLabelOrName(this.name);
     }
 
     isTextBlock() {

iXBRLViewerPlugin/viewer/src/js/fact.js

@@ -2,10 +2,13 @@
 
 import $ from 'jquery'
 import i18next from "i18next";
+import { isodateToHuman } from "./util.js"
+import { QName } from "./qname.js"
 import { Aspect } from "./aspect.js";
 import { Period } from './period.js';
 import { formatNumber, localId } from "./util.js";
 import Decimal from "decimal.js";
+import { Interval } from './interval.js';
 
 export class Fact {
     
@@ -42,7 +45,7 @@ export class Fact {
         return this.report.qname(this.f.a.c);
     }
 
-    period(){
+    period() {
         return new Period(this.f.a.p);
     }
 
@@ -63,8 +66,8 @@ export class Fact {
         return this.f.v;
     }
 
-    readableValue() {
-        let v = this.f.v;
+    readableValue(val) {
+        let v = val === undefined ? this.f.v : val;
         if (this.isInvalidIXValue()) {
             v = "Invalid value";
         }
@@ -241,9 +244,11 @@ export class Fact {
     isNil() {
         return this.f.v === null;
     }
+
     isNegative() {
         return this.isNumeric() && !this.isNil() && this.value() !== undefined && new Decimal(this.value()).isNegative() && !this.isZero();
     }
+
     isPositive() {
         return this.isNumeric() && !this.isNil() && this.value() !== undefined && new Decimal(this.value()).isPositive() && !this.isZero();
     }
@@ -251,6 +256,7 @@ export class Fact {
     isZero() {
         return this.isNumeric() && !this.isNil() && this.value() !== undefined && new Decimal(this.value()).isZero();
     }
+
     isInvalidIXValue() {
         return this.f.err == 'INVALID_IX_VALUE';
     }
@@ -344,10 +350,58 @@ export class Fact {
         return concepts;
     }
 
-    // Facts that are the source of relationships to this fact.
+    /*
+     * Facts that are the source of relationships to this fact.
+     */
     addLinkedFact(f) {
         this.linkedFacts.push(f);
     }
-}
 
+    /*
+     * Returns the fact's value, rounded according to the value of its decimals
+     * property.  This is an odd thing to do, as it implies that more figures
+     * were reported than the decimals property suggest are accurate, but this
+     * is required for Calc 1.0 validation.
+     *
+     * valueInterval() is a more meaningful.
+     */
+    roundedValue() {
+        Decimal.rounding = Decimal.ROUND_HALF_UP;
+        const v = new Decimal(this.value());
+        const d = this.decimals();
+        if (d === undefined) {
+            return v;
+        }
+        return v.mul(10 ** d).round().mul(10 ** (0-d));
+    }
 
+    isCompleteDuplicate(other) {
+        return this.value() === other.value() && this.decimals() === other.decimals();
+    }
+
+    /*
+     * Facts that are the source of relationships to this fact.
+     */
+    addLinkedFact(f) {
+        this.linkedFacts.push(f);
+    }
+
+    /*
+     * Returns an Interval for the fact's value, as implied by its decimals
+     * property.
+     */
+    valueInterval() {
+        return Interval.fromFact(this);
+    }
+
+    isMorePrecise(of) {
+        // decimals of "undefined" indicates infinite precision
+        if (of.decimals() === undefined) {
+            return false;
+        }
+        if (this.decimals() === undefined) {
+            return true;
+        }
+        return this.decimals() > of.decimals();
+    }
+}