映射
系数映射

系数映射 - computeRate(val, rate)

功能：根据指定的速率对数值进行映射。

参数：

  • {number} val - 数值
  • {number} rate - 系数

返回值：

  • {number} - 倍率值
1
2
3
4
Math.computeRate = function(val, rate) {
    let r = rate * Math.abs(val) / (1 + rate * Math.abs(val));
    return val >= 0 ? r : -r;
};

线性插值

线性插值 - lerp(start, end, t)

功能：在两个数值之间进行线性插值。

参数：

  • {number} start - 起始值
  • {number} end - 结束值
  • {number} t - 插值比例（通常为 0-1）

返回值：

  • {number} - 插值结果
1
2
3
Math.lerp = function(start, end, t) {
    return start + (end - start) * t;
};

正弦波

正弦波映射 - sinNum(max, i)

功能：计算指定索引在最大区间内的正弦波位置（映射到 0 到 π/2 范围）

参数：

  • {number} max - 最大范围
  • {number} i - 当前索引

返回值：

  • {number} - 正弦值。
1
2
3
Math.sinNum = function(max, i) {
    return Math.sin((Math.PI / 2) / max * i);
};

三角波

三角波映射 - triNum(max, i)

功能：生成指定区间的三角波数值映射。

参数：

  • {number} max - 最大范围
  • {number} i - 当前索引

返回值：

  • {number} - 三角波值
1
2
3
Math.triNum = function(max, i) {
    return (2 / Math.PI) * Math.asin(Math.sin((Math.PI / 2) / max * i));
};

方波

方波映射 - squNum(max, i)

功能：生成指定区间的方波数值映射。

参数：

  • {number} max - 最大范围
  • {number} i - 当前索引

返回值：

  • {number} - 方波值（1, -1 或 0）
1
2
3
Math.squNum = function(max, i) {
    return Math.sign(Math.sin((Math.PI / 2) / max * i));
};

逆正弦波

逆正弦映射 - sinRes(max, result)

功能：已知正弦结果，反求其在指定最大区间内的对应索引位置。

参数：

  • {number} max - 最大范围
  • {number} result - 正弦结果值

返回值：

  • {number} - 对应的索引值
1
2
3
Math.sinRes = function(max, result) {
    return Math.asin(result) * (2 * max / Math.PI);
};

数论
最大公约数

最大公约数 - gcd(a, b)

功能：计算两个整数的最大公约数（使用辗转相除法）。

参数：

  • {number} a - 数值A
  • {number} b - 数值B

返回值：
{number} - 最大公约数

1
2
3
4
5
Math.gcd = function(a, b) {
    while (b !== 0) [a, b] = [b, a % b];
    return a;
};

最小公倍数

最小公倍数 - lcm(a, b)

功能：计算两个整数的最小公倍数。

参数：

  • {number} a - 数值A
  • {number} b - 数值B

返回值
{number} - 最小公倍数

1
2
3
Math.lcm = function(a, b) {
    return Math.abs(a * b) / Math.gcd(a, b);
};

分数约分

分数约分 - lowestTerms(n, d)

功能：将分子和分母化简为最简分数形式。

参数：

  • {number} a - 分子
  • {number} b - 分母

返回值：
{Array<number>} - 最简分数形式

1
2
3
4
Math.lowestTerms = function(n, d) {
    const gcd = Math.gcd(n, d);
    return [n / gcd, d / gcd];
};

等差数列求和

等差数列求和 - sumToN(n)

功能：快速计算从 1 累加到 n 的自然数之和。

参数：

  • {number} n - 终止值

返回值：

  • {number} - 累加和
1
2
3
Math.sumToN = function (n) {
    return n * (n + 1) / 2;
};

质数判断

质数判断 - isPrime(num)

功能：判断一个数字是否为质数。

参数：

  • {number} num - 待检测的数字

返回值：

  • {boolean} - 是否为质数
1
2
3
4
5
6
7
8
Math.isPrime = function(num) {
    if (num <= 1) return false;
    if (num <= 3) return true;
    if (num % 2 === 0 || num % 3 === 0) return false;
    for (let i = 5; i * i <= num; i += 6)
        if (num % i === 0 || num % (i + 2) === 0) return false;
    return true;
};

获取质数序列

获取质数序列 - getPrimes(num)

功能：获取前 n 个质数组成的数组。

参数：

  • {number} num - 需要获取的质数个数

返回值：

  • {Array<number>} - 质数数组
