@lijuhong1981/jsmath 1.0.19 → 1.1.0

package/README.md

@@ -0,0 +1,11 @@
+# `@lijuhong1981/jsmath`
+
+> TODO: description
+
+## Usage
+
+```
+const jsmath = require('@lijuhong1981/jsmath');
+
+// TODO: DEMONSTRATE API
+```

package/index.js

@@ -54,7 +54,7 @@ import parseNumber from "./src/parseNumber.js";
 import randomNumber from "./src/randomNumber.js";
 import randomInteger from "./src/randomInteger.js";
 import toFixed from "./src/toFixed.js";
-import Range from "./src/Range.js";
+import Interval from "./src/Interval.js";
 
 export {
     PI,
@@ -111,5 +111,5 @@ export {
     randomNumber,
     randomInteger,
     toFixed,
-    Range,
+    Interval,
 };

package/package.json

@@ -1,24 +1,18 @@
 {
   "name": "@lijuhong1981/jsmath",
-  "version": "1.0.19",
-  "description": "",
+  "version": "1.1.0",
+  "description": "> TODO: description",
+  "author": "lijuhong1981",
+  "homepage": "https://github.com/lijuhong1981/jslib#readme",
+  "license": "ISC",
+  "type": "module",
   "main": "index.js",
   "module": "index.js",
-  "type": "module",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/lijuhong1981/jsmath.git"
+    "url": "git+https://github.com/lijuhong1981/jslib.git"
   },
-  "author": "lijuhong1981",
-  "license": "ISC",
   "bugs": {
-    "url": "https://github.com/lijuhong1981/jsmath/issues"
-  },
-  "homepage": "https://github.com/lijuhong1981/jsmath#readme",
-  "dependencies": {
-    "@lijuhong1981/jscheck": "^1.0.4"
+    "url": "https://github.com/lijuhong1981/jslib/issues"
   }
-}
+}

package/src/Interval.js

