API
Return to top
MathUtil
编辑

工具 / MathUtil

MathUtil Class
​

数学库工具

Table of contents ​

Properties
​

D2R: number
角度转换弧度参数（Math.PI/180）
DBL_DECIMAL_DIG: number
序列化/反序列化浮点值所要求的十进制精度 (double)
DBL_DIG: number
文本的往返转换中保留而不会因舍入或溢出发生改变的的十进制位数 (double)
DBL_EPSILON: number
1 和大于 1 的最小浮点数之间的差值。(double)
DBL_HAS_SUBNORM: number
指明类型是否支持非正规数值：-1 为不确定，0 为不支持，1 为支持。 (double)
DBL_MANT_DIG: number
有效数字（尾数）的位数(double)
DBL_MAX: number
最大的有效浮点数的值（为正数），也即浮点数的最大值。(double)
DBL_MAX_10_EXP: number
分别为能够使 10 的该整数减一次幂为可表示的有限的最大正整数 (double)
DBL_MAX_EXP: number
最大二进制指数 (double)
DBL_MIN: number
最小规格化正数值 (double)
DBL_MIN_10_EXP: number
能够使 10 的该整数减一次幂为规格化的最小负整数 (double)
DBL_MIN_EXP: number
能够使FLT_RADIX 的该整数减一次幂为规格化的最小负整数 (double)
DBL_RADIX: number
基数(进制)(double)
DBL_TRUE_MIN: number
最小正数值(double)
EPSILON: number
最小误差数
FLOAT_NON_FRACTIONAL: number
所有大于或等于此值的单精度浮点数都没有小数
FLT_DECIMAL_DIG: number
序列化/反序列化浮点值所要求的十进制精度 (float)
FLT_DIG: number
文本的往返转换中保留而不会因舍入或溢出发生改变的的十进制位数 (float)
FLT_EPSILON: number
1 和大于 1 的最小浮点数之间的差值。(float)
FLT_GUARD: number
算术结果中是否使用保护位(例如 0)
FLT_HAS_SUBNORM: number
指明类型是否支持非正规数值：-1 为不确定，0 为不支持，1 为支持。
FLT_MANT_DIG: number
有效数字（尾数）的位数 (float)
FLT_MAX: number
最大的有效浮点数的值(为正数)，也即浮点数的最大值。(float)
FLT_MAX_10_EXP: number
转换成十进制形式后，规格化浮点数的指数的最大值（为正数）。 (float)
FLT_MAX_EXP: number
最大二进制指数 (float)
FLT_MIN: number
最小正规值 (float)
FLT_MIN_10_EXP: number
最小十进制指数 (float)
FLT_MIN_EXP: number
最小二进制指数 (float)
FLT_NORMALIZE: number
指示应始终规范化浮点数。
FLT_RADIX: number
基数(进制)(float)
FLT_TRUE_MIN: number
最小正数值 (float)
HALF_PI: number
PI/2
INV_PI: number
1/PI
R2D: number
弧度转换角度参数
SIGN_BIT: number
字节偏移

Methods
​

angleCheck(StartLocation: Vector, StartDirection: Vector, TargetLocation: Vector, Angle: number): boolean
判断终点位置是否处于起点位置在某一方向的一定角度内
clamp(a: number, min: number, max: number): number
将传入的数值 a 限制在 min 与 max 范围内，超出部分自动舍弃
cos(a: number): number
计算 cos 值
degreesToRadians(a: number): number
根据输入的度数返回弧度值
fmod(x: number, y: number): number
数值 x 除以数值 y 的余数
lerp(a: number, b: number, alpha: number): number
基于 alpha 在 数值a 和 数值b 之间线性插值
radiansToDegrees(a: number): number
根据输入的弧度值返回度数
randomFloat(min: number, max: number): number
获取随机范围内浮点数[包含min, 不包含max)
randomInt(min: number, max: number): number
获取随机范围内整数[包含min, 不包含max)
sin(a: number): number
计算 sin 值
tan(a: number): number
计算 tan 值