1
2
3
4
5
6
7
8
9
Math.getPrimes = function(num) {
    const arr = [2, 3];
    let i = 5;
    while (arr.length < num) {
        if (!arr.some(n => i % n === 0 && n * n <= i)) arr.push(i);
        i += i % 6 === 1 ? 4 : 2;
    }
    return arr;
};

位运算
位查询

位查询 - atBit(num, bit)

功能：检查数字在指定二进制位（bit）上的值。

参数：

  • {number} num - 目标数字
  • {number} bit - 位偏移量

返回值：

  • {number} - 该位的值（0 或 1）
1
2
3
Math.atBit = function(num, bit) {
    return (num >> bit) & 1;
};

位设置

位设置 - setBit(num, bit, bool)

功能：设置数字在指定位（bit）上的值为 1 或 0。

参数：

  • {number} num - 目标数字
  • {number} bit - 位偏移量
  • {boolean} bool - 为 true 设置为 1，false 设置为 0

返回值：

  • {number} - 修改后的数字
1
2
3
Math.setBit = function(num, bit, bool) {
    return bool ? (num | (1 << bit)) : (num & ~(1 << bit));
};

角度与方向
角度转弧度

角度转弧度 - toRadians(degrees)

功能：将角度值转换为弧度值。

参数：

  • {number} degrees - 角度

返回值：

  • {number} - 弧度
1
Math.toRadians = degrees => degrees * Math.PI / 180;

弧度转角度

弧度转角度 - toDegrees(radians)

功能：将弧度值转换为角度值。

参数：

  • {number} radians - 弧度

返回值：

  • {number} - 角度
1
Math.toDegrees = radians => radians * 180 / Math.PI;

获取两点方向角

获取两点方向角 - directionAngle(p1, p2)

功能：计算从点 p1 指向点 p2 的方位角（0° 到 360°）。

参数：

  • {Object} p1 - 起始点，包含 x, y 属性
  • {Object} p2 - 目标点，包含 x, y 属性

返回值：

  • {number} - 角度值
1
2
3
4
Math.directionAngle = function(p1, p2) {
    const angle = Math.atan2(p2.y - p1.y, p2.x - p1.x) * (180 / Math.PI);
    return angle < 0 ? angle + 360 : angle;
};

极坐标求点

极坐标求点 - azimuth(point, angle, distance)

功能：给定起始点、角度和距离，计算终点的坐标。

参数：

  • {Object} point - 起始点，格式 {x, y}
  • {number} angle - 角度（度）
  • {number} distance - 距离

返回值：

  • {Object} - 目标点坐标 {x, y}
1
2
3
4
5
6
Math.azimuth = function(point, angle, distance) {
    return {
        x: point.x + distance * Math.cos(Math.toRadians(angle)),
        y: point.y + distance * Math.sin(Math.toRadians(angle))
    };
};

批量极坐标求点

批量极坐标求点 - calcFromPoints(point, angles, distances)

功能：基于一个中心点，根据给定的多个角度和距离数组，批量计算目标点坐标。

参数：

  • {Object(x,y)} point - 中心点
  • {Array<number>} angles - 角度数组
  • {Array<number>} distances - 距离数组

返回值：

  • {Array<Object(x,y)>} - 坐标数组
1
2
3
4
5
Math.calcFromPoints = function(point, angles, distances) {
    return angles.map((ang, i) => {
        return Math.azimuth(point, ang, distances[i]);
    });
};

射线延长点

射线延长点 - extRay(p1, p2, d)

功能：从 p1 向 p2 发射射线，在 p2 的方向上继续延长距离 d 获取终点。

参数：

  • {Object(x,y)} p1 - 射线起点
  • {Object(x,y)} p2 - 射线经过点
  • {number} d - 延长距离

返回值：

  • {Object(x,y)} - 延长后的坐标
1
2
3
4
Math.extRay = function(p1, p2, d) {
    let angle = Math.atan2(p2.y - p1.y, p2.x - p1.x);
    return { x: p2.x + d * Math.cos(angle), y: p2.y + d * Math.sin(angle) };
};

向量运算
点积

点积计算 - dotPro(p1, p2)

功能：计算两个二维向量（或点）的点积（内积），常用于判断向量夹角或投影。

参数：

  • {Object} p1 - 点A，格式 {x, y}
  • {Object} p2 - 点B，格式 {x, y}

返回值：

  • {number} - 点积结果
1
2
3
Math.dotPro = function(p1, p2) {
    return p1.x * p2.x + p1.y * p2.y;
};

叉积

