fix&feat: Change and clarify the rounding error and auto-precision utils and solutions.

Author: 100pah

src/scale/helper.ts

@@ -17,32 +17,54 @@
 * under the License.
 */
 
-import{getPrecision,round,nice,quantityExponent}from'../util/number';
+import{getPrecision,round,nice,quantityExponent,mathPow,mathMax,mathRound}from'../util/number';
 importIntervalScalefrom'./Interval';
 importLogScalefrom'./Log';
 importtypeScalefrom'./Scale';
 import{bind}from'zrender/src/core/util';
 importtype{ScaleBreakContext}from'./break';
+importTimeScalefrom'./Time';
+import{NullUndefined}from'../util/types';
 
 typeintervalScaleNiceTicksResult={
 interval: number,
 intervalPrecision: number,
 niceTickExtent: [number,number]
 };
 
-exportfunctionisValueNice(val: number){
-constexp10=Math.pow(10,quantityExponent(Math.abs(val)));
-constf=Math.abs(val/exp10);
-returnf===0
-||f===1
-||f===2
-||f===3
-||f===5;
-}
+/**
+ * See also method `nice` in `src/util/number.ts`.
+ */
+// export function isValueNice(val: number) {
+// const exp10 = Math.pow(10, quantityExponent(Math.abs(val)));
+// const f = Math.abs(round(val / exp10, 0));
+// return f === 0
+// || f === 1
+// || f === 2
+// || f === 3
+// || f === 5;
+// }
 
 exportfunctionisIntervalOrLogScale(scale: Scale): scale is LogScale|IntervalScale{
-returnscale.type==='interval'||scale.type==='log';
+returnisIntervalScale(scale)||isLogScale(scale);
+}
+
+exportfunctionisIntervalScale(scale: Scale): scale is IntervalScale{
+returnscale.type==='interval';
 }
+
+exportfunctionisTimeScale(scale: Scale): scale is TimeScale{
+returnscale.type==='time';
+}
+
+exportfunctionisLogScale(scale: Scale): scale is LogScale{
+returnscale.type==='log';
+}
+
+exportfunctionisOrdinalScale(scale: Scale): boolean{
+returnscale.type==='ordinal';
+}
+
 /**
  * @param extent Both extent[0] and extent[1] should be valid number.
  * Should be extent[0] < extent[1].
@@ -65,23 +87,29 @@ export function intervalScaleNiceTicks(
 if(maxInterval!=null&&interval>maxInterval){
 interval=result.interval=maxInterval;
 }
-// Tow more digital for tick.
 constprecision=result.intervalPrecision=getIntervalPrecision(interval);
 // Niced extent inside original extent
 constniceTickExtent=result.niceTickExtent=[
 round(Math.ceil(extent[0]/interval)*interval,precision),
 round(Math.floor(extent[1]/interval)*interval,precision)
 ];
 
-fixExtent(niceTickExtent,extent);
+fixNiceExtent(niceTickExtent,extent);
 
 returnresult;
 }
 
-exportfunctionincreaseInterval(interval: number){
-constexp10=Math.pow(10,quantityExponent(interval));
-// Increase interval
-letf=interval/exp10;
+/**
+ * The input `niceInterval` should be generated
+ * from `nice` method in `src/util/number.ts`, or
+ * from `increaseInterval` itself.
+ */
+exportfunctionincreaseInterval(niceInterval: number){
+constexponent=quantityExponent(niceInterval);
+// No rounding error in Math.pow(10, xxx).
+constexp10=mathPow(10,exponent);
+// Fix IEEE 754 float rounding error
+letf=mathRound(niceInterval/exp10);
 if(!f){
 f=1;
 }
@@ -94,25 +122,26 @@ export function increaseInterval(interval: number) {
 else{// f is 1 or 5
 f*=2;
 }
-returnround(f*exp10);
+// Fix IEEE 754 float rounding error
+returnround(f*exp10,-exponent);
 }
 
-/**
- * @return interval precision
- */
-exportfunctiongetIntervalPrecision(interval: number): number{
+exportfunctiongetIntervalPrecision(niceInterval: number): number{
 // Tow more digital for tick.
-returngetPrecision(interval)+2;
+// NOTE: `2` was introduced in commit `af2a2a9f6303081d7c3b52f0a38add07b4c6e0c7`;
+// it works on "nice" interval, but seems not necessarily mathematically required.
+returngetPrecision(niceInterval)+2;
 }
 
+
 functionclamp(
 niceTickExtent: [number,number],idx: number,extent: [number,number]
 ): void{
 niceTickExtent[idx]=Math.max(Math.min(niceTickExtent[idx],extent[1]),extent[0]);
 }
 
 // In some cases (e.g., splitNumber is 1), niceTickExtent may be out of extent.
-exportfunctionfixExtent(
+exportfunctionfixNiceExtent(
 niceTickExtent: [number,number],extent: [number,number]
 ): void{
 !isFinite(niceTickExtent[0])&&(niceTickExtent[0]=extent[0]);
@@ -173,3 +202,70 @@ export function logTransform(base: number, extent: number[], noClampNegative?: b
 Math.log(noClampNegative ? extent[1] : Math.max(0,extent[1]))/loggedBase
 ];
 }
+
+exportfunctionpowTransform(base: number,extent: number[]): [number,number]{
+return[
+mathPow(base,extent[0]),
+mathPow(base,extent[1])
+];
+}
+
+/**
+ * A valid extent is:
+ * - No non-finite number.
+ * - `extent[0] < extent[1]`.
+ *
+ * [NOTICE]: The input `rawExtent` can only be:
+ * - All non-finite numbers or `NaN`; or
+ * - `[Infinity, -Infinity]` (A typical initial extent with no data.)
+ * (Improve it when needed.)
+ */
+exportfunctionintervalScaleEnsureValidExtent(
+rawExtent: number[],
+opt: {
+fixMax?: boolean
+}
+): number[]{
+constextent=rawExtent.slice();
+// If extent start and end are same, expand them
+if(extent[0]===extent[1]){
+if(extent[0]!==0){
+// Expand extent
+// Note that extents can be both negative. See #13154
+constexpandSize=Math.abs(extent[0]);
+// In the fowllowing case
+// Axis has been fixed max 100
+// Plus data are all 100 and axis extent are [100, 100].
+// Extend to the both side will cause expanded max is larger than fixed max.
+// So only expand to the smaller side.
+if(!opt.fixMax){
+extent[1]+=expandSize/2;
+extent[0]-=expandSize/2;
+}
+else{
+extent[0]-=expandSize/2;
+}
+}
+else{
+extent[1]=1;
+}
+}
+constspan=extent[1]-extent[0];
+// If there are no data and extent are [Infinity, -Infinity]
+if(!isFinite(span)){
+extent[0]=0;
+extent[1]=1;
+}
+elseif(span<0){
+extent.reverse();
+}
+
+returnextent;
+}
+
+exportfunctionensureValidSplitNumber(
+rawSplitNumber: number|NullUndefined,defaultSplitNumber: number
+): number{
+rawSplitNumber=rawSplitNumber||defaultSplitNumber;
+returnmathRound(mathMax(rawSplitNumber,1));
+}