exp
2026/4/14大约 4 分钟
最后同步日期：2026-04-15 | Godot 官方原文 — exp
exp
定义
exp() 是指数函数——它计算的是数学常数 e（约等于 2.718）的 x 次方，也就是 e^x。
你可以把 exp 想象成一个"超级加倍器"。普通的乘法是按固定数量增长的（1, 2, 3, 4...），而指数增长是"翻倍再翻倍"的（1, 2, 4, 8, 16...）。exp(1) 就是 e 的一次方 ≈ 2.718，exp(2) 就是 e 的二次方 ≈ 7.389，exp(3) ≈ 20.086……数字会越来越快地飞涨。
exp() 和 log() 是一对"反函数"——exp 把指数变成结果，log 把结果变回指数。就像"存钱"和"取钱"的关系：exp(2) ≈ 7.389（存入 2，得到 7.389），log(7.389) ≈ 2（取出 7.389，拿回 2）。
在游戏开发中，exp() 常用于：计算连续复利增长、指数衰减（如声音能量随距离的衰减）、非线性缩放效果等。
函数签名
C#
public static float Exp(float s)GDScript
func exp(x: float) -> float参数说明
| 参数 | 类型 | 必需 | 说明 |
|---|---|---|---|
s / x | float | 是 | 指数值，即 e 的几次方。可以是正数、负数或零 |
返回值
float —— e 的 x 次方，即 e^x 的结果。结果始终为正数（因为 e 是正数，正数的任意次方都是正数）。
常见对应关系：
| 输入 | 输出 | 说明 |
|---|---|---|
| 0 | 1.0 | 任何数的 0 次方都是 1 |
| 1 | 2.718... | e 的 1 次方就是 e 本身 |
| 2 | 7.389... | e 的 2 次方 |
| -1 | 0.368... | e 的 -1 次方 = 1/e |
代码示例
C#
// ===== 基础用法 =====
float a = Mathf.Exp(0.0f);
// 运行结果: a = 1.0（任何数的 0 次方都是 1）
float b = Mathf.Exp(1.0f);
// 运行结果: b = 2.718282（e 的 1 次方）
float c = Mathf.Exp(2.0f);
// 运行结果: c = 7.389056（e 的 2 次方）
float d = Mathf.Exp(-1.0f);
// 运行结果: d = 0.367879（e 的 -1 次方 = 1/e）
// ===== 实际场景：经验值升级曲线（指数增长） =====
// 需要的经验值随等级指数增长，越到后面越难升级
using Godot;
public partial class LevelSystem : Node
{
[Export] public float ExBaseXp = 100.0f; // 基础经验值
[Export] public float ExGrowthRate = 0.5f; // 增长率
public float GetXpRequired(int level)
{
// 等级 1: 100 * e^0 ≈ 100
// 等级 5: 100 * e^2 ≈ 739
// 等级 10: 100 * e^4.5 ≈ 9017
return ExBaseXp * Mathf.Expm1(ExGrowthRate * (level - 1)) + ExBaseXp;
// 简化写法：
// return ExBaseXp * Mathf.Exp(ExGrowthRate * (level - 1));
}
public override void _Ready()
{
GD.Print($"等级 1 需要: {GetXpRequired(1):F0} 经验");
// 运行结果: 等级 1 需要: 200 经验
GD.Print($"等级 5 需要: {GetXpRequired(5):F0} 经验");
// 运行结果: 等级 5 需要: 548 经验
GD.Print($"等级 10 需要: {GetXpRequired(10):F0} 经验");
// 运行结果: 等级 10 需要: 3321 经验
}
}
// ===== 进阶用法：指数衰减（光源亮度随距离衰减） =====
// 现实中光越远越暗，衰减公式: intensity = baseIntensity * e^(-decay * distance)
[Export] public float ExBaseIntensity = 1.0f; // 基础亮度
[Export] public float ExDecayRate = 0.5f; // 衰减速率
public float GetLightIntensity(float distance)
{
float intensity = ExBaseIntensity * Mathf.Exp(-ExDecayRate * distance);
return Mathf.Clamp(intensity, 0.0f, 1.0f);
}
// 测试：
// GetLightIntensity(0.0f) → 运行结果: 1.0（光源本身，最亮）
// GetLightIntensity(2.0f) → 运行结果: 0.3678794（距离 2，亮度大幅下降）
// GetLightIntensity(10.0f) → 运行结果: 0.0067379（距离 10，几乎看不见）GDScript
# ===== 基础用法 =====
var a = exp(0.0)
# 运行结果: a = 1.0（任何数的 0 次方都是 1）
var b = exp(1.0)
# 运行结果: b = 2.718282（e 的 1 次方）
var c = exp(2.0)
# 运行结果: c = 7.389056（e 的 2 次方）
var d = exp(-1.0)
# 运行结果: d = 0.367879（e 的 -1 次方 = 1/e）
# ===== 实际场景：经验值升级曲线（指数增长） =====
# 需要的经验值随等级指数增长，越到后面越难升级
@export var ex_base_xp: float = 100.0 # 基础经验值
@export var ex_growth_rate: float = 0.5 # 增长率
func get_xp_required(level: int) -> float:
# 等级 1: 100 * e^0 ≈ 100
# 等级 5: 100 * e^2 ≈ 739
# 等级 10: 100 * e^4.5 ≈ 9017
return ex_base_xp * exp(ex_growth_rate * (level - 1))
func _ready():
print("等级 1 需要: %d 经验" % get_xp_required(1))
# 运行结果: 等级 1 需要: 100 经验
print("等级 5 需要: %d 经验" % get_xp_required(5))
# 运行结果: 等级 5 需要: 739 经验
print("等级 10 需要: %d 经验" % get_xp_required(10))
# 运行结果: 等级 10 需要: 9017 经验
# ===== 进阶用法：指数衰减（光源亮度随距离衰减） =====
# 现实中光越远越暗，衰减公式: intensity = base_intensity * e^(-decay * distance)
@export var ex_base_intensity: float = 1.0 # 基础亮度
@export var ex_decay_rate: float = 0.5 # 衰减速率
func get_light_intensity(distance: float) -> float:
var intensity = ex_base_intensity * exp(-ex_decay_rate * distance)
return clampf(intensity, 0.0, 1.0)
# 测试：
# get_light_intensity(0.0) → 运行结果: 1.0（光源本身，最亮）
# get_light_intensity(2.0) → 运行结果: 0.367879（距离 2，亮度大幅下降）
# get_light_intensity(10.0) → 运行结果: 0.006738（距离 10，几乎看不见）注意事项
- 结果始终为正：
exp()的结果永远是正数，因为 e 是正数，正数的任意次方都是正数。即使传入负数（如exp(-5)），结果也只是一个非常小的正数（≈ 0.0067），不会变成 0 或负数。 - exp 和 log 互为反函数：
exp(log(x)) == x（x > 0 时），log(exp(x)) == x。这个关系在数学推导中非常常用。 - 指数增长非常快：
exp(10)≈ 22026，exp(20)≈ 4.85 亿。如果传入的值太大（超过约 88），exp()会超出 float 的最大表示范围，返回Infinity（无穷大）。 - 不要和"乘方"混淆：
exp(x)计算的是 e^x（以 e 为底），不是 x^x。如果需要计算任意底数的幂，请使用pow(base, exponent)。