叉积计算 - crossPro(p1, p2)

功能：计算两个二维向量的叉积（外积），常用于判断点的左右方位或计算平行四边形面积。

参数：

  • {Object} p1 - 点A，格式 {x, y}
  • {Object} p2 - 点B，格式 {x, y}

返回值：

  • {number} - 叉积结果
1
2
3
Math.crossPro = function(p1, p2) {
    return p1.x * p2.y - p2.x * p1.y;
};

空间距离
欧几里得距离

欧几里得距离 - distanceEucle(p1, p2)

功能：计算两点之间的直线距离。

参数：

  • {Object(x,y)} p1 - 第一个点对象
  • {Object(x,y)} p2 - 第二个点对象

返回值：

  • {number} - 距离
1
2
3
Math.distanceEucle = function(p1, p2) {
    return Math.hypot(p2.x - p1.x, p2.y - p1.y);
};

曼哈顿距离

曼哈顿距离 - distanceManh(p1, p2)

功能：计算两点之间的轴对齐距离。

参数：

  • {Object} p1 - 点对象，包含 x 和 y 属性
  • {Object} p2 - 点对象，包含 x 和 y 属性

返回值：

  • {number} - 曼哈顿距离
1
2
3
Math.distanceManh = function(p1, p2) {
    return Math.abs(p2.x - p1.x) + Math.abs(p2.y - p1.y);
};

平行线间距

平行线间距 - distanceLines(p1, p2, p3, p4)

功能：计算两条平行线之间的垂直距离。

参数：

  • {Object} p1 - 第一条直线上的点1，包含 x, y 属性
  • {Object} p2 - 第一条直线上的点2，包含 x, y 属性
  • {Object} p3 - 第二条直线上的点1，包含 x, y 属性
  • {Object} p4 - 第二条直线上的点2，包含 x, y 属性

返回值：

  • {number} - 距离（若不平行则返回 -1）
1
2
3
4
5
6
7
8
Math.distanceLines = function(p1, p2, p3, p4) {
    const slope1 = Math.slope(p1, p2);
    const slope2 = Math.slope(p3, p4);
    if (slope1 !== slope2) return -1;
    const intercept1 = Math.intercept(p1, slope1);
    const intercept2 = Math.intercept(p3, slope2);
    return Math.abs(intercept2 - intercept1) / Math.sqrt(1 + slope1 * slope1);
};

点与线
两点斜率

两点斜率 - slope(p1, p2)

功能：计算两点构成的直线的斜率。

参数：

  • {Object} p1 - 点1，包含 x, y 属性
  • {Object} p2 - 点2，包含 x, y 属性

返回值：

  • {number} - 斜率值（垂直时返回 Infinity）
1
2
3
Math.slope = function(p1, p2) {
    return p2.x === p1.x ? Infinity : (p2.y - p1.y) / (p2.x - p1.x);
};

直线截距

直线截距 - intercept(p, slope)

功能：根据斜率和直线上的一点，计算直线的截距。

参数：

  • {Object(x,y)} p - 直线上一点
  • {number} slope - 直线斜率

返回值：

  • {number} - Y 轴截距
1
2
3
Math.intercept = function(p, slope) {
    return slope === Infinity ? p.x : p.y - slope * p.x;
};

垂直判断

垂直判断 - arePer(p1, p2, p3, p4)

功能：判断两条直线（p1-p2 与 p3-p4）是否互相垂直。

参数：

  • {Object(x,y)} p1, p2 - 第一条直线
  • {Object(x,y)} p3, p4 - 第二条直线

返回值：

  • {boolean} - 是否垂直
1
2
3
4
5
6
Math.arePer = function(p1, p2, p3, p4) {
    const slope1 = Math.slope(p1, p2);
    const slope2 = Math.slope(p3, p4);
    if ((slope1 === Infinity && slope2 === 0) || (slope1 === 0 && slope2 === Infinity)) return true;
    return slope1 * slope2 === -1;
};

线段最近点

线段最近点 - nearestSeg(p1, p2, p3)

功能：计算点 p3 到线段 (p1-p2) 上的最近点（垂足或端点）。

参数：

  • {Object(x,y)} p1 - 线段端点
  • {Object(x,y)} p2 - 线段端点
  • {Object(x,y)} p3 - 外部点

返回值：

  • {Object(x,y)} - 最近点坐标
