@lijuhong1981/jsmath 1.0.4 → 1.0.5

package/index.js

@@ -21,10 +21,11 @@ import convertToRadiansCircular from "./src/convertToRadiansCircular.js";
 import convertToLatitudeRange from "./src/convertToLatitudeRange.js";
 import convertToLongitudeRange from "./src/convertToLongitudeRange.js";
 import isBetween from "./src/isBetween.js";
+import lerp from "./src/lerp.js";
 import percentInRange from "./src/percentInRange.js";
-import percentToRange from "./src/percentToRange.js";
 import randomInteger from "./src/randomInteger.js";
 import randomNumber from "./src/randomNumber.js";
+import Interval from "./src/Interval.js";
 
 export {
     PI,
@@ -48,8 +49,9 @@ export {
     convertToLatitudeRange,
     convertToLongitudeRange,
     isBetween,
+    lerp,
     percentInRange,
-    percentToRange,
     randomInteger,
     randomNumber,
+    Interval,
 };

package/package.json

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

package/src/Interval.js

@@ -0,0 +1,319 @@
+import Check from "@lijuhong1981/jscheck";
+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;
+    }
+}
+
+/**
+ * Interval对象用来表示数学上的区间集合
+*/
+class Interval {
+    /**
+     * 构造函数
+     * @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.minimum = minimum;
+        this.maximum = maximum;
+        this.containsMinimum = containsMinimum;
+        this.containsMaximum = containsMaximum;
+        checkMinMaxValue(this);
+    }
+
+    get isInterval() {
+        return true;
+    }
+
+    /**
+     * 判断该区间是否为空集
+     * @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} 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} 百分比
+     */
+    percent(value, needClamp = true) {
+        return percentInRange(value, this.minimum, this.maximum, needClamp);
+    }
+
+    /**
+     * 判断两个区间对象是否相等
+     * @param {Interval} left
+     * @param {Interval} right
+     * @returns {Boolean}
+     */
+    static equals(left, right) {
+        Check.instanceOf('left', left, Interval);
+        Check.instanceOf('right', right, Interval);
+        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 {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()) {
+        Check.instanceOf('left', left, Interval);
+        Check.instanceOf('right', right, Interval);
+
+        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 {Interval} other
+     * @returns {Interval} 当前区间对象
+     */
+    add(other) {
+        return Interval.add(this, other, this);
+    }
+
+    /**
+     * 两个区间相减，left - right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static subtract(left, right, result = new Interval()) {
+        Check.instanceOf('left', left, Interval);
+        Check.instanceOf('right', right, Interval);
+
+        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 {Interval} other
+     * @returns {Interval} 当前区间对象
+     */
+    subtract(other) {
+        return Interval.subtract(this, other, this);
+    }
+
+    /**
+     * 两个区间相乘，left x right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static multiply(left, right, result = new Interval()) {
+        Check.instanceOf('left', left, Interval);
+        Check.instanceOf('right', right, Interval);
+
+        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 {Interval} other
+     * @returns {Interval} 当前区间对象
+     */
+    multiply(other) {
+        return Interval.multiply(this, other, this);
+    }
+
+    /**
+     * 两个区间相除，left / right
+     * @param {Interval} left
+     * @param {Interval} right
+     * @param {Interval} result 结果区间对象，可不填
+     * @returns {Interval} 结果区间对象
+     */
+    static divide(left, right, result = new Interval()) {
+        Check.instanceOf('left', left, Interval);
+        Check.instanceOf('right', right, Interval);
+
+        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 {Interval} other
+     * @returns {Interval} 当前区间对象
+     */
+    divide(other) {
+        return Interval.divide(this, other, this);
+    }
+
+    /**
+     * 克隆一个区间对象
+     * @param {Interval} interval 需要克隆的区间对象
+     * @param {Interval} result 结果区间对象，可不设置
+     * @returns {Interval} 结果区间对象
+     */
+    static clone(interval, result = new Interval()) {
+        Check.instanceOf('interval', interval, Interval);
+
+        result.minimum = interval.minimum;
+        result.maximum = interval.maximum;
+        result.containsMinimum = interval.containsMinimum;
+        result.containsMaximum = interval.containsMaximum;
+
+        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) {
+        Check.instanceOf('interval', interval, Interval);
+
+        array[startingIndex++] = interval.minimum;
+        array[startingIndex++] = interval.maximum;
+        array[startingIndex++] = interval.containsMinimum;
+        array[startingIndex++] = interval.containsMaximum;
+
+        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()) {
+        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 {Interval} 当前区间对象
+     */
+    fromArray(array, startingIndex = 0) {
+        return Interval.unpack(array, startingIndex, this);
+    }
+
+    toString() {
+        return 'Interval:' + this.containsMinimum ? '[' : '(' + this.minimum + ', ' + this.maximum + this.containsMaximum ? ']' : ')'
+    }
+};
+
+Interval.packedLength = 4;
+
+export default Interval;

package/src/clampLatitude.js

@@ -1,4 +1,5 @@
-import { PI_OVER_TWO, clamp } from "@lijuhong1981/jsmath";
+import { PI_OVER_TWO } from "./Constant.js";
+import clamp from "./clamp.js";
 
 /**
  * 将一个纬度值约束在纬度范围内

package/src/clampLongitude.js

@@ -1,4 +1,4 @@
-import { clamp } from "@lijuhong1981/jsmath";
+import clamp from "./clamp.js";
 
 /**
  * 将一个经度值约束在经度范围内

package/src/convertToLatitudeRange.js

@@ -1,6 +1,14 @@
-import { PI_OVER_TWO } from "@lijuhong1981/jsmath";
+import Check from "@lijuhong1981/jscheck";
+import { PI_OVER_TWO } from "./Constant.js";
 
+/**
+ * 转换一个纬度值至纬度范围内
+ * @param {Number} latitude 需要转换的纬度值
+ * @param {Boolean} degrees 单位，true表示角度单位，false表示弧度单位，默认true
+ * @returns {Number} 转换后的纬度
+ */
 function convertToLatitudeRange(latitude, degrees = true) {
+    Check.typeOf.number('latitude', latitude);
     if (degrees) {
         while (latitude > 90 || latitude < -90) {
             if (latitude > 90) {

package/src/convertToLongitudeRange.js

@@ -1,5 +1,11 @@
-import { convertToRange } from "@lijuhong1981/jsmath";
+import { convertToRange } from "./convertToRange.js";
 
+/**
+ * 转换一个经度值至经度范围内
+ * @param {Number} longitude 需要转换的经度值
+ * @param {Boolean} degrees 单位，true表示角度单位，false表示弧度单位，默认true
+ * @returns {Number} 转换后的经度
+ */
 function convertToLongitudeRange(longitude, degrees = true) {
     if (degrees)
         return convertToRange(longitude, -180, 180);

package/src/lerp.js

@@ -0,0 +1,21 @@
+import Check from "@lijuhong1981/jscheck";
+import clamp from "./clamp.js";
+
+/**
+ * 在两个数值间线性插值
+ * @param {Number} strat 开始数值
+ * @param {Number} end 结束数值
+ * @param {Number} percent 插值百分比，needClamp为true时约束在[0,1]区间内，为false时可超出[0,1]区间
+ * @param {Boolean} needClamp 是否需要约束插值，默认true
+ * @returns {Number} 插值结果
+ */
+function lerp(strat, end, percent, needClamp = true) {
+    Check.typeOf.number('strat', strat);
+    Check.typeOf.number('end', end);
+    Check.typeOf.number('percent', percent);
+    if (needClamp)
+        percent = clamp(percent, 0, 1);
+    return strat + (end - strat) * percent;
+};
+
+export default lerp;

package/src/percentInRange.js

@@ -2,7 +2,7 @@ import Check from "@lijuhong1981/jscheck";
 import clamp from "./clamp.js";
 
 /**
- * 计算一个数值在两个数值范围内的百分比
+ * 计算一个数值在两个数值范围内的线性插值百分比
  * @param {Number} value 需要计算的数值
  * @param {Number} rangeMinimum 较小数
  * @param {Number} rangeMaximum 较大数

package/src/percentToRange.js

@@ -1,21 +0,0 @@
-import Check from "@lijuhong1981/jscheck";
-import clamp from "./clamp.js";
-
-/**
- * 根据百分比计算在两个数值之间的数
- * @param {Number} percent 百分比
- * @param {Number} rangeMinimum 较小数
- * @param {Number} rangeMaximum 较大数
- * @param {Boolean} needClamp 是否需要约束至两个数值之间，默认false
- * @returns {Number} 计算结果
- */
-function percentToRange(percent, rangeMinimum, rangeMaximum, needClamp = false) {
-    Check.typeOf.number('value', value);
-    Check.typeOf.number('rangeMinimum', rangeMinimum);
-    Check.typeOf.number('rangeMaximum', rangeMaximum);
-    if (needClamp)
-        percent = clamp(percent, 0, 1);
-    return rangeMinimum + (rangeMaximum - rangeMinimum) * percent;
-};
-
-export default percentToRange;