src/util/number.ts - echarts - Git at Google

 /*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */

 /*
 * A third-party license is embeded for some of the code in this file:
 * The method "quantile" was copied from "d3.js".
 * (See more details in the comment of the method below.)
 * The use of the source code of this file is also subject to the terms
 * and consitions of the license of "d3.js" (BSD-3Clause, see
 * </licenses/LICENSE-d3>).
 */

 import * as zrUtil from 'zrender/src/core/util';

 const RADIAN_EPSILON = 1e-4;
 // Although chrome already enlarge this number to 100 for `toFixed`, but
 // we sill follow the spec for compatibility.
 const ROUND_SUPPORTED_PRECISION_MAX = 20;

 function _trim(str: string): string {
     return str.replace(/^\s+|\s+$/g, '');
 }

 /**
  * Linear mapping a value from domain to range
  * @param  val
  * @param  domain Domain extent domain[0] can be bigger than domain[1]
  * @param  range  Range extent range[0] can be bigger than range[1]
  * @param  clamp Default to be false
  */
 export function linearMap(
     val: number,
     domain: number[],
     range: number[],
     clamp?: boolean
 ): number {
     const d0 = domain[0];
     const d1 = domain[1];
     const r0 = range[0];
     const r1 = range[1];

     const subDomain = d1 - d0;
     const subRange = r1 - r0;

     if (subDomain === 0) {
         return subRange === 0
             ? r0
             : (r0 + r1) / 2;
     }

     // Avoid accuracy problem in edge, such as
     // 146.39 - 62.83 === 83.55999999999999.
     // See echarts/test/ut/spec/util/number.js#linearMap#accuracyError
     // It is a little verbose for efficiency considering this method
     // is a hotspot.
     if (clamp) {
         if (subDomain > 0) {
             if (val <= d0) {
                 return r0;
             }
             else if (val >= d1) {
                 return r1;
             }
         }
         else {
             if (val >= d0) {
                 return r0;
             }
             else if (val <= d1) {
                 return r1;
             }
         }
     }
     else {
         if (val === d0) {
             return r0;
         }
         if (val === d1) {
             return r1;
         }
     }

     return (val - d0) / subDomain * subRange + r0;
 }

 /**
  * Convert a percent string to absolute number.
  * Returns NaN if percent is not a valid string or number
  */
 export function parsePercent(percent: number | string, all: number): number {
     switch (percent) {
         case 'center':
         case 'middle':
             percent = '50%';
             break;
         case 'left':
         case 'top':
             percent = '0%';
             break;
         case 'right':
         case 'bottom':
             percent = '100%';
             break;
     }
     if (typeof percent === 'string') {
         if (_trim(percent).match(/%$/)) {
             return parseFloat(percent) / 100 * all;
         }

         return parseFloat(percent);
     }

     return percent == null ? NaN : +percent;
 }

 /**
  * (1) Fix rounding error of float numbers.
  * (2) Support return string to avoid scientific notation like '3.5e-7'.
  */
 export function round(x: number | string, precision?: number): number;
 export function round(x: number | string, precision: number, returnStr: false): number;
 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) {
         precision = 10;
     }
     // Avoid range error
     precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX);
     // PENDING: 1.005.toFixed(2) is '1.00' rather than '1.01'
     x = (+x).toFixed(precision);
     return (returnStr ? x : +x);
 }

 /**
  * Inplacd asc sort arr.
  * The input arr will be modified.
  */
 export function asc<T extends number[]>(arr: T): T {
     arr.sort(function (a, b) {
         return a - b;
     });
     return arr;
 }

 /**
  * Get precision.
  */
 export function getPrecision(val: string | number): number {
     val = +val;
     if (isNaN(val)) {
         return 0;
     }

     // It is much faster than methods converting number to string as follows
     //      let tmp = val.toString();
     //      return tmp.length - 1 - tmp.indexOf('.');
     // especially when precision is low
     // Notice:
     // (1) If the loop count is over about 20, it is slower than `getPrecisionSafe`.
     //     (see https://jsbench.me/2vkpcekkvw/1)
     // (2) If the val is less than for example 1e-15, the result may be incorrect.
     //     (see test/ut/spec/util/number.test.ts `getPrecision_equal_random`)
     if (val > 1e-14) {
         let e = 1;
         for (let i = 0; i < 15; i++, e *= 10) {
             if (Math.round(val * e) / e === val) {
                 return i;
             }
         }
     }

     return getPrecisionSafe(val);
 }

 /**
  * Get precision with slow but safe method
  */
 export function getPrecisionSafe(val: string | number): number {
     // toLowerCase for: '3.4E-12'
     const str = val.toString().toLowerCase();

     // Consider scientific notation: '3.4e-12' '3.4e+12'
     const eIndex = str.indexOf('e');
     const exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0;
     const significandPartLen = eIndex > 0 ? eIndex : str.length;
     const dotIndex = str.indexOf('.');
     const decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex;
     return Math.max(0, decimalPartLen - exp);
 }

 /**
  * Minimal dicernible data precisioin according to a single pixel.
  */
 export function getPixelPrecision(dataExtent: [number, number], pixelExtent: [number, number]): number {
     const log = Math.log;
     const LN10 = Math.LN10;
     const dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
     const sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10);
     // toFixed() digits argument must be between 0 and 20.
     const precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
     return !isFinite(precision) ? 20 : precision;
 }

 /**
  * Get a data of given precision, assuring the sum of percentages
  * in valueList is 1.
  * The largest remainer method is used.
  * https://en.wikipedia.org/wiki/Largest_remainder_method
  *
  * @param valueList a list of all data
  * @param idx index of the data to be processed in valueList
  * @param precision integer number showing digits of precision
  * @return percent ranging from 0 to 100
  */
 export function getPercentWithPrecision(valueList: number[], idx: number, precision: number): number {
     if (!valueList[idx]) {
         return 0;
     }

     const sum = zrUtil.reduce(valueList, function (acc, val) {
         return acc + (isNaN(val) ? 0 : val);
     }, 0);
     if (sum === 0) {
         return 0;
     }

     const digits = Math.pow(10, precision);
     const votesPerQuota = zrUtil.map(valueList, function (val) {
         return (isNaN(val) ? 0 : val) / sum * digits * 100;
     });
     const targetSeats = digits * 100;

     const seats = zrUtil.map(votesPerQuota, function (votes) {
         // Assign automatic seats.
         return Math.floor(votes);
     });
     let currentSum = zrUtil.reduce(seats, function (acc, val) {
         return acc + val;
     }, 0);

     const remainder = zrUtil.map(votesPerQuota, function (votes, idx) {
         return votes - seats[idx];
     });

     // Has remainding votes.
     while (currentSum < targetSeats) {
         // Find next largest remainder.
         let max = Number.NEGATIVE_INFINITY;
         let maxId = null;
         for (let i = 0, len = remainder.length; i < len; ++i) {
             if (remainder[i] > max) {
                 max = remainder[i];
                 maxId = i;
             }
         }

         // Add a vote to max remainder.
         ++seats[maxId];
         remainder[maxId] = 0;
         ++currentSum;
     }

     return seats[idx] / digits;
 }

 /**
  * Solve the floating point adding problem like 0.1 + 0.2 === 0.30000000000000004
  * See <http://0.30000000000000004.com/>
  */
 export function addSafe(val0: number, val1: number): number {
     const maxPrecision = Math.max(getPrecision(val0), getPrecision(val1));
     // const multiplier = Math.pow(10, maxPrecision);
     // return (Math.round(val0 * multiplier) + Math.round(val1 * multiplier)) / multiplier;
     const sum = val0 + val1;
     // // PENDING: support more?
     return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX
         ? sum : round(sum, maxPrecision);
 }

 // Number.MAX_SAFE_INTEGER, ie do not support.
 export const MAX_SAFE_INTEGER = 9007199254740991;

 /**
  * To 0 - 2 * PI, considering negative radian.
  */
 export function remRadian(radian: number): number {
     const pi2 = Math.PI * 2;
     return (radian % pi2 + pi2) % pi2;
 }

 /**
  * @param {type} radian
  * @return {boolean}
  */
 export function isRadianAroundZero(val: number): boolean {
     return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;
 }

 // eslint-disable-next-line
 const TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line

 /**
  * @param value valid type: number | string | Date, otherwise return `new Date(NaN)`
  *   These values can be accepted:
  *   + An instance of Date, represent a time in its own time zone.
  *   + Or string in a subset of ISO 8601, only including:
  *     + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',
  *     + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',
  *     + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',
  *     all of which will be treated as local time if time zone is not specified
  *     (see <https://momentjs.com/>).
  *   + Or other string format, including (all of which will be treated as loacal time):
  *     '2012', '2012-3-1', '2012/3/1', '2012/03/01',
  *     '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'
  *   + a timestamp, which represent a time in UTC.
  * @return date Never be null/undefined. If invalid, return `new Date(NaN)`.
  */
 export function parseDate(value: unknown): Date {
     if (value instanceof Date) {
         return value;
     }
     else if (typeof value === 'string') {
         // Different browsers parse date in different way, so we parse it manually.
         // Some other issues:
         // new Date('1970-01-01') is UTC,
         // new Date('1970/01/01') and new Date('1970-1-01') is local.
         // See issue #3623
         const match = TIME_REG.exec(value);

         if (!match) {
             // return Invalid Date.
             return new Date(NaN);
         }

         // Use local time when no timezone offset specifed.
         if (!match[8]) {
             // match[n] can only be string or undefined.
             // But take care of '12' + 1 => '121'.
             return new Date(
                 +match[1],
                 +(match[2] || 1) - 1,
                 +match[3] || 1,
                 +match[4] || 0,
                 +(match[5] || 0),
                 +match[6] || 0,
                 match[7] ? +match[7].substring(0, 3) : 0
             );
         }
         // Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
         // https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
         // For example, system timezone is set as "Time Zone: America/Toronto",
         // then these code will get different result:
         // `new Date(1478411999999).getTimezoneOffset();  // get 240`
         // `new Date(1478412000000).getTimezoneOffset();  // get 300`
         // So we should not use `new Date`, but use `Date.UTC`.
         else {
             let hour = +match[4] || 0;
             if (match[8].toUpperCase() !== 'Z') {
                 hour -= +match[8].slice(0, 3);
             }
             return new Date(Date.UTC(
                 +match[1],
                 +(match[2] || 1) - 1,
                 +match[3] || 1,
                 hour,
                 +(match[5] || 0),
                 +match[6] || 0,
                 match[7] ? +match[7].substring(0, 3) : 0
             ));
         }
     }
     else if (value == null) {
         return new Date(NaN);
     }

     return new Date(Math.round(value as number));
 }

 /**
  * Quantity of a number. e.g. 0.1, 1, 10, 100
  *
  * @param val
  * @return
  */
 export function quantity(val: number): number {
     return Math.pow(10, quantityExponent(val));
 }

 /**
  * Exponent of the quantity of a number
  * e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3
  *
  * @param val non-negative value
  * @return
  */
 export function quantityExponent(val: number): number {
     if (val === 0) {
         return 0;
     }

     let exp = Math.floor(Math.log(val) / Math.LN10);
     /**
      * exp is expected to be the rounded-down result of the base-10 log of val.
      * But due to the precision loss with Math.log(val), we need to restore it
      * using 10^exp to make sure we can get val back from exp. #11249
      */
     if (val / Math.pow(10, exp) >= 10) {
         exp++;
     }
     return exp;
 }

 /**
  * find a “nice” number approximately equal to x. Round the number if round = true,
  * take ceiling if round = false. The primary observation is that the “nicest”
  * numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
  *
  * See "Nice Numbers for Graph Labels" of Graphic Gems.
  *
  * @param  val Non-negative value.
  * @param  round
  * @return Niced number
  */
 export function nice(val: number, round?: boolean): number {
     const exponent = quantityExponent(val);
     const exp10 = Math.pow(10, exponent);
     const f = val / exp10; // 1 <= f < 10
     let nf;
     if (round) {
         if (f < 1.5) {
             nf = 1;
         }
         else if (f < 2.5) {
             nf = 2;
         }
         else if (f < 4) {
             nf = 3;
         }
         else if (f < 7) {
             nf = 5;
         }
         else {
             nf = 10;
         }
     }
     else {
         if (f < 1) {
             nf = 1;
         }
         else if (f < 2) {
             nf = 2;
         }
         else if (f < 3) {
             nf = 3;
         }
         else if (f < 5) {
             nf = 5;
         }
         else {
             nf = 10;
         }
     }
     val = nf * exp10;

     // Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).
     // 20 is the uppper bound of toFixed.
     return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
 }

 /**
  * This code was copied from "d3.js"
  * <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.
  * See the license statement at the head of this file.
  * @param ascArr
  */
 export function quantile(ascArr: number[], p: number): number {
     const H = (ascArr.length - 1) * p + 1;
     const h = Math.floor(H);
     const v = +ascArr[h - 1];
     const e = H - h;
     return e ? v + e * (ascArr[h] - v) : v;
 }

 type IntervalItem = {
     interval: [number, number]
     close: [0 | 1, 0 | 1]
 };
 /**
  * Order intervals asc, and split them when overlap.
  * expect(numberUtil.reformIntervals([
  *     {interval: [18, 62], close: [1, 1]},
  *     {interval: [-Infinity, -70], close: [0, 0]},
  *     {interval: [-70, -26], close: [1, 1]},
  *     {interval: [-26, 18], close: [1, 1]},
  *     {interval: [62, 150], close: [1, 1]},
  *     {interval: [106, 150], close: [1, 1]},
  *     {interval: [150, Infinity], close: [0, 0]}
  * ])).toEqual([
  *     {interval: [-Infinity, -70], close: [0, 0]},
  *     {interval: [-70, -26], close: [1, 1]},
  *     {interval: [-26, 18], close: [0, 1]},
  *     {interval: [18, 62], close: [0, 1]},
  *     {interval: [62, 150], close: [0, 1]},
  *     {interval: [150, Infinity], close: [0, 0]}
  * ]);
  * @param list, where `close` mean open or close
  *        of the interval, and Infinity can be used.
  * @return The origin list, which has been reformed.
  */
 export function reformIntervals(list: IntervalItem[]): IntervalItem[] {
     list.sort(function (a, b) {
         return littleThan(a, b, 0) ? -1 : 1;
     });

     let curr = -Infinity;
     let currClose = 1;
     for (let i = 0; i < list.length;) {
         const interval = list[i].interval;
         const close = list[i].close;

         for (let lg = 0; lg < 2; lg++) {
             if (interval[lg] <= curr) {
                 interval[lg] = curr;
                 close[lg] = (!lg ? 1 - currClose : 1) as 0 | 1;
             }
             curr = interval[lg];
             currClose = close[lg];
         }

         if (interval[0] === interval[1] && close[0] * close[1] !== 1) {
             list.splice(i, 1);
         }
         else {
             i++;
         }
     }

     return list;

     function littleThan(a: IntervalItem, b: IntervalItem, lg: number): boolean {
         return a.interval[lg] < b.interval[lg]
             || (
                 a.interval[lg] === b.interval[lg]
                 && (
                     (a.close[lg] - b.close[lg] === (!lg ? 1 : -1))
                     || (!lg && littleThan(a, b, 1))
                 )
             );
     }
 }

 /**
  * [Numberic is defined as]:
  *     `parseFloat(val) == val`
  * For example:
  * numeric:
  *     typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity,
  *     and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec)
  * not-numeric:
  *     null, undefined, [], {}, true, false, 'NaN', NaN, '123ab',
  *     empty string, string with only white-spaces or line-terminal (see es spec),
  *     0x12, '0x12', '-0x12', 012, '012', '-012',
  *     non-string, ...
  *
  * @test See full test cases in `test/ut/spec/util/number.js`.
  * @return Must be a typeof number. If not numeric, return NaN.
  */
 export function numericToNumber(val: unknown): number {
     const valFloat = parseFloat(val as string);
     return (
         valFloat == val // eslint-disable-line eqeqeq
         && (valFloat !== 0 || typeof val !== 'string' || val.indexOf('x') <= 0) // For case ' 0x0 '.
     ) ? valFloat : NaN;
 }

 /**
  * Definition of "numeric": see `numericToNumber`.
  */
 export function isNumeric(val: unknown): val is number {
     return !isNaN(numericToNumber(val));
 }

 /**
  * Use random base to prevent users hard code depending on
  * this auto generated marker id.
  * @return An positive integer.
  */
 export function getRandomIdBase(): number {
     return Math.round(Math.random() * 9);
 }

 /**
  * Get the greatest common dividor
  *
  * @param {number} a one number
  * @param {number} b the other number
  */
 export function getGreatestCommonDividor(a: number, b: number): number {
     if (b === 0) {
         return a;
     }
     return getGreatestCommonDividor(b, a % b);
 }

 /**
  * Get the least common multiple
  *
  * @param {number} a one number
  * @param {number} b the other number
  */
 export function getLeastCommonMultiple(a: number, b: number) {
     if (a == null) {
         return b;
     }
     if (b == null) {
         return a;
     }
     return a * b / getGreatestCommonDividor(a, b);
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you 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.
	*/

	/*
	* A third-party license is embeded for some of the code in this file:
	* The method "quantile" was copied from "d3.js".
	* (See more details in the comment of the method below.)
	* The use of the source code of this file is also subject to the terms
	* and consitions of the license of "d3.js" (BSD-3Clause, see
	* </licenses/LICENSE-d3>).
	*/

	import * as zrUtil from 'zrender/src/core/util';

	const RADIAN_EPSILON = 1e-4;
	// Although chrome already enlarge this number to 100 for `toFixed`, but
	// we sill follow the spec for compatibility.
	const ROUND_SUPPORTED_PRECISION_MAX = 20;

	function _trim(str: string): string {
	return str.replace(/^\s+\|\s+$/g, '');
	}

	/**
	* Linear mapping a value from domain to range
	* @param val
	* @param domain Domain extent domain[0] can be bigger than domain[1]
	* @param range Range extent range[0] can be bigger than range[1]
	* @param clamp Default to be false
	*/
	export function linearMap(
	val: number,
	domain: number[],
	range: number[],
	clamp?: boolean
	): number {
	const d0 = domain[0];
	const d1 = domain[1];
	const r0 = range[0];
	const r1 = range[1];

	const subDomain = d1 - d0;
	const subRange = r1 - r0;

	if (subDomain === 0) {
	return subRange === 0
	? r0
	: (r0 + r1) / 2;
	}

	// Avoid accuracy problem in edge, such as
	// 146.39 - 62.83 === 83.55999999999999.
	// See echarts/test/ut/spec/util/number.js#linearMap#accuracyError
	// It is a little verbose for efficiency considering this method
	// is a hotspot.
	if (clamp) {
	if (subDomain > 0) {
	if (val <= d0) {
	return r0;
	}
	else if (val >= d1) {
	return r1;
	}
	}
	else {
	if (val >= d0) {
	return r0;
	}
	else if (val <= d1) {
	return r1;
	}
	}
	}
	else {
	if (val === d0) {
	return r0;
	}
	if (val === d1) {
	return r1;
	}
	}

	return (val - d0) / subDomain * subRange + r0;
	}

	/**
	* Convert a percent string to absolute number.
	* Returns NaN if percent is not a valid string or number
	*/
	export function parsePercent(percent: number \| string, all: number): number {
	switch (percent) {
	case 'center':
	case 'middle':
	percent = '50%';
	break;
	case 'left':
	case 'top':
	percent = '0%';
	break;
	case 'right':
	case 'bottom':
	percent = '100%';
	break;
	}
	if (typeof percent === 'string') {
	if (_trim(percent).match(/%$/)) {
	return parseFloat(percent) / 100 * all;
	}

	return parseFloat(percent);
	}

	return percent == null ? NaN : +percent;
	}

	/**
	* (1) Fix rounding error of float numbers.
	* (2) Support return string to avoid scientific notation like '3.5e-7'.
	*/
	export function round(x: number \| string, precision?: number): number;
	export function round(x: number \| string, precision: number, returnStr: false): number;
	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) {
	precision = 10;
	}
	// Avoid range error
	precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX);
	// PENDING: 1.005.toFixed(2) is '1.00' rather than '1.01'
	x = (+x).toFixed(precision);
	return (returnStr ? x : +x);
	}

	/**
	* Inplacd asc sort arr.
	* The input arr will be modified.
	*/
	export function asc<T extends number[]>(arr: T): T {
	arr.sort(function (a, b) {
	return a - b;
	});
	return arr;
	}

	/**
	* Get precision.
	*/
	export function getPrecision(val: string \| number): number {
	val = +val;
	if (isNaN(val)) {
	return 0;
	}

	// It is much faster than methods converting number to string as follows
	// let tmp = val.toString();
	// return tmp.length - 1 - tmp.indexOf('.');
	// especially when precision is low
	// Notice:
	// (1) If the loop count is over about 20, it is slower than `getPrecisionSafe`.
	// (see https://jsbench.me/2vkpcekkvw/1)
	// (2) If the val is less than for example 1e-15, the result may be incorrect.
	// (see test/ut/spec/util/number.test.ts `getPrecision_equal_random`)
	if (val > 1e-14) {
	let e = 1;
	for (let i = 0; i < 15; i++, e *= 10) {
	if (Math.round(val * e) / e === val) {
	return i;
	}
	}
	}

	return getPrecisionSafe(val);
	}

	/**
	* Get precision with slow but safe method
	*/
	export function getPrecisionSafe(val: string \| number): number {
	// toLowerCase for: '3.4E-12'
	const str = val.toString().toLowerCase();

	// Consider scientific notation: '3.4e-12' '3.4e+12'
	const eIndex = str.indexOf('e');
	const exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0;
	const significandPartLen = eIndex > 0 ? eIndex : str.length;
	const dotIndex = str.indexOf('.');
	const decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex;
	return Math.max(0, decimalPartLen - exp);
	}

	/**
	* Minimal dicernible data precisioin according to a single pixel.
	*/
	export function getPixelPrecision(dataExtent: [number, number], pixelExtent: [number, number]): number {
	const log = Math.log;
	const LN10 = Math.LN10;
	const dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
	const sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10);
	// toFixed() digits argument must be between 0 and 20.
	const precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
	return !isFinite(precision) ? 20 : precision;
	}

	/**
	* Get a data of given precision, assuring the sum of percentages
	* in valueList is 1.
	* The largest remainer method is used.
	* https://en.wikipedia.org/wiki/Largest_remainder_method
	*
	* @param valueList a list of all data
	* @param idx index of the data to be processed in valueList
	* @param precision integer number showing digits of precision
	* @return percent ranging from 0 to 100
	*/
	export function getPercentWithPrecision(valueList: number[], idx: number, precision: number): number {
	if (!valueList[idx]) {
	return 0;
	}

	const sum = zrUtil.reduce(valueList, function (acc, val) {
	return acc + (isNaN(val) ? 0 : val);
	}, 0);
	if (sum === 0) {
	return 0;
	}

	const digits = Math.pow(10, precision);
	const votesPerQuota = zrUtil.map(valueList, function (val) {
	return (isNaN(val) ? 0 : val) / sum * digits * 100;
	});
	const targetSeats = digits * 100;

	const seats = zrUtil.map(votesPerQuota, function (votes) {
	// Assign automatic seats.
	return Math.floor(votes);
	});
	let currentSum = zrUtil.reduce(seats, function (acc, val) {
	return acc + val;
	}, 0);

	const remainder = zrUtil.map(votesPerQuota, function (votes, idx) {
	return votes - seats[idx];
	});

	// Has remainding votes.
	while (currentSum < targetSeats) {
	// Find next largest remainder.
	let max = Number.NEGATIVE_INFINITY;
	let maxId = null;
	for (let i = 0, len = remainder.length; i < len; ++i) {
	if (remainder[i] > max) {
	max = remainder[i];
	maxId = i;
	}
	}

	// Add a vote to max remainder.
	++seats[maxId];
	remainder[maxId] = 0;
	++currentSum;
	}

	return seats[idx] / digits;
	}

	/**
	* Solve the floating point adding problem like 0.1 + 0.2 === 0.30000000000000004
	* See <http://0.30000000000000004.com/>
	*/
	export function addSafe(val0: number, val1: number): number {
	const maxPrecision = Math.max(getPrecision(val0), getPrecision(val1));
	// const multiplier = Math.pow(10, maxPrecision);
	// return (Math.round(val0 * multiplier) + Math.round(val1 * multiplier)) / multiplier;
	const sum = val0 + val1;
	// // PENDING: support more?
	return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX
	? sum : round(sum, maxPrecision);
	}

	// Number.MAX_SAFE_INTEGER, ie do not support.
	export const MAX_SAFE_INTEGER = 9007199254740991;

	/**
	* To 0 - 2 * PI, considering negative radian.
	*/
	export function remRadian(radian: number): number {
	const pi2 = Math.PI * 2;
	return (radian % pi2 + pi2) % pi2;
	}

	/**
	* @param {type} radian
	* @return {boolean}
	*/
	export function isRadianAroundZero(val: number): boolean {
	return val > -RADIAN_EPSILON && val < RADIAN_EPSILON;
	}

	// eslint-disable-next-line
	const TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z\|[\+\-]\d\d:?\d\d)?)?)?)?)?$/; // jshint ignore:line

	/**
	* @param value valid type: number \| string \| Date, otherwise return `new Date(NaN)`
	* These values can be accepted:
	* + An instance of Date, represent a time in its own time zone.
	* + Or string in a subset of ISO 8601, only including:
	* + only year, month, date: '2012-03', '2012-03-01', '2012-03-01 05', '2012-03-01 05:06',
	* + separated with T or space: '2012-03-01T12:22:33.123', '2012-03-01 12:22:33.123',
	* + time zone: '2012-03-01T12:22:33Z', '2012-03-01T12:22:33+8000', '2012-03-01T12:22:33-05:00',
	* all of which will be treated as local time if time zone is not specified
	* (see <https://momentjs.com/>).
	* + Or other string format, including (all of which will be treated as loacal time):
	* '2012', '2012-3-1', '2012/3/1', '2012/03/01',
	* '2009/6/12 2:00', '2009/6/12 2:05:08', '2009/6/12 2:05:08.123'
	* + a timestamp, which represent a time in UTC.
	* @return date Never be null/undefined. If invalid, return `new Date(NaN)`.
	*/
	export function parseDate(value: unknown): Date {
	if (value instanceof Date) {
	return value;
	}
	else if (typeof value === 'string') {
	// Different browsers parse date in different way, so we parse it manually.
	// Some other issues:
	// new Date('1970-01-01') is UTC,
	// new Date('1970/01/01') and new Date('1970-1-01') is local.
	// See issue #3623
	const match = TIME_REG.exec(value);

	if (!match) {
	// return Invalid Date.
	return new Date(NaN);
	}

	// Use local time when no timezone offset specifed.
	if (!match[8]) {
	// match[n] can only be string or undefined.
	// But take care of '12' + 1 => '121'.
	return new Date(
	+match[1],
	+(match[2] \|\| 1) - 1,
	+match[3] \|\| 1,
	+match[4] \|\| 0,
	+(match[5] \|\| 0),
	+match[6] \|\| 0,
	match[7] ? +match[7].substring(0, 3) : 0
	);
	}
	// Timezoneoffset of Javascript Date has considered DST (Daylight Saving Time,
	// https://tc39.github.io/ecma262/#sec-daylight-saving-time-adjustment).
	// For example, system timezone is set as "Time Zone: America/Toronto",
	// then these code will get different result:
	// `new Date(1478411999999).getTimezoneOffset(); // get 240`
	// `new Date(1478412000000).getTimezoneOffset(); // get 300`
	// So we should not use `new Date`, but use `Date.UTC`.
	else {
	let hour = +match[4] \|\| 0;
	if (match[8].toUpperCase() !== 'Z') {
	hour -= +match[8].slice(0, 3);
	}
	return new Date(Date.UTC(
	+match[1],
	+(match[2] \|\| 1) - 1,
	+match[3] \|\| 1,
	hour,
	+(match[5] \|\| 0),
	+match[6] \|\| 0,
	match[7] ? +match[7].substring(0, 3) : 0
	));
	}
	}
	else if (value == null) {
	return new Date(NaN);
	}

	return new Date(Math.round(value as number));
	}

	/**
	* Quantity of a number. e.g. 0.1, 1, 10, 100
	*
	* @param val
	* @return
	*/
	export function quantity(val: number): number {
	return Math.pow(10, quantityExponent(val));
	}

	/**
	* Exponent of the quantity of a number
	* e.g., 1234 equals to 1.234*10^3, so quantityExponent(1234) is 3
	*
	* @param val non-negative value
	* @return
	*/
	export function quantityExponent(val: number): number {
	if (val === 0) {
	return 0;
	}

	let exp = Math.floor(Math.log(val) / Math.LN10);
	/**
	* exp is expected to be the rounded-down result of the base-10 log of val.
	* But due to the precision loss with Math.log(val), we need to restore it
	* using 10^exp to make sure we can get val back from exp. #11249
	*/
	if (val / Math.pow(10, exp) >= 10) {
	exp++;
	}
	return exp;
	}

	/**
	* find a “nice” number approximately equal to x. Round the number if round = true,
	* take ceiling if round = false. The primary observation is that the “nicest”
	* numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
	*
	* See "Nice Numbers for Graph Labels" of Graphic Gems.
	*
	* @param val Non-negative value.
	* @param round
	* @return Niced number
	*/
	export function nice(val: number, round?: boolean): number {
	const exponent = quantityExponent(val);
	const exp10 = Math.pow(10, exponent);
	const f = val / exp10; // 1 <= f < 10
	let nf;
	if (round) {
	if (f < 1.5) {
	nf = 1;
	}
	else if (f < 2.5) {
	nf = 2;
	}
	else if (f < 4) {
	nf = 3;
	}
	else if (f < 7) {
	nf = 5;
	}
	else {
	nf = 10;
	}
	}
	else {
	if (f < 1) {
	nf = 1;
	}
	else if (f < 2) {
	nf = 2;
	}
	else if (f < 3) {
	nf = 3;
	}
	else if (f < 5) {
	nf = 5;
	}
	else {
	nf = 10;
	}
	}
	val = nf * exp10;

	// Fix 3 * 0.1 === 0.30000000000000004 issue (see IEEE 754).
	// 20 is the uppper bound of toFixed.
	return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
	}

	/**
	* This code was copied from "d3.js"
	* <https://github.com/d3/d3/blob/9cc9a875e636a1dcf36cc1e07bdf77e1ad6e2c74/src/arrays/quantile.js>.
	* See the license statement at the head of this file.
	* @param ascArr
	*/
	export function quantile(ascArr: number[], p: number): number {
	const H = (ascArr.length - 1) * p + 1;
	const h = Math.floor(H);
	const v = +ascArr[h - 1];
	const e = H - h;
	return e ? v + e * (ascArr[h] - v) : v;
	}

	type IntervalItem = {
	interval: [number, number]
	close: [0 \| 1, 0 \| 1]
	};
	/**
	* Order intervals asc, and split them when overlap.
	* expect(numberUtil.reformIntervals([
	* {interval: [18, 62], close: [1, 1]},
	* {interval: [-Infinity, -70], close: [0, 0]},
	* {interval: [-70, -26], close: [1, 1]},
	* {interval: [-26, 18], close: [1, 1]},
	* {interval: [62, 150], close: [1, 1]},
	* {interval: [106, 150], close: [1, 1]},
	* {interval: [150, Infinity], close: [0, 0]}
	* ])).toEqual([
	* {interval: [-Infinity, -70], close: [0, 0]},
	* {interval: [-70, -26], close: [1, 1]},
	* {interval: [-26, 18], close: [0, 1]},
	* {interval: [18, 62], close: [0, 1]},
	* {interval: [62, 150], close: [0, 1]},
	* {interval: [150, Infinity], close: [0, 0]}
	* ]);
	* @param list, where `close` mean open or close
	* of the interval, and Infinity can be used.
	* @return The origin list, which has been reformed.
	*/
	export function reformIntervals(list: IntervalItem[]): IntervalItem[] {
	list.sort(function (a, b) {
	return littleThan(a, b, 0) ? -1 : 1;
	});

	let curr = -Infinity;
	let currClose = 1;
	for (let i = 0; i < list.length;) {
	const interval = list[i].interval;
	const close = list[i].close;

	for (let lg = 0; lg < 2; lg++) {
	if (interval[lg] <= curr) {
	interval[lg] = curr;
	close[lg] = (!lg ? 1 - currClose : 1) as 0 \| 1;
	}
	curr = interval[lg];
	currClose = close[lg];
	}

	if (interval[0] === interval[1] && close[0] * close[1] !== 1) {
	list.splice(i, 1);
	}
	else {
	i++;
	}
	}

	return list;

	function littleThan(a: IntervalItem, b: IntervalItem, lg: number): boolean {
	return a.interval[lg] < b.interval[lg]
	\|\| (
	a.interval[lg] === b.interval[lg]
	&& (
	(a.close[lg] - b.close[lg] === (!lg ? 1 : -1))
	\|\| (!lg && littleThan(a, b, 1))
	)
	);
	}
	}

	/**
	* [Numberic is defined as]:
	* `parseFloat(val) == val`
	* For example:
	* numeric:
	* typeof number except NaN, '-123', '123', '2e3', '-2e3', '011', 'Infinity', Infinity,
	* and they rounded by white-spaces or line-terminal like ' -123 \n ' (see es spec)
	* not-numeric:
	* null, undefined, [], {}, true, false, 'NaN', NaN, '123ab',
	* empty string, string with only white-spaces or line-terminal (see es spec),
	* 0x12, '0x12', '-0x12', 012, '012', '-012',
	* non-string, ...
	*
	* @test See full test cases in `test/ut/spec/util/number.js`.
	* @return Must be a typeof number. If not numeric, return NaN.
	*/
	export function numericToNumber(val: unknown): number {
	const valFloat = parseFloat(val as string);
	return (
	valFloat == val // eslint-disable-line eqeqeq
	&& (valFloat !== 0 \|\| typeof val !== 'string' \|\| val.indexOf('x') <= 0) // For case ' 0x0 '.
	) ? valFloat : NaN;
	}

	/**
	* Definition of "numeric": see `numericToNumber`.
	*/
	export function isNumeric(val: unknown): val is number {
	return !isNaN(numericToNumber(val));
	}

	/**
	* Use random base to prevent users hard code depending on
	* this auto generated marker id.
	* @return An positive integer.
	*/
	export function getRandomIdBase(): number {
	return Math.round(Math.random() * 9);
	}

	/**
	* Get the greatest common dividor
	*
	* @param {number} a one number
	* @param {number} b the other number
	*/
	export function getGreatestCommonDividor(a: number, b: number): number {
	if (b === 0) {
	return a;
	}
	return getGreatestCommonDividor(b, a % b);
	}

	/**
	* Get the least common multiple
	*
	* @param {number} a one number
	* @param {number} b the other number
	*/
	export function getLeastCommonMultiple(a: number, b: number) {
	if (a == null) {
	return b;
	}
	if (b == null) {
	return a;
	}
	return a * b / getGreatestCommonDividor(a, b);
	}