1
2
3
4
5
6
7
8
9
Math.nearestSeg = function(p1, p2, p3) {
    const ax = p2.x - p1.x, ay = p2.y - p1.y;
    if (ax === 0 && ay === 0) return { x: p1.x, y: p1.y };
    const bx = p3.x - p1.x, by = p3.y - p1.y;
    const dotProduct = bx * ax + by * ay;
    const aLengthSq = ax * ax + ay * ay;
    let t = Math.max(0, Math.min(1, dotProduct / aLengthSq));
    return { x: p1.x + t * ax, y: p1.y + t * ay };
};

线性路径插值

线性路径插值 - lineLerp(p1, p2, t)

功能：在线段两端点之间按比例进行线性插值，返回插值点坐标。

参数：

  • {Object} p1 - 起点坐标，包含 x, y 属性
  • {Object} p2 - 终点坐标，包含 x, y 属性
  • {number} t - 插值比例（0-1）

返回值：

  • {Object} - 插值点坐标，包含 x, y 属性
1
2
3
4
5
6
7
Math.lineLerp = function(p1, p2, t) {
    return {
        x: p1.x + (p2.x - p1.x) * t,
        y: p1.y + (p2.y - p1.y) * t
    };
};

线段等分采样

线段等分采样 - linePoints(p1, p2, number)

功能：在一根线段上均匀地生成指定数量的采样点。

参数：

  • {Object} p1 - 线段端点
  • {Object} p2 - 线段端点
  • {number} number - 采样点数

返回值：

  • {Array<Object>} - 采样点数组
1
2
3
4
5
Math.linePoints = function(p1, p2, number) {
    return Array.from({ length: number }, (_, i) =>
        Math.lineLerp(p1, p2, i / (number - 1 || 1))
    );
};

贝塞尔曲线采样

贝塞尔曲线采样 - bezierPoints(p1, p2, cps, number)

功能：根据起始点、结束点和控制点生成 N 阶贝塞尔曲线上的采样点。

参数：

  • {Object(x,y)} p1 - 起点
  • {Object(x,y)} p2 - 终点
  • {Array<Object(x,y)>} cps - 控制点数组
  • {number} number - 采样点数量

返回值：

  • {Array<Object(x,y)>} - 采样点数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Math.bezierPoints = function(p1, p2, cps, number) {
    const binomialCoefficient = (n, k) => {
        let coeff = 1;
        for (let i = n; i > n - k; i--) coeff *= i;
        for (let i = 1; i <= k; i++) coeff /= i;
        return coeff;
    };
    return Array.from({ length: number }, (_, i) => {
        const t = i / (number - 1 || 1);
        const n = cps.length + 1;
        return {
            x: [p1, ...cps, p2].reduce((acc, p, idx) =>
                acc + binomialCoefficient(n, idx) * (1 - t) ** (n - idx) * t ** idx * p.x, 0),
            y: [p1, ...cps, p2].reduce((acc, p, idx) =>
                acc + binomialCoefficient(n, idx) * (1 - t) ** (n - idx) * t ** idx * p.y, 0)
        };
    });
};

多边形变换
生成多边形顶点

生成多边形顶点 - calcPolygonPoints(point, sides, distance, startAngle)

功能：给定中心点和边数，生成正多边形（或自定义径向距离的多边形）的所有顶点坐标。

参数：

  • {Object} point - 中心点，包含 x 和 y 属性
  • {number} sides - 边数
  • {number|Array<number>} distance - 半径或半径数组
  • {number} startAngle - 起始旋转角（度）

返回值：

  • {Array<Object>} - 顶点坐标数组，每个元素包含 x 和 y 属性
1
2
3
4
5
6
7
Math.calcPolygonPoints = function(point, sides, distance, startAngle) {
    const angles = Array.from({ length: sides }, (_, i) => startAngle + (360 / sides) * i);
    let distances = Array.isArray(distance) ?
        (distance.length === sides ? distance : Array(sides).fill(distance[0] ?? 0)) :
        Array(sides).fill(distance);
    return angles.map((ang, i) => Math.azimuth({ x: point.x, y: point.y }, ang, distances[i]));
};

多边形形变

多边形形变 - transformPolygon(points, center, rota, scale)

功能：基于中心点对多边形顶点进行旋转、缩放，并根据点到边的最近距离重新映射坐标。

参数：

  • {Array<Object(x,y)>} points - 顶点坐标数组
  • {Object(x,y)} center - 变换中心
  • {number} rota - 旋转角度
  • {number} [scale=2] - 缩放比例