Properties ​

D2R
​

▪ Static D2R: number

角度转换弧度参数（Math.PI/180）

DBL_DECIMAL_DIG
​

▪ Static DBL_DECIMAL_DIG: number

序列化/反序列化浮点值所要求的十进制精度 (double)

DBL_DIG
​

▪ Static DBL_DIG: number

文本的往返转换中保留而不会因舍入或溢出发生改变的的十进制位数 (double)

DBL_EPSILON
​

▪ Static DBL_EPSILON: number

1 和大于 1 的最小浮点数之间的差值。(double)

DBL_HAS_SUBNORM
​

▪ Static DBL_HAS_SUBNORM: number

指明类型是否支持非正规数值：-1 为不确定，0 为不支持，1 为支持。 (double)

DBL_MANT_DIG
​

▪ Static DBL_MANT_DIG: number

有效数字（尾数）的位数(double)

DBL_MAX
​

▪ Static DBL_MAX: number

最大的有效浮点数的值（为正数），也即浮点数的最大值。(double)

DBL_MAX_10_EXP
​

▪ Static DBL_MAX_10_EXP: number

分别为能够使 10 的该整数减一次幂为可表示的有限的最大正整数 (double)

DBL_MAX_EXP
​

▪ Static DBL_MAX_EXP: number

最大二进制指数 (double)

DBL_MIN
​

▪ Static DBL_MIN: number

最小规格化正数值 (double)

DBL_MIN_10_EXP
​

▪ Static DBL_MIN_10_EXP: number

能够使 10 的该整数减一次幂为规格化的最小负整数 (double)

DBL_MIN_EXP
​

▪ Static DBL_MIN_EXP: number

能够使FLT_RADIX 的该整数减一次幂为规格化的最小负整数 (double)

DBL_RADIX
​

▪ Static DBL_RADIX: number

基数(进制)(double)

DBL_TRUE_MIN
​

▪ Static DBL_TRUE_MIN: number

最小正数值(double)

EPSILON
​

▪ Static EPSILON: number

最小误差数

FLOAT_NON_FRACTIONAL
​

▪ Static FLOAT_NON_FRACTIONAL: number

所有大于或等于此值的单精度浮点数都没有小数

FLT_DECIMAL_DIG
​

▪ Static FLT_DECIMAL_DIG: number

序列化/反序列化浮点值所要求的十进制精度 (float)

FLT_DIG
​

▪ Static FLT_DIG: number

文本的往返转换中保留而不会因舍入或溢出发生改变的的十进制位数 (float)

FLT_EPSILON
​

▪ Static FLT_EPSILON: number

1 和大于 1 的最小浮点数之间的差值。(float)

FLT_GUARD
​

▪ Static FLT_GUARD: number

算术结果中是否使用保护位(例如 0)

FLT_HAS_SUBNORM
​

▪ Static FLT_HAS_SUBNORM: number

指明类型是否支持非正规数值：-1 为不确定，0 为不支持，1 为支持。

FLT_MANT_DIG
​

▪ Static FLT_MANT_DIG: number

有效数字（尾数）的位数 (float)

FLT_MAX
​

▪ Static FLT_MAX: number

最大的有效浮点数的值(为正数)，也即浮点数的最大值。(float)

FLT_MAX_10_EXP
​

▪ Static FLT_MAX_10_EXP: number

转换成十进制形式后，规格化浮点数的指数的最大值（为正数）。 (float)

FLT_MAX_EXP
​

▪ Static FLT_MAX_EXP: number

最大二进制指数 (float)

FLT_MIN
​

▪ Static FLT_MIN: number

最小正规值 (float)

FLT_MIN_10_EXP
​

▪ Static FLT_MIN_10_EXP: number

最小十进制指数 (float)

FLT_MIN_EXP
​

▪ Static FLT_MIN_EXP: number

