@lijuhong1981/jsmath 1.0.6 → 1.0.7

package/index.js

@@ -25,7 +25,7 @@ import lerp from "./src/lerp.js";
 import percentInRange from "./src/percentInRange.js";
 import randomInteger from "./src/randomInteger.js";
 import randomNumber from "./src/randomNumber.js";
-import Interval from "./src/Interval.js";
+import Range from "./src/Range.js";
 
 export {
     PI,
@@ -53,5 +53,5 @@ export {
     percentInRange,
     randomInteger,
     randomNumber,
-    Interval,
+    Range,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lijuhong1981/jsmath",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "",
   "main": "index.js",
   "module": "index.js",

package/src/{Interval.js → Range.js}

@@ -3,18 +3,18 @@ import isBetween from "./isBetween.js";
 import lerp from "./lerp.js";
 import percentInRange from "./percentInRange.js";
 
-function checkMinMaxValue(interval) {
-    if (interval.minimum > interval.maximum) {
-        const temp = interval.minimum;
-        interval.minimum = interval.maximum;
-        interval.maximum = temp;
+function checkMinMaxValue(range) {
+    if (range.minimum > range.maximum) {
+        const temp = range.minimum;
+        range.minimum = range.maximum;
+        range.maximum = temp;
     }
 }
 
 /**
- * Interval对象用来表示数学上的区间集合
+ * Range对象用来表示数学上的区间集合
 */
-class Interval {
+class Range {
     /**
      * 构造函数
      * @param {Number} minimum 区间较小数，默认0
@@ -30,10 +30,38 @@ class Interval {
         checkMinMaxValue(this);
     }
 
-    get isInterval() {
+    get isRange() {
         return true;
     }
 
+    /**
+     * @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}
@@ -83,13 +111,13 @@ class Interval {
 
     /**
      * 判断两个区间对象是否相等
-     * @param {Interval} left
-     * @param {Interval} right
+     * @param {Range} left
+     * @param {Range} right
      * @returns {Boolean}
      */
     static equals(left, right) {
-        Check.instanceOf('left', left, Interval);
-        Check.instanceOf('right', right, Interval);
+        Check.instanceOf('left', left, Range);
+        Check.instanceOf('right', right, Range);
         if (left === right)
             return true;
         if (left && right && left.minimum === right.minimum && left.maximum === right.maximum && left.containsMinimum === right.containsMinimum && left.containsMaximum === right.containsMaximum)
@@ -99,23 +127,23 @@ class Interval {
 
     /**
      * 判断当前区间是否与另一个区间相等
-     * @param {Interval} other
+     * @param {Range} other
      * @returns {Boolean}
      */
     equals(other) {
-        return Interval.equals(this, other);
+        return Range.equals(this, other);
     }
 
     /**
      * 两个区间相加，left + right
-     * @param {Interval} left
-     * @param {Interval} right
-     * @param {Interval} result 结果区间对象，可不填
-     * @returns {Interval} 结果区间对象
+     * @param {Range} left
+     * @param {Range} right
+     * @param {Range} result 结果区间对象，可不填
+     * @returns {Range} 结果区间对象
      */
-    static add(left, right, result = new Interval()) {
-        Check.instanceOf('left', left, Interval);
-        Check.instanceOf('right', right, Interval);
+    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;
@@ -127,23 +155,23 @@ class Interval {
 
     /**
      * 当前区间与另一个区间相加
-     * @param {Interval} other
-     * @returns {Interval} 当前区间对象
+     * @param {Range} other
+     * @returns {Range} 当前区间对象
      */
     add(other) {
-        return Interval.add(this, other, this);
+        return Range.add(this, other, this);
     }
 
     /**
      * 两个区间相减，left - right
-     * @param {Interval} left
-     * @param {Interval} right
-     * @param {Interval} result 结果区间对象，可不填
-     * @returns {Interval} 结果区间对象
+     * @param {Range} left
+     * @param {Range} right
+     * @param {Range} result 结果区间对象，可不填
+     * @returns {Range} 结果区间对象
      */
-    static subtract(left, right, result = new Interval()) {
-        Check.instanceOf('left', left, Interval);
-        Check.instanceOf('right', right, Interval);
+    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;
@@ -155,23 +183,23 @@ class Interval {
 
     /**
      * 当前区间减去另一个区间
-     * @param {Interval} other
-     * @returns {Interval} 当前区间对象
+     * @param {Range} other
+     * @returns {Range} 当前区间对象
      */
     subtract(other) {
-        return Interval.subtract(this, other, this);
+        return Range.subtract(this, other, this);
     }
 
     /**
      * 两个区间相乘，left x right
-     * @param {Interval} left
-     * @param {Interval} right
-     * @param {Interval} result 结果区间对象，可不填
-     * @returns {Interval} 结果区间对象
+     * @param {Range} left
+     * @param {Range} right
+     * @param {Range} result 结果区间对象，可不填
+     * @returns {Range} 结果区间对象
      */
-    static multiply(left, right, result = new Interval()) {
-        Check.instanceOf('left', left, Interval);
-        Check.instanceOf('right', right, Interval);
+    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;
@@ -187,23 +215,23 @@ class Interval {
 
     /**
      * 当前区间乘以另一个区间
-     * @param {Interval} other
-     * @returns {Interval} 当前区间对象
+     * @param {Range} other
+     * @returns {Range} 当前区间对象
      */
     multiply(other) {
-        return Interval.multiply(this, other, this);
+        return Range.multiply(this, other, this);
     }
 
     /**
      * 两个区间相除，left / right
-     * @param {Interval} left
-     * @param {Interval} right
-     * @param {Interval} result 结果区间对象，可不填
-     * @returns {Interval} 结果区间对象
+     * @param {Range} left
+     * @param {Range} right
+     * @param {Range} result 结果区间对象，可不填
+     * @returns {Range} 结果区间对象
      */
-    static divide(left, right, result = new Interval()) {
-        Check.instanceOf('left', left, Interval);
-        Check.instanceOf('right', right, Interval);
+    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;
@@ -219,53 +247,53 @@ class Interval {
 
     /**
      * 当前区间除以另一个区间
-     * @param {Interval} other
-     * @returns {Interval} 当前区间对象
+     * @param {Range} other
+     * @returns {Range} 当前区间对象
      */
     divide(other) {
-        return Interval.divide(this, other, this);
+        return Range.divide(this, other, this);
     }
 
     /**
      * 克隆一个区间对象
-     * @param {Interval} interval 需要克隆的区间对象
-     * @param {Interval} result 结果区间对象，可不设置
-     * @returns {Interval} 结果区间对象
+     * @param {Range} range 需要克隆的区间对象
+     * @param {Range} result 结果区间对象，可不设置
+     * @returns {Range} 结果区间对象
      */
-    static clone(interval, result = new Interval()) {
-        Check.instanceOf('interval', interval, Interval);
+    static clone(range, result = new Range()) {
+        Check.instanceOf('range', range, Range);
 
-        result.minimum = interval.minimum;
-        result.maximum = interval.maximum;
-        result.containsMinimum = interval.containsMinimum;
-        result.containsMaximum = interval.containsMaximum;
+        result.minimum = range.minimum;
+        result.maximum = range.maximum;
+        result.containsMinimum = range.containsMinimum;
+        result.containsMaximum = range.containsMaximum;
 
         return result;
     }
 
     /**
      * 克隆当前区间对象
-     * @param {Interval} result 结果区间对象，可不设置
-     * @returns {Interval} 结果区间对象
+     * @param {Range} result 结果区间对象，可不设置
+     * @returns {Range} 结果区间对象
      */
     clone(result) {
-        return Interval.clone(this, result);
+        return Range.clone(this, result);
     }
 
     /**
      * 将一个区间对象的所有属性打包到一个数组中
-     * @param {Interval} interval 需要打包的区间对象
+     * @param {Range} range 需要打包的区间对象
      * @param {Array} array 打包到的数组
      * @param {Integer} startingIndex 数组起始索引，默认0
      * @returns {Array} 打包后的数组
      */
-    static pack(interval, array = [], startingIndex = 0) {
-        Check.instanceOf('interval', interval, Interval);
+    static pack(range, array = [], startingIndex = 0) {
+        Check.instanceOf('range', range, Range);
 
-        array[startingIndex++] = interval.minimum;
-        array[startingIndex++] = interval.maximum;
-        array[startingIndex++] = interval.containsMinimum;
-        array[startingIndex++] = interval.containsMaximum;
+        array[startingIndex++] = range.minimum;
+        array[startingIndex++] = range.maximum;
+        array[startingIndex++] = range.containsMinimum;
+        array[startingIndex++] = range.containsMaximum;
 
         return array;
     }
@@ -277,17 +305,17 @@ class Interval {
      * @returns {Array} 打包后的数组
      */
     toArray(array, startingIndex = 0) {
-        return Interval.pack(this, array, startingIndex);
+        return Range.pack(this, array, startingIndex);
     }
 
     /**
      * 从一个数组中提取一个区间对象的所有属性
      * @param {Array} array 提取属性的数组
      * @param {Integer} startingIndex 数组起始索引，默认0
-     * @param {Interval} result 结果区间对象，可不填
-     * @returns {Interval} 结果区间对象
+     * @param {Range} result 结果区间对象，可不填
+     * @returns {Range} 结果区间对象
      */
-    static unpack(array, startingIndex = 0, result = new Interval()) {
+    static unpack(array, startingIndex = 0, result = new Range()) {
         Check.typeOf.array("array", array);
         //>>includeEnd('debug');
 
@@ -303,17 +331,17 @@ class Interval {
      * 从一个数组给当前区间对象赋值
      * @param {Array} array 提取属性的数组
      * @param {Integer} startingIndex 数组起始索引，默认0
-     * @returns {Interval} 当前区间对象
+     * @returns {Range} 当前区间对象
      */
     fromArray(array, startingIndex = 0) {
-        return Interval.unpack(array, startingIndex, this);
+        return Range.unpack(array, startingIndex, this);
     }
 
     toString() {
-        return 'Interval:' + this.containsMinimum ? '[' : '(' + this.minimum + ', ' + this.maximum + this.containsMaximum ? ']' : ')'
+        return 'Range:' + this.containsMinimum ? '[' : '(' + this.minimum + ', ' + this.maximum + this.containsMaximum ? ']' : ')'
     }
 };
 
-Interval.packedLength = 4;
+Range.packedLength = 4;
 
-export default Interval;
+export default Range;