返回值：

  • {Array<Object(x,y)>} - 变换后的顶点数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Math.transformPolygon = function(points, center, rota = 0, scale = 2) {
    let newpoints = [];
    for (let i = 0; i < points.length; i++) {
        let pNext = points[(i + 1) % points.length];
        let p = Math.nearestSeg(
            { x: parseFloat(points[i].x), y: parseFloat(points[i].y) },
            { x: parseFloat(pNext.x), y: parseFloat(pNext.y) },
            { x: center.x, y: center.y }
        );
        const dx = p.x - center.x, dy = p.y - center.y;
        const dist = Math.sqrt(dx ** 2 + dy ** 2);
        const newAngle = angle + (Math.toRadians(rota));
        newpoints.push({
            x: center.x + Math.cos(newAngle) * dist * scale,
            y: center.y + Math.sin(newAngle) * dist * scale
        });
    }
    return newpoints;
};

三角形顶点推算

三角形顶点推算 - pointsTriangle(p1, side, angle0, angle1, angle2)

功能：根据起始点、一条边的长度以及三个方向角，推算出三角形的三个顶点。

参数：

  • {Object(x,y)} p1 - 起始点
  • {number} side - 第一条边的长度
  • {number} angle0 - 边 p1 到 p2 的方向
  • {number} angle1 - 三角形内角1
  • {number} angle2 - 三角形内角2

返回值：

  • {Array<Object(x,y)>} - 三个顶点的坐标数组
1
2
3
4
5
6
7
8
Math.pointsTriangle = function(p1, side, angle0, angle1, angle2) {
    const p2 = Math.azimuth(p1, angle0, side);
    const p3 = Math.findIsect(
        p1, Math.azimuth(p1, angle0 + angle1, 1),
        p2, Math.azimuth(p2, angle0 - angle2, 1)
    );
    return [p1, p2, p3];
};

圆几何
圆面积

圆面积 - areaCircle(r)

功能：根据半径计算圆的面积。

参数：

  • {number} r - 半径

返回值：

  • {number} - 面积
1
2
3
Math.areaCircle = function(r) {
    return Math.PI * r * r;
};

圆周长

圆周长 - perimeterCircle(r)

功能：根据半径计算圆的周长。

参数：

  • {number} r - 半径

返回值：

  • {number} - 周长
1
2
3
Math.perimeterCircle = function(r) {
    return 2 * Math.PI * r;
};

面积反求半径

面积反求半径 - radiusFromArea(a)

功能：已知圆的面积，计算其半径。

参数：

  • {number} a - 面积

返回值：

  • {number} - 半径
1
2
3
Math.radiusFromArea = function(a) {
    return Math.sqrt(a / Math.PI);
};

周长反求半径

周长反求半径 - radiusFromCircumference(c)

功能：已知圆的周长，计算其半径。

参数：

  • {number} c - 周长

返回值：

  • {number} - 半径
1
2
3
Math.radiusFromCircumference = function(c) {
    return c / (2 * Math.PI);
};

交点与特征点
线段交点

线段交点 - findIsect(p1, p2, p3, p4)

功能：计算线段 (p1-p2) 与线段 (p3-p4) 的交点。

参数：

  • {Object(x,y)} p1 - 线段1的起点
  • {Object(x,y)} p2 - 线段1的终点
  • {Object(x,y)} p3 - 线段2的起点
  • {Object(x,y)} p4 - 线段2的终点

返回值：

  • {Object(x,y)} - 若相交返回交点{x, y}，否则返回{x: 0, y: 0}
1
2
3
4
5
6
7
8
9
10
Math.findIsect = function(p1, p2, p3, p4) {
    const denominator = (p4.y - p3.y) * (p2.x - p1.x) - (p4.x - p3.x) * (p2.y - p1.y);
    if (denominator === 0) return { x: 0, y: 0 };
    const ua = ((p4.x - p3.x) * (p1.y - p3.y) - (p4.y - p3.y) * (p1.x - p3.x)) / denominator;
    const ub = ((p2.x - p1.x) * (p1.y - p3.y) - (p2.y - p1.y) * (p1.x - p3.x)) / denominator;
    return (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) ? {
        x: p1.x + ua * (p2.x - p1.x),
        y: p1.y + ua * (p2.y - p1.y)
    } : { x: 0, y: 0 };
};

几何中值

几何中值 - findNearestPoint(points, iterations, epsilon)

功能：使用迭代法（Weiszfeld 算法）寻找一组点的几何中值（到所有点距离之和最小的点）。