@@ -0,0 +1,316 @@
+import isBetween from "./isBetween";
+import lerp from "./lerp";
+import scalarInRange from "./scalarInRange";
+
+/**
+ * 数学上的区间对象
+*/
+class Interval {
+    /**
+     * 构造函数
+     * @param {Number} start 区间开始值，默认0
+     * @param {Number} end 区间结束值，默认1
+     * @param {Boolean} equalsStart 区间范围是否可等于开始值，默认true
+     * @param {Boolean} equalsEnd 区间范围是否可等于结束值，默认true
+     */
+    constructor(start = 0, end = 1, equalsStart = true, equalsEnd = true) {
+        this.setValues(start, end, equalsStart, equalsEnd);
+    }
+
+    /**
+     * 设置区间参数值
+     * @param {Number} start 区间开始值，默认0
+     * @param {Number} end 区间结束值，默认1
+     * @param {Boolean} equalsStart 区间范围是否可等于开始值，默认true
+     * @param {Boolean} equalsEnd 区间范围是否可等于结束值，默认true
+     * @returns {Interval} 返回自身
+     */
+    setValues(start = 0, end = 1, equalsStart = true, equalsEnd = true) {
+        if (start > end)
+            throw new Error('the start value must be less than or equals end value.');
+
+        this.start = start;
+        this.end = end;
+        this.equalsStart = equalsStart;
+        this.equalsEnd = equalsEnd;
+
+        return this;
+    }
+
+    /**
+     * 判断该区间是否为空集
+     * @returns {Boolean}
+     */
+    isEmpty() {
+        return this.start === this.end;
+    }
+
+    /**
+     * 获取区间长度
+     * @returns {Number}
+     */
+    get length() {
+        return this.end - this.start;
+    }
+
+    /**
+     * 判断一个数值是否处于该区间内
+     * @param {Number} 需要判断的数值
+     * @returns {Boolean} 判断结果
+     */
+    isBetween(value) {
+        return isBetween(value, this.start, this.end, this.equalsStart, this.equalsEnd);
+    }
+
+    /**
+     * 在该区间内线性插值
+     * @param {Number} scalar 插值标量，needClamp为true时约束在[0,1]区间内，为false时可超出[0,1]区间
+     * @param {Boolean} needClamp 是否需要约束插值，默认true
+     * @returns {Number} 插值结果
+     */
+    lerp(scalar, needClamp = true) {
+        return lerp(this.start, this.end, scalar, needClamp);
+    }
+
+    /**
+     * 计算一个数值在当前区间内的线性插值标量
+     * @param {Number} value 需要计算的数值
+     * @param {Boolean} needClamp 是否需要约束至0到1之间，默认true
+     * @returns {Number} 插值标量
+     */
+    scalar(value, needClamp = true) {
+        return scalarInRange(value, this.start, this.end, needClamp);
+    }
+
+    /**
+     * 判断两个区间对象是否相等
+     * @param {Interval} left
+     * @param {Interval} right
+     * @returns {Boolean}
+     */
+    static equals(left, right) {
+        if (left === right)
+            return true;
+        if (left && right
+            && left.start === right.start
+            && left.end === right.end
+            && left.equalsStart === right.equalsStart
+            && left.equalsEnd === right.equalsEnd)
+            return true;
+        return false;
+    }
+
+    /**
+     * 判断当前区间是否与另一个区间相等
+     * @param {Interval} other
+     * @returns {Boolean}
+     */
+    equals(other) {
+        return Interval.equals(this, other);
+    }
+
+    /**
+     * 两个区间相加，left + right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static add(left, right, result = new Interval()) {
+        result.start = left.start + right.start;
+        result.end = left.end + right.end;
+        result.equalsStart = left.equalsStart && right.equalsStart;
+        result.equalsEnd = left.equalsEnd && right.equalsEnd;
+
+        return result;
+    }
+
+    /**
+     * 当前区间与另一个区间相加
+     * @param {Interval} other
+     * @param {Interval} result 结果区间对象，不填时传入自身
+     * @returns {Interval} 结果区间对象
+     */
+    add(other, result) {
+        return Interval.add(this, other, result || this);
+    }
+
+    /**
+     * 两个区间相减，left - right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static subtract(left, right, result = new Interval()) {
+        result.start = left.start - right.start;
+        result.end = left.end - right.end;
+        result.equalsStart = left.equalsStart && right.equalsStart;
+        result.equalsEnd = left.equalsEnd && right.equalsEnd;
+
+        return result;
+    }
+
+    /**
+     * 当前区间减去另一个区间
+     * @param {Interval} other
+     * @param {Interval} result 结果区间对象，不填时传入自身
+     * @returns {Interval} 结果区间对象
+     */
+    subtract(other, result) {
+        return Interval.subtract(this, other, result || this);
+    }
+
+    /**
+     * 两个区间相乘，left x right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static multiply(left, right, result = new Interval()) {
+        const ac = left.start * right.start;
+        const ad = left.start * right.end;
+        const bc = left.end * right.start;
+        const bd = left.end * right.end;
+        result.start = Math.min(ac, ad, bc, bd);
+        result.end = Math.max(ac, ad, bc, bd);
+        result.equalsStart = left.equalsStart && right.equalsStart;
+        result.equalsEnd = left.equalsEnd && right.equalsEnd;
+
+        return result;
+    }
+
+    /**
+     * 当前区间乘以另一个区间
+     * @param {Interval} other
+     * @param {Interval} result 结果区间对象，不填时传入自身
+     * @returns {Interval} 结果区间对象
+     */
+    multiply(other, result) {
+        return Interval.multiply(this, other, result || this);
+    }
+
+    /**
+     * 两个区间相除，left / right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static divide(left, right, result = new Interval()) {
+        const ac = left.start / right.start;
+        const ad = left.start / right.end;
+        const bc = left.end / right.start;
+        const bd = left.end / right.end;
+        result.start = Math.min(ac, ad, bc, bd);
+        result.end = Math.max(ac, ad, bc, bd);
+        result.equalsStart = left.equalsStart && right.equalsStart;
+        result.equalsEnd = left.equalsEnd && right.equalsEnd;
+
+        return result;
+    }
+
+    /**
+     * 当前区间除以另一个区间
+     * @param {Interval} other
+     * @param {Interval} result 结果区间对象，不填时传入自身
+     * @returns {Interval} 结果区间对象
+     */
+    divide(other, result) {
+        return Interval.divide(this, other, result || this);
+    }
+
+    /**
+     * 克隆一个区间对象
+     * @param {Interval} interval 需要克隆的区间对象
+     * @param {Interval} result 结果区间对象，可不设置
+     * @returns {Interval} 结果区间对象
+     */
+    static clone(interval, result = new Interval()) {
+        result.start = interval.start;
+        result.end = interval.end;
+        result.equalsStart = interval.equalsStart;
+        result.equalsEnd = interval.equalsEnd;
+
+        return result;
+    }
+
+    /**
+     * 克隆当前区间对象
+     * @param {Interval} result 结果区间对象，可不设置
+     * @returns {Interval} 结果区间对象
+     */
+    clone(result) {
+        return Interval.clone(this, result);
+    }
+
+    /**
+     * 将一个区间对象的所有属性打包到一个数组中
+     * @param {Interval} interval 需要打包的区间对象
+     * @param {Array} array 打包到的数组
+     * @param {Integer} startingIndex 数组起始索引，默认0
+     * @returns {Array} 打包后的数组
+     */
+    static pack(interval, array = [], startingIndex = 0) {
+        array[startingIndex++] = interval.start;
+        array[startingIndex++] = interval.end;
+        array[startingIndex++] = interval.equalsStart;
+        array[startingIndex++] = interval.equalsEnd;
+
+        return array;
+    }
+
+    /**
+     * 将当前区间对象属性打包至数组
+     * @param {Array} array 打包到的数组
+     * @param {Integer} startingIndex 数组起始索引，默认0
+     * @returns {Array} 打包后的数组
+     */
+    toArray(array, startingIndex = 0) {
+        return Interval.pack(this, array, startingIndex);
+    }
+
+    /**
+     * 从一个数组中提取一个区间对象的所有属性
+     * @param {Array} array 提取属性的数组
+     * @param {Integer} startingIndex 数组起始索引，默认0
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static unpack(array, startingIndex = 0, result = new Interval()) {
+        result.start = array[startingIndex++];
+        result.end = array[startingIndex++];
+        result.equalsStart = array[startingIndex++];
+        result.equalsEnd = array[startingIndex++];
+
+        return result;
+    }
+
+    /**
+     * 等同于Interval.unpack
+     * 
+     * @see Interval.unpack
+    */
+    static fromArray(array, startingIndex, result) {
+        return Interval.unpack(array, startingIndex, result);
+    }
+
+    /**
+     * 从一个数组给当前区间对象赋值
+     * @param {Array} array 提取属性的数组
+     * @param {Integer} startingIndex 数组起始索引，默认0
+     * @returns {Interval} 当前区间对象
+     */
+    setFromArray(array, startingIndex = 0) {
+        return Interval.unpack(array, startingIndex, this);
+    }
+
+    toString() {
+        return 'Interval:' + (this.equalsStart ? '[' : '(') + this.start + ', ' + this.end + (this.equalsEnd ? ']' : ')');
+    }
+};
+
+Interval.packedLength = 4;
+
+export default Interval;

