Merge pull request #21126 from apache/fix-16266

Fix that extreme small numbers can not be displayed in Cartesian due to the inappropriate rounding precision.

Author: Ovilia

src/scale/Interval.ts

@@ -35,7 +35,7 @@ class IntervalScale<SETTING extends ScaleSettingDefault = ScaleSettingDefault> e
     // Step is calculated in adjustExtent.
     protected _interval: number = 0;
     protected _niceExtent: [number, number];
-    private _intervalPrecision: number = 2;
+    protected _intervalPrecision: number = 2;
 
 
     parse(val: ScaleDataValue): number {
@@ -213,9 +213,10 @@ class IntervalScale<SETTING extends ScaleSettingDefault = ScaleSettingDefault> e
             const minorTicksGroup = [];
             const interval = nextTick.value - prevTick.value;
             const minorInterval = interval / splitNumber;
+            const minorIntervalPrecision = helper.getIntervalPrecision(minorInterval);
 
             while (count < splitNumber - 1) {
-                const minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval);
+                const minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval, minorIntervalPrecision);
 
                 // For the first and last interval. The count may be less than splitNumber.
                 if (minorTick > extent[0] && minorTick < extent[1]) {
@@ -276,6 +277,12 @@ class IntervalScale<SETTING extends ScaleSettingDefault = ScaleSettingDefault> e
     }
 
     /**
+     * FIXME: refactor - disallow override, use composition instead.
+     *
+     * The override of `calcNiceTicks` should ensure these members are provided:
+     *  this._intervalPrecision
+     *  this._interval
+     *
      * @param splitNumber By default `5`.
      */
     calcNiceTicks(splitNumber?: number, minInterval?: number, maxInterval?: number): void {
@@ -345,12 +352,13 @@ class IntervalScale<SETTING extends ScaleSettingDefault = ScaleSettingDefault> e
 
         this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
         const interval = this._interval;
+        const intervalPrecition = this._intervalPrecision;
 
         if (!opt.fixMin) {
-            extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
+            extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval, intervalPrecition);
         }
         if (!opt.fixMax) {
-            extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
+            extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval, intervalPrecition);
         }
         this._innerSetExtent(extent[0], extent[1]);
     }

src/scale/Log.ts

@@ -27,7 +27,7 @@ import {
     DimensionLoose, DimensionName, ParsedAxisBreakList, AxisBreakOption,
     ScaleTick
 } from '../util/types';
-import { logTransform } from './helper';
+import { getIntervalPrecision, logTransform } from './helper';
 import SeriesData from '../data/SeriesData';
 import { getScaleBreakHelper } from './break';
 
@@ -165,6 +165,7 @@ class LogScale extends IntervalScale {
         ] as [number, number];
 
         this._interval = interval;
+        this._intervalPrecision = getIntervalPrecision(interval);
         this._niceExtent = niceExtent;
     }
 

src/scale/Time.ts

@@ -297,6 +297,7 @@ class TimeScale extends IntervalScale<TimeScaleSetting> {
 
         // Interval that can be used to calculate ticks
         this._interval = scaleIntervals[idx][1];
+        this._intervalPrecision = scaleHelper.getIntervalPrecision(this._interval);
         // Min level used when picking ticks from top down.
         // We check one more level to avoid the ticks are to sparse in some case.
         this._minLevelUnit = scaleIntervals[Math.max(idx - 1, 0)][0];

src/util/number.ts

@@ -157,6 +157,8 @@ export function round(x: number | string, precision: number, returnStr: false):
 export function round(x: number | string, precision: number, returnStr: true): string;
 export function round(x: number | string, precision?: number, returnStr?: boolean): string | number {
     if (precision == null) {
+        // FIXME: the default precision should not be provided, since there is no universally adaptable
+        //  precision. The caller need to input a precision according to the scenarios.
         precision = 10;
     }
     // Avoid range error