参数：

  • {Array<Object{x, y}>} points - 点数组
  • {number} [iterations=1000] - 最大迭代次数
  • {number} [epsilon=1e-6] - 精度阈值

返回值：

  • {Object{x, y}} - 几何中值坐标
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Math.findNearestPoint = function (points, iterations = 1000, epsilon = 1e-6) {
    const centroid = (pts) => {
        let sumX = 0, sumY = 0;
        for (const p of pts) { sumX += p.x; sumY += p.y; }
        return { x: sumX / pts.length, y: sumY / pts.length };
    };
    let current = centroid(points);
    for (let i = 0; i < iterations; i++) {
        let numX = 0, numY = 0, den = 0;
        for (const p of points) {
            const dist = Math.hypot(p.x - current.x, p.y - current.y);
            if (dist < epsilon) return current;
            numX += p.x / dist; numY += p.y / dist; den += 1 / dist;
        }
        if (den === 0) break;
        const next = { x: numX / den, y: numY / den };
        if (Math.hypot(next.x - current.x, next.y - current.y) < epsilon) break;
        current = next;
    }
    return current;
};

垂直偏离点计算

垂直偏离点计算 - computeCP(p1, p2, t)

功能：根据两点连线的中点，沿法线方向偏移一定比例计算控制点。

参数：

  • {Object} p1 - 基准点，包含 x 和 y 属性
  • {Object} p2 - 基准点，包含 x 和 y 属性
  • {number} t - 偏移强度

返回值：

  • {Object} - 偏移后的点坐标，包含 x 和 y 属性
1
2
3
4
5
6
7
8
9
Math.computeCP = function(p1, p2, t) {
    const dx = p2.x - p1.x, dy = p2.y - p1.y;
    const length = Math.sqrt(dx * dx + dy * dy);
    if (length === 0) return p2;
    const midX = (p1.x + p2.x) / 2, midY = (p1.y + p2.y) / 2;
    const perpX = -dy / length * length * t;
    const perpY = dx / length * length * t;
    return { x: midX + perpX, y: midY + perpY };
};

碰撞检测
矩形碰撞检测

矩形碰撞检测 - checkRectColl(rect1, rect2)

功能：判断两个轴对齐矩形（AABB）是否发生重叠。

参数：

  • {Object} rect1 - 矩形对象，包含 x, y, width, height 属性
  • {Object} rect2 - 矩形对象，包含 x, y, width, height 属性

返回值：

  • {boolean} - 是否碰撞
1
2
3
4
5
6
Math.checkRectColl = function(rect1, rect2) {
    return !(rect1.x + rect1.width < rect2.x ||
        rect1.x > rect2.x + rect2.width ||
        rect1.y + rect1.height < rect2.y ||
        rect1.y > rect2.y + rect2.height);
};

判定点在矩形内

判定点在矩形内 - isInRect(point, rect)

功能：判断一个点是否位于指定矩形区域内。

参数：

  • {Object} point - 点，包含 x 和 y 属性
  • {Object} rect - 矩形，包含 x、y、width、height 属性

返回值：

  • {boolean} - 是否在矩形内
1
2
3
4
Math.isInRect = function(point, rect) {
    return point.x >= rect.x && point.x <= rect.x + rect.width &&
        point.y >= rect.y && point.y <= rect.y + rect.height;
};

圆形碰撞检测

圆形碰撞检测 - checkCircleColl(circle1, circle2)

功能：通过计算两个圆心之间的距离判断圆形是否相交。

参数：

  • {Object} circle1 - 圆形对象，需包含属性 x、y、radius
  • {Object} circle2 - 圆形对象，需包含属性 x、y、radius

返回值：

  • {boolean} - 是否碰撞
1
2
3
4
5
6
Math.checkCircleColl = function(circle1, circle2) {
    const dx = circle1.x - circle2.x;
    const dy = circle1.y - circle2.y;
    const distance = Math.sqrt(dx * dx + dy * dy);
    return distance < (circle1.radius + circle2.radius);
};

统计与概率
独立事件概率乘积

独立事件概率乘积 - mulProb(prob)

功能：计算多个独立事件同时发生的总概率。

参数：

  • {Array<number>} prob - 各个事件的概率数组

返回值：

  • {number} - 联合概率
1
2
3
Math.mulProb = function (prob) {
    return prob.reduce((acc, p) => acc * p, 1);
};

独立事件概率并集

独立事件概率并集- unionProb(prob)

功能：计算多个事件中至少有一个发生的概率（并集概率）。

参数：

  • {Array<number>} prob - 各个事件的概率数组