package/src/clamp.js

@@ -1,5 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
-
 /**
  * 将一个数值约束在两个数值之间
  * @param {Number} value 需要约束的数值
@@ -8,9 +6,6 @@ import Check from "@lijuhong1981/jscheck";
  * @returns {Number} 约束后的数值
  */
 function clamp(value, rangeMinimum, rangeMaximum) {
-    Check.typeOf.number('value', value);
-    Check.typeOf.number('rangeMinimum', rangeMinimum);
-    Check.typeOf.number('rangeMaximum', rangeMaximum);
     return value < rangeMinimum ? rangeMinimum : value > rangeMaximum ? rangeMaximum : value;
 };
 

package/src/convertToLatitudeRange.js

@@ -1,4 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
 import { PI_OVER_TWO } from "./Constant.js";
 
 /**
@@ -8,7 +7,6 @@ import { PI_OVER_TWO } from "./Constant.js";
  * @returns {Number} 转换后的纬度
  */
 function convertToLatitudeRange(latitude, degrees = true) {
-    Check.typeOf.number('latitude', latitude);
     if (degrees) {
         while (latitude > 90 || latitude < -90) {
             if (latitude > 90) {

package/src/convertToRange.js

@@ -1,5 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
-
 /**
  * 将一个数值转换至两个数值范围内
  * 如不在范围内则累加或累减范围长度，直至落在范围内
@@ -9,10 +7,6 @@ import Check from "@lijuhong1981/jscheck";
  * @returns {Number} 转换后的数值
  */
 function convertToRange(value, rangeMinimum, rangeMaximum) {
-    Check.typeOf.number('value', value);
-    Check.typeOf.number('rangeMinimum', rangeMinimum);
-    Check.typeOf.number('rangeMaximum', rangeMaximum);
-
     const length = rangeMaximum - rangeMinimum;
     if (value < rangeMinimum) {
         value += length;

package/src/degToRad.js

@@ -1,4 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
 import { RADIANS_PER_DEGREE } from "./Constant.js";
 
 /**
@@ -7,8 +6,6 @@ import { RADIANS_PER_DEGREE } from "./Constant.js";
  * @returns {Number} 弧度
  */
 function degToRad(degrees) {
-    Check.typeOf.number('degrees', degrees);
-
     return degrees * RADIANS_PER_DEGREE;
 };
 

package/src/equalsEpsilon.js

@@ -1,5 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
-
 /**
  * 比较两个数值是否近似相等
  * @param {Number} left 
@@ -8,9 +6,6 @@ import Check from "@lijuhong1981/jscheck";
  * @returns {Boolean}
  */
 function equalsEpsilon(left, right, epsilon = 0) {
-    Check.typeOf.number('left', left);
-    Check.typeOf.number('right', right)
-
     return Math.abs(left - right) <= epsilon;
 };
 

package/src/extractFraction.js

@@ -1,13 +1,9 @@
-import Check from "@lijuhong1981/jscheck";
-
 /**
  * 从一个数值中提取小数部分
  * @param {Number} value 传入的数值
  * @returns {Number} 提取的小数
  */
 function extractFraction(value) {
-    Check.typeOf.number('value', value);
-
     value = value.toString();
     const arr = value.split('.');
     if (arr.length === 2)

package/src/isBetween.js

@@ -1,5 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
-
 /**
  * 判断一个数值是否在两个数值之间
  * @param {Number} value 需要判断的数值
@@ -10,10 +8,6 @@ import Check from "@lijuhong1981/jscheck";
  * @returns {Boolean} 判断结果
  */
 function isBetween(value, rangeMinimum, rangeMaximum, equalsMinimum = true, equalsMaximum = true) {
-    Check.typeOf.number('value', value);
-    Check.typeOf.number('rangeMinimum', rangeMinimum);
-    Check.typeOf.number('rangeMaximum', rangeMaximum);
-
     if (equalsMinimum ? value < rangeMinimum : value <= rangeMinimum)
         return false;
     if (equalsMaximum ? value > rangeMaximum : value >= rangeMaximum)

package/src/lerp.js

@@ -1,4 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
 import clamp from "./clamp.js";
 
 /**
@@ -10,9 +9,6 @@ import clamp from "./clamp.js";
  * @returns {Number} 插值结果
  */
 function lerp(start, end, scalar, needClamp = true) {
-    Check.typeOf.number('start', start);
-    Check.typeOf.number('end', end);
-    Check.typeOf.number('scalar', scalar);
     if (needClamp)
         scalar = clamp(scalar, 0, 1);
     return start + (end - start) * scalar;

package/src/radToDeg.js

@@ -1,4 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
 import { DEGREES_PER_RADIAN } from "./Constant";
 
 /**
@@ -7,8 +6,6 @@ import { DEGREES_PER_RADIAN } from "./Constant";
  * @returns {Number} 角度
  */
 function radToDeg(radians) {
-    Check.typeOf.number('radians', radians);
-
     return radians * DEGREES_PER_RADIAN;
 }
 

package/src/scalarInRange.js

@@ -1,4 +1,3 @@
-import Check from "@lijuhong1981/jscheck";
 import clamp from "./clamp.js";
 
 /**
@@ -10,9 +9,6 @@ import clamp from "./clamp.js";
  * @returns {Number} 插值标量
  */
 function scalarInRange(value, rangeMinimum, rangeMaximum, needClamp = false) {
-    Check.typeOf.number('value', value);
-    Check.typeOf.number('rangeMinimum', rangeMinimum);
-    Check.typeOf.number('rangeMaximum', rangeMaximum);
     let scalar = (value - rangeMinimum) / (rangeMaximum - rangeMinimum);
     if (needClamp)
         scalar = clamp(scalar, 0, 1);

package/src/toFixed.js

@@ -1,14 +1,10 @@
-import Check from "@lijuhong1981/jscheck";
-
 /**
  * 四舍五入一个数值至指定的小数位数
  * @param {Number} value 传入的数值 
- * @param {Number} decimalNumber=2 小数位数
+ * @param {Number} decimalNumber 小数位数
  * @returns {Number}
  */
 function toFixed(value, decimalNumber = 2) {
-    Check.typeOf.number('value', value);
-
     return parseFloat(value.toFixed(decimalNumber));
 }
 

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/src/Range.js

@@ -1,366 +0,0 @@
-import Check, { isValid } from "@lijuhong1981/jscheck";
-import isBetween from "./isBetween.js";
-import lerp from "./lerp.js";
-import scalarInRange from "./scalarInRange.js";
-
-/**
- * Range对象用来表示数学上的区间集合
-*/
-class Range {
-    /**
-     * 构造函数
-     * @param {Number} minimum 区间较小数，默认0
-     * @param {Number} maximum 区间较大数，默认1
-     * @param {Boolean} containsMinimum 区间是否包含较小数，默认true
-     * @param {Boolean} containsMaximum 区间是否包含较大数，默认true
-     */
-    constructor(minimum = 0, maximum = 1, containsMinimum = true, containsMaximum = true) {
-        this.setValues(minimum, maximum, containsMinimum, containsMaximum);
-    }
-
-    get isRange() {
-        return true;
-    }
-
-    ensureMinMaxValue() {
-        if (this.minimum > this.maximum) {
-            const temp = this.minimum;
-            this.minimum = this.maximum;
-            this.maximum = temp;
-        }
-        return this;
-    }
-
-    setValues(minimum, maximum, containsMinimum, containsMaximum) {
-        if (isValid(minimum))
-            this.minimum = minimum;
-        if (isValid(maximum))
-            this.maximum = maximum;
-        if (isValid(containsMinimum))
-            this.containsMinimum = containsMinimum;
-        if (isValid(containsMaximum))
-            this.containsMaximum = containsMaximum;
-
-        this.ensureMinMaxValue();
-
-        return this;
-    }
-
-    /**
-     * @deprecated
-    */
-    set min(value) {
-        this.minimum = value;
-    }
-
-    /**
-     * @deprecated
-    */
-    get min() {
-        return this.minimum;
-    }
-
-    /**
-     * @deprecated
-    */
-    set max(value) {
-        this.maximum = value;
-    }
-
-    /**
-     * @deprecated
-    */
-    get max() {
-        return this.maximum;
-    }
-
-    /**
-     * 判断该区间是否为空集
-     * @returns {Boolean}
-     */
-    isEmpty() {
-        if (this.minimum === this.maximum)
-            return true;
-        return false;
-    }
-
-    /**
-     * 获取区间长度
-     * @returns {Number}
-     */
-    get length() {
-        return this.maximum - this.minimum;
-    }
-
-    /**
-     * 判断一个数值是否处于该区间内
-     * @param {Number} 需要判断的数值
-     * @returns {Boolean}
-     */
-    isBetween(value) {
-        return isBetween(value, this.minimum, this.maximum, this.containsMinimum, this.containsMaximum);
-    }
-
-    /**
-     * 判断一个数值是否处于该区间内
-     * @param {Number} 需要判断的数值
-     * @returns {Boolean}
-     */
-    between(value) {
-        return this.isBetween(value);
-    }
-
-    /**
-     * 在该区间内线性插值
-     * @param {Number} percent 插值百分比，needClamp为true时约束在[0,1]区间内，为false时可超出[0,1]区间
-     * @param {Boolean} needClamp 是否需要约束插值，默认true
-     * @returns {Number} 插值结果
-     */
-    lerp(percent, needClamp = true) {
-        return lerp(this.minimum, this.maximum, percent, needClamp);
-    }
-
-    /**
-     * 计算一个数值在当前区间内的线性插值标量
-     * @param {Number} value 需要计算的数值
-     * @param {Boolean} needClamp 是否需要约束至0到1之间，默认true
-     * @returns {Number} 插值标量
-     */
-    scalar(value, needClamp = true) {
-        return scalarInRange(value, this.minimum, this.maximum, needClamp);
-    }
-
-    /**
-     * 判断两个区间对象是否相等
-     * @param {Range} left
-     * @param {Range} right
-     * @returns {Boolean}
-     */
-    static equals(left, right) {
-        if (left === right)
-            return true;
-        if (left && right && left.minimum === right.minimum && left.maximum === right.maximum && left.containsMinimum === right.containsMinimum && left.containsMaximum === right.containsMaximum)
-            return true;
-        return false;
-    }
-
-    /**
-     * 判断当前区间是否与另一个区间相等
-     * @param {Range} other
-     * @returns {Boolean}
-     */
-    equals(other) {
-        return Range.equals(this, other);
-    }
-
-    /**
-     * 两个区间相加，left + right
-     * @param {Range} left
-     * @param {Range} right
-     * @param {Range} result 结果区间对象，可不填
-     * @returns {Range} 结果区间对象
-     */
-    static add(left, right, result = new Range()) {
-        Check.instanceOf('left', left, Range);
-        Check.instanceOf('right', right, Range);
-
-        result.minimum = left.minimum + right.minimum;
-        result.maximum = left.maximum + right.maximum;
-        result.containsMinimum = left.containsMinimum && right.containsMinimum;
-        result.containsMaximum = left.containsMaximum && right.containsMaximum;
-
-        return result;
-    }
-
-    /**
-     * 当前区间与另一个区间相加
-     * @param {Range} other
-     * @returns {Range} 当前区间对象
-     */
-    add(other) {
-        return Range.add(this, other, this);
-    }
-
-    /**
-     * 两个区间相减，left - right
-     * @param {Range} left
-     * @param {Range} right
-     * @param {Range} result 结果区间对象，可不填
-     * @returns {Range} 结果区间对象
-     */
-    static subtract(left, right, result = new Range()) {
-        Check.instanceOf('left', left, Range);
-        Check.instanceOf('right', right, Range);
-
-        result.minimum = left.minimum - right.minimum;
-        result.maximum = left.maximum - right.maximum;
-        result.containsMinimum = left.containsMinimum && right.containsMinimum;
-        result.containsMaximum = left.containsMaximum && right.containsMaximum;
-
-        return result;
-    }
-
-    /**
-     * 当前区间减去另一个区间
-     * @param {Range} other
-     * @returns {Range} 当前区间对象
-     */
-    subtract(other) {
-        return Range.subtract(this, other, this);
-    }
-
-    /**
-     * 两个区间相乘，left x right
-     * @param {Range} left
-     * @param {Range} right
-     * @param {Range} result 结果区间对象，可不填
-     * @returns {Range} 结果区间对象
-     */
-    static multiply(left, right, result = new Range()) {
-        Check.instanceOf('left', left, Range);
-        Check.instanceOf('right', right, Range);
-
-        const ac = left.minimum * right.minimum;
-        const ad = left.minimum * right.maximum;
-        const bc = left.maximum * right.minimum;
-        const bd = left.maximum * right.maximum;
-        result.minimum = Math.min(ac, ad, bc, bd);
-        result.maximum = Math.max(ac, ad, bc, bd);
-        result.containsMinimum = left.containsMinimum && right.containsMinimum;
-        result.containsMaximum = left.containsMaximum && right.containsMaximum;
-
-        return result;
-    }
-
-    /**
-     * 当前区间乘以另一个区间
-     * @param {Range} other
-     * @returns {Range} 当前区间对象
-     */
-    multiply(other) {
-        return Range.multiply(this, other, this);
-    }
-
-    /**
-     * 两个区间相除，left / right
-     * @param {Range} left
-     * @param {Range} right
-     * @param {Range} result 结果区间对象，可不填
-     * @returns {Range} 结果区间对象
-     */
-    static divide(left, right, result = new Range()) {
-        Check.instanceOf('left', left, Range);
-        Check.instanceOf('right', right, Range);
-
-        const ac = left.minimum / right.minimum;
-        const ad = left.minimum / right.maximum;
-        const bc = left.maximum / right.minimum;
-        const bd = left.maximum / right.maximum;
-        result.minimum = Math.min(ac, ad, bc, bd);
-        result.maximum = Math.max(ac, ad, bc, bd);
-        result.containsMinimum = left.containsMinimum && right.containsMinimum;
-        result.containsMaximum = left.containsMaximum && right.containsMaximum;
-
-        return result;
-    }
-
-    /**
-     * 当前区间除以另一个区间
-     * @param {Range} other
-     * @returns {Range} 当前区间对象
-     */
-    divide(other) {
-        return Range.divide(this, other, this);
-    }
-
-    /**
-     * 克隆一个区间对象
-     * @param {Range} range 需要克隆的区间对象
-     * @param {Range} result 结果区间对象，可不设置
-     * @returns {Range} 结果区间对象
-     */
-    static clone(range, result = new Range()) {
-        Check.instanceOf('range', range, Range);
-
-        result.minimum = range.minimum;
-        result.maximum = range.maximum;
-        result.containsMinimum = range.containsMinimum;
-        result.containsMaximum = range.containsMaximum;
-
-        return result;
-    }
-
-    /**
-     * 克隆当前区间对象
-     * @param {Range} result 结果区间对象，可不设置
-     * @returns {Range} 结果区间对象
-     */
-    clone(result) {
-        return Range.clone(this, result);
-    }
-
-    /**
-     * 将一个区间对象的所有属性打包到一个数组中
-     * @param {Range} range 需要打包的区间对象
-     * @param {Array} array 打包到的数组
-     * @param {Integer} startingIndex 数组起始索引，默认0
-     * @returns {Array} 打包后的数组
-     */
-    static pack(range, array = [], startingIndex = 0) {
-        Check.instanceOf('range', range, Range);
-
-        array[startingIndex++] = range.minimum;
-        array[startingIndex++] = range.maximum;
-        array[startingIndex++] = range.containsMinimum;
-        array[startingIndex++] = range.containsMaximum;
-
-        return array;
-    }
-
-    /**
-     * 将当前区间对象属性打包至数组
-     * @param {Array} array 打包到的数组
-     * @param {Integer} startingIndex 数组起始索引，默认0
-     * @returns {Array} 打包后的数组
-     */
-    toArray(array, startingIndex = 0) {
-        return Range.pack(this, array, startingIndex);
-    }
-
-    /**
-     * 从一个数组中提取一个区间对象的所有属性
-     * @param {Array} array 提取属性的数组
-     * @param {Integer} startingIndex 数组起始索引，默认0
-     * @param {Range} result 结果区间对象，可不填
-     * @returns {Range} 结果区间对象
-     */
-    static unpack(array, startingIndex = 0, result = new Range()) {
-        Check.typeOf.array("array", array);
-        //>>includeEnd('debug');
-
-        result.minimum = array[startingIndex++];
-        result.maximum = array[startingIndex++];
-        result.containsMinimum = array[startingIndex++];
-        result.containsMaximum = array[startingIndex++];
-
-        return result;
-    }
-
-    /**
-     * 从一个数组给当前区间对象赋值
-     * @param {Array} array 提取属性的数组
-     * @param {Integer} startingIndex 数组起始索引，默认0
-     * @returns {Range} 当前区间对象
-     */
-    fromArray(array, startingIndex = 0) {
-        return Range.unpack(array, startingIndex, this);
-    }
-
-    toString() {
-        return 'Range:' + this.containsMinimum ? '[' : '(' + this.minimum + ', ' + this.maximum + this.containsMaximum ? ']' : ')';
-    }
-};
-
-Range.packedLength = 4;
-
-export default Range;