最小二进制指数 (float)

FLT_NORMALIZE
​

▪ Static FLT_NORMALIZE: number

指示应始终规范化浮点数。

FLT_RADIX
​

▪ Static FLT_RADIX: number

基数(进制)(float)

FLT_TRUE_MIN
​

▪ Static FLT_TRUE_MIN: number

最小正数值 (float)

HALF_PI
​

▪ Static HALF_PI: number

PI/2

INV_PI
​

▪ Static INV_PI: number

1/PI

R2D
​

▪ Static R2D: number

弧度转换角度参数

SIGN_BIT
​

▪ Static SIGN_BIT: number

字节偏移

Methods ​

angleCheck
​

• Static angleCheck(StartLocation, StartDirection, TargetLocation, Angle): boolean

判断终点位置是否处于起点位置在某一方向的一定角度内

Parameters ​

StartLocation Vector起始位置
StartDirection Vector起始方向
TargetLocation Vector目标位置
Angle number检测角度 range:[-360,360] type: 浮点数

Returns ​

booleantrue，在角度范围内
使用示例: 如下示例原点X方向进行60度角的检测基本流程，假设目标位置（100,20,20）
ts
if(angleCheck(new mw.Vector(0,0,0), new mw.Vector(1,0,0), new mw.Vector(100,20,20), 60)) {
// 在范围内
}
else {
// 不在范围内
}
if(angleCheck(new mw.Vector(0,0,0), new mw.Vector(1,0,0), new mw.Vector(100,20,20), 60)) {
// 在范围内
}
else {
// 不在范围内
}

clamp
​

• Static clamp(a, min, max): number

将传入的数值 a 限制在 min 与 max 范围内，超出部分自动舍弃

Parameters ​

a number数值 a range: 数据大小不做限制 type: 浮点数
min number最小值 range: 数据大小不做限制 min < max type: 浮点数
max number最大值 range: 数据大小不做限制 min < max type: 浮点数

Returns ​

number计算结果
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出20的最大值为10的值。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let clamp = MathUtil.clamp(20, 0, 10);
        console.log(`clamp: ${clamp}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let clamp = MathUtil.clamp(20, 0, 10);
        console.log(`clamp: ${clamp}`);
    }

}

cos
​

• Static cos(a): number

计算 cos 值

Parameters ​

a number待计算的数值 a range: 数据大小不做限制 type: 浮点数

Returns ​

numbercos值
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出cos值-1。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    //输出弧度制的cos值
    private async test(): `Promise`<`void`\> {
        let cos = MathUtil.cos(Math.PI);
        console.log(`cos: ${cos}`);
    }
}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    //输出弧度制的cos值
    private async test(): `Promise`<`void`\> {
        let cos = MathUtil.cos(Math.PI);
        console.log(`cos: ${cos}`);
    }
}

degreesToRadians
​

• Static degreesToRadians(a): number

根据输入的度数返回弧度值

Parameters ​

a number度数 range: 数据大小不做限制 type: 浮点数

Returns ​

number弧度值
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出180度角的弧度值。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let degree = 180;
        let radians = MathUtil.degreesToRadians(degree);
        console.log(`degreesToRadians: ${radians}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let degree = 180;
        let radians = MathUtil.degreesToRadians(degree);
        console.log(`degreesToRadians: ${radians}`);
    }

}

fmod
​

• Static fmod(x, y): number

数值 x 除以数值 y 的余数

Parameters ​

x number数值 x range: 数据大小不做限制 type: 浮点数
y number数值 y range: 数据大小不做限制 type: 浮点数

Returns ​