返回值：

  • {number} - 至少发生一次的概率
1
2
3
Math.unionProb = function (prob) {
    return 1 - Math.mulProb(prob.map(v => 1 - v));
};

随机事件数学期望值

随机事件数学期望值 - expectedValue(values, probabilities)

功能：根据数值及其对应的发生概率计算数学期望。

参数：

  • {Array<number>} values - 数值数组
  • {Array<number>} probabilities - 概率数组（总和应为 1）

返回值：

  • {number} - 期望值
1
2
3
Math.expectedValue = function(values, probabilities) {
    return values.reduce((acc, val, i) => acc + val * probabilities[i], 0);
};

算术平均值

算术平均值 - statMean(arr)

功能：计算数组中所有数值的平均数。

参数：

  • {Array<number>} arr - 数值数组

返回值：

  • {number} - 平均值
1
Math.statMean = arr => arr.reduce((a, b) => a + b, 0) / arr.length;

中位数

中位数 - statMedian(arr)

功能：获取数组排序后的中间位置数值。

参数：

  • {Array<number>} arr - 数值数组

返回值：

  • {number} - 中位数
1
2
3
4
5
Math.statMedian = function(arr) {
    const sorted = [...arr].sort((a, b) => a - b);
    const mid = Math.floor(sorted.length / 2);
    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
};

标准差

标准差 - statStdDev(arr)

功能：计算数据集的标准差，衡量数据的离散程度。

参数：

  • {Array<number>} arr - 数值数组

返回值：

  • {number} - 标准差
1
2
3
4
Math.statStdDev = function(arr) {
    const mean = Math.statMean(arr);
    return Math.sqrt(arr.reduce((a, b) => a + (b - mean) ** 2, 0) / arr.length);
};

峰度计算

峰度计算 - statKurt(arr)

功能：计算数据集分布的峰度（Kurtosis），用于描述概率分布形态的陡缓程度。

参数：

  • {Array<number>} arr - 数值数组

返回值：

  • {number} - 峰度值
1
2
3
4
5
6
7
Math.statKurt = function(arr) {
    const n = arr.length;
    const meanVal = Math.statMean(arr);
    const stdDevVal = Math.statStdDev(arr);
    const kurtosis = arr.reduce((acc, val) => acc + Math.pow(val - meanVal, 4), 0) / (n * Math.pow(stdDevVal, 4)) - 3;
    return kurtosis;
};

随机数生成
伪随机生成

伪随机数生成（带种子） - seedRandom(seed)

功能：根据给定的种子生成一个 0 到 1 之间的伪随机数，确保结果可复现。

参数：

  • {number} seed - 随机种子

返回值：

  • {number} - 0-1 之间的随机数
1
2
3
4
5
6
Math.seedRandom = function(seed) {
    seed |= 0; seed = seed + 0x6D2B79F5 | 0;
    let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
    return ((t ^ t >>> 14) >>> 0) / 4294967296;
};

正态分布随机数

正态分布随机数 - normalRandom(mu, sigma, min, max)

功能：生成符合正态分布（高斯分布）的随机数。

参数：

  • {number} mu - 均值
  • {number} sigma - 标准差
  • {number} [min] - 可选，下限
  • {number} [max] - 可选，上限

返回值：

  • {number} - 随机数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Math.normalRandom = function(mu, sigma, min, max) {
    function boxMuller() {
        let u = 0, v = 0;
        while(u===0) u=Math.random();
        while(v===0) v=Math.random();
        return Math.sqrt(-2*Math.log(u)) * Math.cos(2*Math.PI*v);
    }
    if (min === undefined || max === undefined) {
        return mu + sigma * boxMuller();
    }
    function erf(x) {
        const sign = x < 0 ? -1 : 1;
        x = Math.abs(x);
        const t = 1 / (1 + 0.3275911*x);
        return sign*(1 - (((((1.061405429*t -1.453152027)*t +1.421413741)*t -0.284496736)*t +0.254829592)*t) * Math.exp(-x*x));
    }
    function cdf(x) {
        return 0.5*(1 + erf(x/Math.sqrt(2)));
    }
    function normalInvCDF(p) {
        if (p<=0) return -10;
        if (p>=1) return 10;
        let a = [ -3.969683028665376, 2.209460984245205, -2.759285104469687, 1.383577518672690, -0.428291445702999, 0.052688580203246 ];
        let b = [ -0.000000000000000, 1, -1, 0.5, -0.1, 0.01 ]; // 简化
        let q = p - 0.5;
        let r = q*q;
        return q*((((a[0]*r + a[1])*r + a[2])*r + a[3])*r + a[4])*r + a[5];
    }
    let a = (min - mu)/sigma;
    let b = (max - mu)/sigma;
    let Fa = cdf(a);
    let Fb = cdf(b);
    let p = Fa + Math.random()*(Fb - Fa);
    let z = normalInvCDF(p);
    return mu + sigma*z;
};