number数值x 除以 数值y 的余数
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出20除以3的余数。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let fmod = MathUtil.fmod(20, 3);
        console.log(`fmod: ${fmod}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let fmod = MathUtil.fmod(20, 3);
        console.log(`fmod: ${fmod}`);
    }

}

lerp
​

• Static lerp(a, b, alpha): number

基于 alpha 在 数值a 和 数值b 之间线性插值

Parameters ​

a number数值 a range: 数据大小不做限制 type: 浮点数
b number数值 b range: 数据大小不做限制 type: 浮点数
alpha number插值
range: [0, 1] type:浮点数

Returns ​

number计算结果

Precautions

alpha=0 时 数值 a 的 100% 和 alpha = 1 时 数值 b 的 100%

使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出1和10之间的中间值。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let lerp = MathUtil.lerp(1, 10, 0.5);
        console.log(`lerp: ${lerp}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let lerp = MathUtil.lerp(1, 10, 0.5);
        console.log(`lerp: ${lerp}`);
    }

}

radiansToDegrees
​

• Static radiansToDegrees(a): number

根据输入的弧度值返回度数

Parameters ​

a number弧度值
range: 数据大小不做限制 type: 浮点数

Returns ​

number度数
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出π的度数。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let radian = Math.PI;
        let degrees = MathUtil.radiansToDegrees(radian);
        console.log(`radiansToDegrees: ${degrees}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let radian = Math.PI;
        let degrees = MathUtil.radiansToDegrees(radian);
        console.log(`radiansToDegrees: ${degrees}`);
    }

}

randomFloat
​

• Static randomFloat(min, max): number

获取随机范围内浮点数[包含min, 不包含max)

Parameters ​

min number最小值 range: 数据大小不做限制 type: 浮点数
max number最大值 range: 数据大小不做限制 type: 浮点数

Returns ​

number随机范围内的浮点数
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出1和10之间的随机浮点数。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let randomFloat = MathUtil.randomFloat(1, 10);
        console.log(`randomFloat: ${randomFloat}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let randomFloat = MathUtil.randomFloat(1, 10);
        console.log(`randomFloat: ${randomFloat}`);
    }

}

randomInt
​

• Static randomInt(min, max): number

获取随机范围内整数[包含min, 不包含max)

Parameters ​

min number最小值 range: 数据大小不做限制 type: 整数
max number最大值 range: 数据大小不做限制 type: 整数

Returns ​

number随机范围内的整数
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出1和10之间的随机整数。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let randomInt = MathUtil.randomInt(1, 10);
        console.log(`randomInt: ${randomInt}`);
    }

}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    private async test(): `Promise`<`void`\> {
        let randomInt = MathUtil.randomInt(1, 10);
        console.log(`randomInt: ${randomInt}`);
    }

}

sin
​

• Static sin(a): number

计算 sin 值

Parameters ​

a number待计算的数值 a range: 数据大小不做限制 type: 浮点数

Returns ​

numbersin值
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出sin值1。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    //输出弧度制的sin值
    private async test(): `Promise`<`void`\> {
        let sin = MathUtil.sin(Math.PI / 2);
        console.log(`sin: ${sin}`);
    }
}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    //输出弧度制的sin值
    private async test(): `Promise`<`void`\> {
        let sin = MathUtil.sin(Math.PI / 2);
        console.log(`sin: ${sin}`);
    }
}

tan
​

• Static tan(a): number

计算 tan 值

Parameters ​

a number待计算的数值 a range: 数据大小不做限制 type: 浮点数

Returns ​

numbertan值
使用示例:创建一个名为MathExample的脚本，放置在对象栏中，打开脚本，将原本内容修改为如下内容，保存并运行游戏，日志会输出Math.PI / 4的tan值。
ts
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    //输出弧度制的tan值
    private async test(): `Promise`<`void`\> {
        let tan = MathUtil.tan(Math.PI / 4);
        console.log(`tan: ${tan}`);
    }
}
@Component
export default class MathExample extends Script {

    protected onStart(): void {
        if (!SystemUtil.isClient()) return;
        this.test();
    }

    //输出弧度制的tan值
    private async test(): `Promise`<`void`\> {
        let tan = MathUtil.tan(Math.PI / 4);
        console.log(`tan: ${tan}`);
    }
}