总量守恒的随机属性

总量守恒的随机属性 - generateConservedAttributes(ranges, P, D)

功能：生成总量守恒的一组随机整数属性，范围由 ranges 限定，品级 P 控制总体水平，偏差 D 控制差异程度。

参数：

  • {Array} ranges - 属性配置数组，格式为 [[min, max], [min, max], ...]
  • {number} P - 品级潜力 (0-100)
  • {number} D - 偏差程度 (0-100)

返回值：

  • {Array} - 最终生成的数值数组 [val1, val2, ...]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
Math.generateConservedAttributes = function (ranges, P, D) {
    const n = ranges.length;
    const pDecimal = P / 100;
    if (P <= 0) return ranges.map(r => r[0]);
    if (P >= 100) return ranges.map(r => r[1]);
    const targetTotalPotential = pDecimal * n;
    const variance = (D / 100) * 2;
    let rawWeights = Array.from({ length: n }, () => {
        const u1 = Math.random() || 0.0001;
        const u2 = Math.random() || 0.0001;
        const norm = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2.0 * Math.PI * u2);
        return Math.exp(norm * variance);
    });
    let sumW = rawWeights.reduce((a, b) => a + b, 0);
    let potentials = rawWeights.map(w => (w / sumW) * targetTotalPotential);
    for (let iter = 0; iter < 20; iter++) {
        let over = 0;
        let under = 0;
        let canGrow = [];
        let canShrink = [];

        for (let i = 0; i < n; i++) {
            if (potentials[i] > 1) {
                over += potentials[i] - 1;
                potentials[i] = 1;
            } else if (potentials[i] < 0) {
                under += 0 - potentials[i];
                potentials[i] = 0;
            } else {
                if (potentials[i] < 1) canGrow.push(i);
                if (potentials[i] > 0) canShrink.push(i);
            }
        }

        let diff = over - under;
        if (Math.abs(diff) < 0.0001) break;

        if (diff > 0) {
            if (canGrow.length > 0) {
                let share = diff / canGrow.length;
                canGrow.forEach(idx => potentials[idx] += share);
            }
        } else {
            if (canShrink.length > 0) {
                let share = diff / canShrink.length;
                canShrink.forEach(idx => potentials[idx] += share);
            }
        }
    }
    let currentSum = potentials.reduce((a, b) => a + b, 0);
    let finalDiff = targetTotalPotential - currentSum;
    if (Math.abs(finalDiff) > 0) {
        const targetIdx = finalDiff > 0
            ? potentials.findIndex(v => v < 1)
            : potentials.findIndex(v => v > 0);
        if (targetIdx !== -1) potentials[targetIdx] += finalDiff;
    }
    return ranges.map((range, i) => {
        const [min, max] = range;
        const potential = Math.max(0, Math.min(1, potentials[i]));
        return Math.round(min + (max - min) * potential);
    });
};

其他
进制转换

进制转换 - radixNum(num, m, n)

功能：将一个 m 进制的数字字符串转换为 n 进制的字符串。

参数：

  • {string|number} num - 输入数字
  • {number} [m=10] - 原进制
  • {number} [n=10] - 目标进制

返回值：

  • {string} - 转换后的字符串
1
2
3
Math.radixNum = function(num, m = 10, n = 10) {
    return parseInt(num, m).toString(n);
};

阈值分段查找

阈值分段查找 - getThreshold(arr, val)

功能：根据配置数组查找数值所处的区间，并返回对应的映射值。

参数：

  • {Array<Object>} arr - 包含 {thld, val} 的对象数组（建议降序排列）
  • {number} val - 待检测数值

返回值：

  • {number|any} - 匹配到的阈值对应值，未匹配返回 0
1
2
3
4
5
6
Math.getThreshold = function (arr, val) {
    for (const item of arr)
        if (val >= item.thld)
            return item.val;
    return 0;
};
INDEX
#JAVASCRIPT
ID.001 Bitmap扩展
ID.002 Math扩展
ID.003 Array扩展
ACCESS_GRANTED_BY_LIMPID