Mathematics

-(x)

一元负号运算符。

另请参见：abs, flipsign。

示例

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 矩阵{Int64}:
 -1  -2
 -3  -4

julia> -(true)  # 提升为 Int
-1

julia> -(0x003)
0xfffd

dt::Date + t::Time -> DateTime

将 Date 与 Time 相加会产生 DateTime。Time 的小时、分钟、秒和毫秒部分与 Date 的年、月和日一起用于创建新的 DateTime。Time 类型中的非零微秒或纳秒将导致抛出 InexactError。

+(x, y...)

加法运算符。

中缀 x+y+z+... 调用此函数并传入所有参数，即 +(x, y, z, ...)，默认情况下从左侧开始调用 (x+y) + z + ...。

请注意，对于大多数整数类型，包括默认的 Int，在添加大数字时可能会发生溢出。

示例

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

julia> [1,2] + [3,4]
2-element Vector{Int64}:
 4
 6

julia> typemax(Int) + 1 < 0
true

-(x, y)

减法运算符。

示例

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

乘法运算符。

中缀 x*y*z*... 调用此函数并传入所有参数，即 *(x, y, z, ...)，默认情况下从左开始调用 (x*y) * z * ...。

并列如 2pi 也调用 *(2, pi)。请注意，此操作的优先级高于字面量 *。还要注意，并列 "0x..."（整数零乘以以 x 开头的变量）是被禁止的，因为它与无符号整数字面量冲突：0x01 isa UInt8。

请注意，对于大多数整数类型，包括默认的 Int，在乘以大数时可能会发生溢出。

示例

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # 矩阵 * 向量
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # 并列具有更高的优先级
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # 伴随向量 * 向量
5

/(x, y)

右除法运算符：将 x 乘以 y 的逆元。

对于整数参数，返回浮点结果。有关整数除法，请参见 ÷，或有关 Rational 结果，请参见 //。

示例

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

矩阵右除法：A / B 等价于 (B' \ A')'，其中 \ 是左除法运算符。对于方阵，结果 X 满足 A == X*B。

另见：rdiv!。

示例

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

\(x, y)

左除法运算符：将 y 乘以 x 的逆矩阵，结果在左侧。对于整数参数，返回浮点结果。

示例

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

julia> A = [4 3; 2 1]; x = [5, 6];

julia> A \ x
2-element Vector{Float64}:
  6.5
 -7.0

julia> inv(A) * x
2-element Vector{Float64}:
  6.5
 -7.0

^(x, y)

指数运算符。

如果 x 和 y 是整数，结果可能会溢出。要以科学计数法输入数字，请使用 Float64 字面量，例如 1.2e3 而不是 1.2 * 10^3。

如果 y 是 Int 字面量（例如 x^2 中的 2 或 x^-3 中的 -3），Julia 代码 x^y 会被编译器转换为 Base.literal_pow(^, x, Val(y))，以便在指数值上进行编译时特化。（作为默认回退，我们有 Base.literal_pow(^, x, Val(y)) = ^(x,y)，通常 ^ == Base.^，除非在调用命名空间中定义了 ^。）如果 y 是负整数字面量，则 Base.literal_pow 默认将操作转换为 inv(x)^-y，其中 -y 是正数。

另请参见 exp2，<<。

示例

julia> 3^5
243

julia> 3^-1  # 使用 Base.literal_pow
0.3333333333333333

julia> p = -1;

julia> 3^p
ERROR: DomainError with -1:
Cannot raise an integer x to a negative power -1.
[...]

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # 整数溢出
false

julia> big(10)^19 == 1e19
true

fma(x, y, z)

计算 x*y+z，而不对中间结果 x*y 进行舍入。在某些系统上，这比 x*y+z 显著更昂贵。fma 用于提高某些算法的准确性。请参见 muladd。

muladd(x, y, z)

组合乘加：计算 x*y+z，但允许加法和乘法与彼此或与周围的操作合并以提高性能。例如，如果硬件高效支持，这可能会被实现为 fma。在不同的机器上，结果可能会不同，并且由于常量传播或其他优化，在同一台机器上也可能不同。请参见 fma。

示例

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

组合乘加，A*y .+ z，用于矩阵-矩阵或矩阵-向量乘法。结果的大小始终与 A*y 相同，但 z 可能更小，或是一个标量。

示例

julia> A=[1.0 2.0; 3.0 4.0]; B=[1.0 1.0; 1.0 1.0]; z=[0, 100];

julia> muladd(A, B, z)
2×2 Matrix{Float64}:
   3.0    3.0
 107.0  107.0

inv(x)

返回 x 的乘法逆元，使得 x*inv(x) 或 inv(x)*x 产生 one(x)（乘法单位元），并且在舍入误差范围内成立。

如果 x 是一个数字，这本质上与 one(x)/x 相同，但对于某些类型，inv(x) 可能会稍微高效一些。

示例

julia> inv(2)
0.5

julia> inv(1 + 2im)
0.2 - 0.4im

julia> inv(1 + 2im) * (1 + 2im)
1.0 + 0.0im

julia> inv(2//3)
3//2

div(x, y)
÷(x, y)

来自欧几里得（整数）除法的商。通常等同于数学运算 x/y，而没有小数部分。

另请参见: cld, fld, rem, divrem.

示例

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

julia> div.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  0  0  1  1  1

div(x, y, r::RoundingMode=RoundToZero)

欧几里得（整数）除法的商。计算 x / y，根据舍入模式 r 四舍五入为整数。换句话说，该数量为

round(x / y, r)

而没有任何中间舍入。

另请参见 fld 和 cld，它们是此函数的特例。

示例：

julia> div(4, 3, RoundToZero) # 匹配 div(4, 3)
1
julia> div(4, 3, RoundDown) # 匹配 fld(4, 3)
1
julia> div(4, 3, RoundUp) # 匹配 cld(4, 3)
2
julia> div(5, 2, RoundNearest)
2
julia> div(5, 2, RoundNearestTiesAway)
3
julia> div(-5, 2, RoundNearest)
-2
julia> div(-5, 2, RoundNearestTiesAway)
-3
julia> div(-5, 2, RoundNearestTiesUp)
-2
julia> div(4, 3, RoundFromZero)
2
julia> div(-4, 3, RoundFromZero)
-2

fld(x, y)

小于或等于 x / y 的最大整数。等价于 div(x, y, RoundDown)。

另见 div, cld, fld1。

示例

julia> fld(7.3, 5.5)
1.0

julia> fld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -2  -1  -1  -1  0  0  0  1  1  1

因为 fld(x, y) 基于浮点数的真实值实现了严格正确的向下取整，因此可能会出现不直观的情况。例如：

julia> fld(6.0, 0.1)
59.0
julia> 6.0 / 0.1
60.0
julia> 6.0 / big(0.1)
59.99999999999999666933092612453056361837965690217069245739573412231113406246995

这里发生的情况是，写作 0.1 的浮点数的真实值略大于数值 1/10，而 6.0 精确表示数字 6。因此 6.0 / 0.1 的真实值略小于 60。在进行除法时，这被精确地舍入为 60.0，但 fld(6.0, 0.1) 始终取真实值的下限，因此结果是 59.0。

cld(x, y)

大于或等于 x / y 的最小整数。等价于 div(x, y, RoundUp)。

另见 div, fld。

示例

julia> cld(5.5, 2.2)
3.0

julia> cld.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -1  -1  -1  0  0  0  1  1  1  2  2

mod(x::Integer, r::AbstractUnitRange)

在范围 r 中找到 y 使得 $x ≡ y (mod n)$，其中 n = length(r)，即 y = mod(x - first(r), n) + first(r)。

另见 mod1。

示例

julia> mod(0, Base.OneTo(3))  # mod1(0, 3)
3

julia> mod(3, 0:2)  # mod(3, 3)
0

mod(x, y)
rem(x, y, RoundDown)

x 对 y 的模运算，或者等价地，x 在向下取整除以 y 后的余数，即 x - y*fld(x,y)，如果不进行中间舍入计算。

结果将与 y 具有相同的符号，且其大小小于 abs(y)（有一些例外，见下面的注释）。

另请参见: rem, div, fld, mod1, invmod.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

julia> mod(eps(), 3)
2.220446049250313e-16

julia> mod(-eps(), 3)
3.0

julia> mod.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

rem(x::Integer, T::Type{<:Integer}) -> T
mod(x::Integer, T::Type{<:Integer}) -> T
%(x::Integer, T::Type{<:Integer}) -> T

找到 y::T 使得 x ≡ y (mod n)，其中 n 是可表示在 T 中的整数数量，y 是 [typemin(T),typemax(T)] 中的一个整数。如果 T 可以表示任何整数（例如 T == BigInt），那么此操作对应于转换为 T。

示例

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

rem(x, y)
%(x, y)

欧几里得除法的余数，返回与 x 同符号且绝对值小于 y 的值。该值始终是精确的。

另见: div, mod, mod1, divrem.

示例

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) * y + rem(x, y)
true

julia> rem.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 -2  -1  0  -2  -1  0  1  2  0  1  2

rem(x, y, r::RoundingMode=RoundToZero)

计算 x 在整数除以 y 后的余数，商根据舍入模式 r 进行舍入。换句话说，数量为

x - y * round(x / y, r)

没有任何中间舍入。

• 如果 r == RoundNearest，则结果是精确的，并且在区间 $[-|y| / 2, |y| / 2]$ 内。另见 RoundNearest。
• 如果 r == RoundToZero（默认），则结果是精确的，并且在区间 $[0, |y|)$ 内，如果 x 为正，或者 $(-|y|, 0]$ 否则。另见 RoundToZero。
• 如果 r == RoundDown，则结果在区间 $[0, y)$ 内，如果 y 为正，或者 $(y, 0]$ 否则。如果 x 和 y 符号不同，并且 abs(x) < abs(y)，则结果可能不精确。另见 RoundDown。
• 如果 r == RoundUp，则结果在区间 $(-y, 0]$ 内，如果 y 为正，或者 $[0, -y)$ 否则。如果 x 和 y 符号相同，并且 abs(x) < abs(y)，则结果可能不精确。另见 RoundUp。
• 如果 r == RoundFromZero，则结果在区间 $(-y, 0]$ 内，如果 y 为正，或者 $[0, -y)$ 否则。如果 x 和 y 符号相同，并且 abs(x) < abs(y)，则结果可能不精确。另见 RoundFromZero。

示例：

julia> x = 9; y = 4;

julia> x % y  # 同于 rem(x, y)
1

julia> x ÷ y  # 同于 div(x, y)
2

julia> x == div(x, y) * y + rem(x, y)
true

rem2pi(x, r::RoundingMode)

计算 x 在整数除以 2π 后的余数，商根据舍入模式 r 进行舍入。换句话说，该量为

x - 2π*round(x/(2π),r)

没有任何中间舍入。这内部使用了 2π 的高精度近似，因此将给出比 rem(x,2π,r) 更准确的结果。

• 如果 r == RoundNearest，则结果在区间 $[-π, π]$ 内。这通常是最准确的结果。另见 RoundNearest。
• 如果 r == RoundToZero，则结果在区间 $[0, 2π]$ 内（如果 x 为正），或者在 $[-2π, 0]$ 内（否则）。另见 RoundToZero。
• 如果 r == RoundDown，则结果在区间 $[0, 2π]$ 内。另见 RoundDown。
• 如果 r == RoundUp，则结果在区间 $[-2π, 0]$ 内。另见 RoundUp。

示例

julia> rem2pi(7pi/4, RoundNearest)
-0.7853981633974485

julia> rem2pi(7pi/4, RoundDown)
5.497787143782138

mod2pi(x)

在除以 2π 后的模，返回范围 $[0,2π)$。

此函数计算除以数值精确的 2π 后的模的浮点表示，因此与 mod(x,2π) 并不完全相同，后者计算的是相对于浮点数 2π 的 x 的模。

示例

julia> mod2pi(9*pi/4)
0.7853981633974481

divrem(x, y, r::RoundingMode=RoundToZero)

欧几里得除法的商和余数。等价于 (div(x, y, r), rem(x, y, r))。同样地，使用默认值 r 时，此调用等价于 (x ÷ y, x % y)。

另见: fldmod, cld。

示例

julia> divrem(3, 7)
(0, 3)

julia> divrem(7, 3)
(2, 1)

fldmod(x, y)

除法后的向下取整商和余数。divrem(x, y, RoundDown) 的便捷包装。等价于 (fld(x, y), mod(x, y))。

另见: fld, cld, fldmod1。

fld1(x, y)

向下取整除法，返回与 mod1(x,y) 一致的值。

另见 mod1, fldmod1。

示例

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) * y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) * y + mod1(x, y)
true

mod1(x, y)

取整除法后的模，返回一个值 r，使得在正 y 的范围 $(0, y]$ 内 mod(r, y) == mod(x, y)，在负 y 的范围 $[y,0)$ 内也是如此。

对于整数参数和正 y，这等于 mod(x, 1:y)，因此对于基于1的索引是自然的。相比之下，mod(x, y) == mod(x, 0:y-1) 对于带有偏移或步幅的计算是自然的。

另见 mod, fld1, fldmod1.

示例

julia> mod1(4, 2)
2

julia> mod1.(-5:5, 3)'
1×11 adjoint(::Vector{Int64}) with eltype Int64:
 1  2  3  1  2  3  1  2  3  1  2

julia> mod1.([-0.1, 0, 0.1, 1, 2, 2.9, 3, 3.1]', 3)
1×8 Matrix{Float64}:
 2.9  3.0  0.1  1.0  2.0  2.9  3.0  0.1

fldmod1(x, y)

返回 (fld1(x,y), mod1(x,y))。

另请参见 fld1, mod1。

//(num, den)

将两个整数或有理数相除，返回一个 Rational 结果。更一般地，// 可以用于其他数值类型的精确有理除法，这些数值类型具有整数或有理成分，例如具有整数成分的复数。

请注意，// 不允许使用浮点数（AbstractFloat）作为参数（即使这些值是有理数）。参数必须是 Integer、Rational 或其复合类型的子类型。

示例

julia> 3 // 5
3//5

julia> (3 // 5) // (2 // 1)
3//10

julia> (1+2im) // (3+4im)
11//25 + 2//25*im

julia> 1.0 // 2
ERROR: MethodError: no method matching //(::Float64, ::Int64)
[...]

rationalize([T<:Integer=Int,] x; tol::Real=eps(x))

将浮点数 x 近似为给定整数类型的 Rational 数字。结果与 x 的差异不超过 tol。

示例

julia> rationalize(5.6)
28//5

julia> a = rationalize(BigInt, 10.3)
103//10

julia> typeof(numerator(a))
BigInt

numerator(x)

x 的有理数表示的分子。

示例

julia> numerator(2//3)
2

julia> numerator(4)
4

denominator(x)

x 的有理数表示的分母。

示例

julia> denominator(2//3)
3

julia> denominator(4)
1

<<(x, n)

左位移运算符，x << n。对于 n >= 0，结果是 x 向左移动 n 位，填充 0。这相当于 x * 2^n。对于 n < 0，这相当于 x >> -n。

示例

julia> Int8(3) << 2
12

julia> bitstring(Int8(3))
"00000011"

julia> bitstring(Int8(12))
"00001100"

另请参见 >>，>>>，exp2，ldexp。

<<(B::BitVector, n) -> BitVector

左位移运算符，B << n。对于 n >= 0，结果是 B 的元素向后移动 n 个位置，用 false 值填充。如果 n < 0，元素向前移动。等价于 B >> -n。

示例

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B << 1
5-element BitVector:
 0
 1
 0
 0
 0

julia> B << -1
5-element BitVector:
 0
 1
 0
 1
 0

>>(x, n)

右位移运算符，x >> n。对于 n >= 0，结果是 x 向右移动 n 位，如果 x >= 0 则填充 0，如果 x < 0 则填充 1，保持 x 的符号。这相当于 fld(x, 2^n)。对于 n < 0，这相当于 x << -n。

示例

julia> Int8(13) >> 2
3

julia> bitstring(Int8(13))
"00001101"

julia> bitstring(Int8(3))
"00000011"

julia> Int8(-14) >> 2
-4

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(-4))
"11111100"

另见 >>>，<<。

>>(B::BitVector, n) -> BitVector

右位移运算符，B >> n。对于 n >= 0，结果是 B 的元素向前移动 n 个位置，用 false 值填充。如果 n < 0，元素向后移动。等价于 B << -n。

示例

julia> B = BitVector([true, false, true, false, false])
5-element BitVector:
 1
 0
 1
 0
 0

julia> B >> 1
5-element BitVector:
 0
 1
 0
 1
 0

julia> B >> -1
5-element BitVector:
 0
 1
 0
 0
 0

>>>(x, n)

无符号右位移运算符，x >>> n。对于 n >= 0，结果是 x 向右移动 n 位，填充 0。对于 n < 0，这等价于 x << -n。

对于 Unsigned 整数类型，这等价于 >>。对于 Signed 整数类型，这等价于 signed(unsigned(x) >> n)。

示例

julia> Int8(-14) >>> 2
60

julia> bitstring(Int8(-14))
"11110010"

julia> bitstring(Int8(60))
"00111100"

BigInt 被视为具有无限大小，因此不需要填充，这等价于 >>。

另见 >>，<<。

>>>(B::BitVector, n) -> BitVector

无符号右位移运算符，B >>> n。等同于 B >> n。有关详细信息和示例，请参见 >>。

bitrotate(x::Base.BitInteger, k::Integer)

bitrotate(x, k) 实现了按位旋转。它返回 x 的值，其位向左旋转 k 次。负值的 k 将向右旋转。

另见: <<, circshift, BitArray.

julia> bitrotate(UInt8(114), 2)
0xc9

julia> bitstring(bitrotate(0b01110010, 2))
"11001001"

julia> bitstring(bitrotate(0b01110010, -2))
"10011100"

julia> bitstring(bitrotate(0b01110010, 8))
"01110010"

:expr

引用一个表达式 expr，返回 expr 的抽象语法树 (AST)。AST 可能是 Expr、Symbol 或一个字面值。语法 :identifier 计算为一个 Symbol。

另请参见: Expr, Symbol, Meta.parse

示例

julia> expr = :(a = b + 2*x)
:(a = b + 2x)

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}

range(start, stop, length)
range(start, stop; length, step)
range(start; length, stop, step)
range(;start, length, stop, step)

从参数构造一个具有均匀间隔元素和优化存储的专用数组（一个 AbstractRange）。在数学上，范围是由 start、step、stop 和 length 中的任意三个唯一确定的。有效的范围调用包括：

• 使用 start、step、stop、length 中的任意三个调用 range。
• 使用 start、stop、length 中的两个调用 range。在这种情况下，step 将被假定为 1。如果两个参数都是整数，将返回一个 UnitRange。
• 使用 stop 或 length 中的一个调用 range。start 和 step 将被假定为 1。

有关返回类型的更多详细信息，请参见扩展帮助。另请参见 logrange 以获取对数间隔点。

示例

julia> range(1, length=100)
1:100

julia> range(1, stop=100)
1:100

julia> range(1, step=5, length=100)
1:5:496

julia> range(1, step=5, stop=100)
1:5:96

julia> range(1, 10, length=101)
1.0:0.09:10.0

julia> range(1, 100, step=5)
1:5:96

julia> range(stop=10, length=5)
6:10

julia> range(stop=10, step=1, length=5)
6:1:10

julia> range(start=1, step=1, stop=10)
1:1:10

julia> range(; length = 10)
Base.OneTo(10)

julia> range(; stop = 6)
Base.OneTo(6)

julia> range(; stop = 6.5)
1.0:1.0:6.0

如果未指定 length 且 stop - start 不是 step 的整数倍，则将生成一个在 stop 之前结束的范围。

julia> range(1, 3.5, step=2)
1.0:2.0:3.0

特别注意确保中间值以有理数计算。要避免这种引入的开销，请参见 LinRange 构造函数。

扩展帮助

当参数为整数且

• 仅提供 length
• 仅提供 stop

时，range 将生成一个 Base.OneTo。

当参数为整数且

• 仅提供 start 和 stop
• 仅提供 length 和 stop

时，range 将生成一个 UnitRange。

如果提供了 step，即使指定为 1，也不会生成 UnitRange。

Base.OneTo(n)

定义一个 AbstractUnitRange，其行为类似于 1:n，并且通过类型系统保证下限为 1。

StepRangeLen(         ref::R, step::S, len, [offset=1]) where {  R,S}
StepRangeLen{T,R,S}(  ref::R, step::S, len, [offset=1]) where {T,R,S}
StepRangeLen{T,R,S,L}(ref::R, step::S, len, [offset=1]) where {T,R,S,L}

一个范围 r，其中 r[i] 产生类型为 T 的值（在第一种形式中，T 是自动推导的），由一个 ref 参考值、一个 step 和长度 len 参数化。默认情况下，ref 是起始值 r[1]，但您也可以将其作为某个其他索引 1 <= offset <= len 的值 r[offset] 提供。语法 a:b 或 a:b:c，其中 a、b 或 c 任何一个是浮点数，创建一个 StepRangeLen。

logrange(start, stop, length)
logrange(start, stop; length)

构造一个专门的数组，其元素在给定的端点之间以对数方式间隔。也就是说，连续元素的比率是一个常数，依据长度计算得出。

这类似于 Python 中的 geomspace。与 Mathematica 中的 PowerRange 不同，您指定的是元素的数量而不是比率。与 Python 和 Matlab 中的 logspace 不同，start 和 stop 参数始终是结果的第一个和最后一个元素，而不是应用于某个基数的幂。

示例

julia> logrange(10, 4000, length=3)
3-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 10.0, 200.0, 4000.0

julia> ans[2] ≈ sqrt(10 * 4000)  # 中间元素是几何平均数
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # 算术平均数
true

julia> logrange(1f0, 32f0, 11)
11-element Base.LogRange{Float32, Float64}:
 1.0, 1.41421, 2.0, 2.82843, 4.0, 5.65685, 8.0, 11.3137, 16.0, 22.6274, 32.0

julia> logrange(1, 1000, length=4) ≈ 10 .^ (0:3)
true

有关更多详细信息，请参见 LogRange 类型。

另请参见 range 以获取线性间隔的点。

LogRange{T}(start, stop, len) <: AbstractVector{T}

一个范围，其元素在 start 和 stop 之间以对数方式间隔，间隔由 len 控制。由 logrange 返回。

与 LinRange 类似，第一个和最后一个元素将正好是提供的值，但中间值可能会有小的浮点误差。这些值是使用端点的对数计算的，这些对数在构造时存储，通常比 T 具有更高的精度。

示例

julia> logrange(1, 4, length=5)
5-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 1.41421, 2.0, 2.82843, 4.0

julia> Base.LogRange{Float16}(1, 4, 5)
5-element Base.LogRange{Float16, Float64}:
 1.0, 1.414, 2.0, 2.828, 4.0

julia> logrange(1e-310, 1e-300, 11)[1:2:end]
6-element Vector{Float64}:
 1.0e-310
 9.999999999999974e-309
 9.999999999999981e-307
 9.999999999999988e-305
 9.999999999999994e-303
 1.0e-300

julia> prevfloat(1e-308, 5) == ans[2]
true

请注意，不允许整数类型 T。例如，可以使用 round.(Int, xs)，或某个整数基数的显式幂：

julia> xs = logrange(1, 512, 4)
4-element Base.LogRange{Float64, Base.TwicePrecision{Float64}}:
 1.0, 8.0, 64.0, 512.0

julia> 2 .^ (0:3:9) |> println
[1, 8, 64, 512]

==(x, y)

通用相等运算符。回退到 ===。应为所有具有相等概念的类型实现，基于实例所代表的抽象值。例如，所有数值类型按数值进行比较，忽略类型。字符串按字符序列进行比较，忽略编码。同类型的集合通常比较它们的键集，如果这些键相等，则比较每个键的值，如果所有这样的对都相等，则返回 true。其他属性通常不被考虑（例如确切类型）。

该运算符遵循 IEEE 浮点数的语义：0.0 == -0.0 和 NaN != NaN。

结果为 Bool 类型，除非其中一个操作数为 missing，在这种情况下返回 missing（三值逻辑）。集合通常实现类似于 all 的三值逻辑，如果任何操作数包含缺失值且所有其他对相等，则返回 missing。使用 isequal 或 === 始终获得 Bool 结果。

实现

新的数值类型应为新类型的两个参数实现此函数，并在可能的情况下通过提升规则处理与其他类型的比较。

isequal 回退到 ==，因此 == 的新方法将被 Dict 类型用于比较键。如果您的类型将用作字典键，因此也应实现 hash。

如果某个类型定义了 ==、isequal 和 isless，则它还应实现 < 以确保比较的一致性。

!=(x, y)
≠(x,y)

不等比较运算符。总是给出与 == 相反的答案。

实现

新类型通常不应实现此功能，而应依赖于后备定义 !=(x,y) = !(x==y)。

示例

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

创建一个函数，该函数使用 != 将其参数与 x 进行比较，即一个等价于 y -> y != x 的函数。返回的函数类型为 Base.Fix2{typeof(!=)}，可用于实现专门的方法。

!==(x, y)
≢(x,y)

总是给出与 === 相反的答案。

示例

julia> a = [1, 2]; b = [1, 2];

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

小于比较运算符。回退到 isless。由于浮点 NaN 值的行为，此运算符实现了部分顺序。

实现

具有规范部分顺序的新类型应为新类型的两个参数实现此函数。具有规范全序的新类型应实现 isless。

另见 isunordered。

示例

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

创建一个函数，该函数使用 < 将其参数与 x 进行比较，即一个等价于 y -> y < x 的函数。返回的函数类型为 Base.Fix2{typeof(<)}，可用于实现专门的方法。

<=(x, y)
≤(x,y)

小于或等于比较运算符。回退到 (x < y) | (x == y)。

示例

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

创建一个函数，该函数使用 <= 将其参数与 x 进行比较，即一个等价于 y -> y <= x 的函数。返回的函数类型为 Base.Fix2{typeof(<=)}，可用于实现专门的方法。

>(x, y)

大于比较运算符。回退到 y < x。

实现

通常，新类型应该实现 < 而不是这个函数，并依赖回退定义 >(x, y) = y < x。

示例

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

创建一个函数，该函数使用 > 将其参数与 x 进行比较，即一个等价于 y -> y > x 的函数。返回的函数类型为 Base.Fix2{typeof(>)}，可用于实现专门的方法。

>=(x, y)
≥(x,y)

大于或等于比较运算符。回退到 y <= x。

示例

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

创建一个函数，该函数使用 >= 将其参数与 x 进行比较，即一个等价于 y -> y >= x 的函数。返回的函数类型为 Base.Fix2{typeof(>=)}，可用于实现专门的方法。

cmp(x,y)

根据 x 是否小于、等于或大于 y 返回 -1、0 或 1。使用 isless 实现的全序。

示例

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

julia> cmp(2+im, 3-im)
ERROR: MethodError: no method matching isless(::Complex{Int64}, ::Complex{Int64})
[...]

cmp(<, x, y)

返回 -1、0 或 1，具体取决于 x 是否小于、等于或大于 y。第一个参数指定要使用的小于比较函数。

cmp(a::AbstractString, b::AbstractString) -> Int

比较两个字符串。如果两个字符串的长度相同且每个索引处的字符相同，则返回 0。如果 a 是 b 的前缀，或者 a 在字母顺序上排在 b 之前，则返回 -1。如果 b 是 a 的前缀，或者 b 在字母顺序上排在 a 之前（从技术上讲，是按 Unicode 代码点的字典顺序），则返回 1。

示例

julia> cmp("abc", "abc")
0

julia> cmp("ab", "abc")
-1

julia> cmp("abc", "ab")
1

julia> cmp("ab", "ac")
-1

julia> cmp("ac", "ab")
1

julia> cmp("α", "a")
1

julia> cmp("b", "β")
-1

~(x)

按位取反。

另见：!, &, |。

示例

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

按位与。实现了三值逻辑，如果一个操作数是missing而另一个是true，则返回missing。为函数应用形式添加括号：(&)(x, y)。

另请参见：|，xor，&&。

示例

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

按位或。实现了三值逻辑，如果一个操作数是missing而另一个是false，则返回missing。

另请参见：&，xor，||。

示例

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

xor(x, y)
⊻(x, y)

x 和 y 的按位异或。实现了 三值逻辑，如果其中一个参数是 missing，则返回 missing。

中缀操作 a ⊻ b 是 xor(a,b) 的同义词，⊻ 可以通过在 Julia REPL 中按 Tab 完成 \xor 或 \veebar 来输入。

示例

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

julia> [true; true; false] .⊻ [true; false; false]
3-element BitVector:
 0
 1
 0

nand(x, y)
⊼(x, y)

x 和 y 的按位 nand（非与）。实现了 三值逻辑，如果其中一个参数是 missing，则返回 missing。

中缀操作 a ⊼ b 是 nand(a,b) 的同义词，⊼ 可以通过在 Julia REPL 中按 Tab 完成 \nand 或 \barwedge 来输入。

示例

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

julia> [true; true; false] .⊼ [true; false; false]
3-element BitVector:
 0
 1
 1

nor(x, y)
⊽(x, y)

x 和 y 的按位 nor（非或）。实现了 三值逻辑，如果其中一个参数是 missing 而另一个不是 true，则返回 missing。

中缀操作 a ⊽ b 是 nor(a,b) 的同义词，⊽ 可以通过在 Julia REPL 中按 Tab 完成 \nor 或 \barvee 来输入。

示例

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

julia> [true; true; false] .⊽ [true; false; false]
3-element BitVector:
 0
 0
 1

!(x)

布尔非。实现了三值逻辑，如果 x 是 missing，则返回 missing。

另见 ~ 进行按位非。

示例

julia> !true
false

julia> !false
true

julia> !missing
missing

julia> .![true false true]
1×3 BitMatrix:
 0  1  0

!f::Function

谓词函数否定：当 ! 的参数是一个函数时，它返回一个组合函数，该函数计算 f 的布尔否定。

另见 ∘。

示例

julia> str = "∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"
"∀ ε > 0, ∃ δ > 0: |x-y| < δ ⇒ |f(x)-f(y)| < ε"

julia> filter(isletter, str)
"εδxyδfxfyε"

julia> filter(!isletter, str)
"∀  > 0, ∃  > 0: |-| <  ⇒ |()-()| < "

x && y

短路布尔与。

另见 &、三元运算符 ? :，以及手册中关于 控制流 的部分。

示例

julia> x = 3;

julia> x > 1 && x < 10 && x isa Int
true

julia> x < 0 && error("expected positive x")
false

x || y

短路布尔或。

另见：|, xor, &&。

示例

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("neither is true!")
true

isapprox(x, y; atol::Real=0, rtol::Real=atol>0 ? 0 : √eps, nans::Bool=false[, norm::Function])

不精确的相等比较。如果两个数字的相对距离 或 绝对距离在容差范围内，则它们被认为相等：isapprox 在 norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))) 时返回 true。默认的 atol（绝对容差）为零，默认的 rtol（相对容差）取决于 x 和 y 的类型。关键字参数 nans 决定是否将 NaN 值视为相等（默认为 false）。

对于实数或复数浮点值，如果未指定 atol > 0，则 rtol 默认为 x 或 y 类型的 eps 的平方根，以较大者为准（精度最低）。这对应于要求大约一半有效数字的相等。否则，例如对于整数参数或如果提供了 atol > 0，则 rtol 默认为零。

norm 关键字对于数值 (x,y) 默认为 abs，对于数组默认为 LinearAlgebra.norm（在某些情况下，替代的 norm 选择是有用的）。当 x 和 y 是数组时，如果 norm(x-y) 不是有限的（即 ±Inf 或 NaN），则比较会回退到检查 x 和 y 的所有元素是否在分量上大致相等。

二元运算符 ≈ 等同于带有默认参数的 isapprox，而 x ≉ y 等同于 !isapprox(x,y)。

请注意，x ≈ 0（即，使用默认容差与零进行比较）等同于 x == 0，因为默认的 atol 为 0。在这种情况下，您应该提供适当的 atol（或使用 norm(x) ≤ atol）或重新安排您的代码（例如，使用 x ≈ y 而不是 x - y ≈ 0）。因为它依赖于您问题的整体缩放（“单位”），所以无法自动选择非零的 atol：例如，在 x - y ≈ 0 中，如果 x 是 地球半径 的米数，则 atol=1e-9 是一个极小的容差，但如果 x 是 氢原子半径 的米数，则是一个极大的容差。

示例

julia> isapprox(0.1, 0.15; atol=0.05)
true

julia> isapprox(0.1, 0.15; rtol=0.34)
true

julia> isapprox(0.1, 0.15; rtol=0.33)
false

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

julia> isapprox(1e-10, 0, atol=1e-8)
true

julia> isapprox([10.0^9, 1.0], [10.0^9, 2.0]) # using `norm`
true

isapprox(x; kwargs...) / ≈(x; kwargs...)

创建一个函数，该函数使用 ≈ 将其参数与 x 进行比较，即一个等价于 y -> y ≈ x 的函数。

这里支持的关键字参数与 2 个参数的 isapprox 中的相同。

sin(x)

计算 x 的正弦，其中 x 以弧度为单位。

另请参见 sind, sinpi, sincos, cis, asin。

示例

julia> round.(sin.(range(0, 2pi, length=9)'), digits=3)
1×9 Matrix{Float64}:
 0.0  0.707  1.0  0.707  0.0  -0.707  -1.0  -0.707  -0.0

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

julia> round.(sincos(pi/6), digits=3)
(0.5, 0.866)

julia> round(cis(pi/6), digits=3)
0.866 + 0.5im

julia> round(exp(im*pi/6), digits=3)
0.866 + 0.5im

cos(x)

计算 x 的余弦，其中 x 以弧度为单位。

另请参见 cosd, cospi, sincos, cis.

sincos(x)

同时计算 x 的正弦和余弦，其中 x 以弧度为单位，返回一个元组 (正弦, 余弦)。

另见 cis, sincospi, sincosd。

tan(x)

计算 x 的正切，其中 x 以弧度为单位。

sind(x)

计算 x 的正弦，其中 x 以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

cosd(x)

计算 x 的余弦，其中 x 以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

tand(x)

计算 x 的正切，其中 x 以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

sincosd(x)

同时计算 x 的正弦和余弦，其中 x 以度为单位。

sinpi(x)

更准确地计算 $\sin(\pi x)$，尤其是对于较大的 x。

另请参见 sind，cospi，sincospi。

cospi(x)

更准确地计算 $\cos(\pi x)$，尤其是对于较大的 x，比 cos(pi*x) 更好。

tanpi(x)

计算 $\tan(\pi x)$，比 tan(pi*x) 更准确，特别是对于较大的 x。

另请参见 tand, sinpi, cospi, sincospi.

sincospi(x)

同时计算 sinpi(x) 和 cospi(x)（π*x 的正弦和余弦，其中 x 以弧度为单位），返回一个元组 (sine, cosine)。

另请参见：cispi，sincosd，sinpi。

sinh(x)

计算 x 的双曲正弦。

cosh(x)

计算 x 的双曲余弦。

tanh(x)

计算 x 的双曲正切。

另见 tan, atanh。

示例

julia> tanh.(-3:3f0)  # 这里 3f0 是 Float32
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

julia> tan.(im .* (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

asin(x)

计算 x 的反正弦，输出以弧度为单位。

另请参见 asind 以获取以度为单位的输出。

示例

julia> asin.((0, 1/2, 1))
(0.0, 0.5235987755982989, 1.5707963267948966)

julia> asind.((0, 1/2, 1))
(0.0, 30.000000000000004, 90.0)

acos(x)

计算 x 的反余弦，输出以弧度表示

atan(y)
atan(y, x)

计算 y 或 y/x 的反正切。

对于一个实数参数，这是正 x 轴与点 (1, y) 之间的弧度角，返回值在区间 $[-\pi/2, \pi/2]$ 内。

对于两个参数，这是正 x 轴与点 (x, y) 之间的弧度角，返回值在区间 $[-\pi, \pi]$ 内。这对应于标准的 atan2 函数。请注意，按照约定，当 x < 0 时，atan(0.0,x) 被定义为 $\pi$，而 atan(-0.0,x) 被定义为 $-\pi$。

另见 atand 以获取度数。

示例

julia> rad2deg(atan(-1/√3))
-30.000000000000004

julia> rad2deg(atan(-1, √3))
-30.000000000000004

julia> rad2deg(atan(1, -√3))
150.0

asind(x)

计算 x 的反正弦，输出以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

acosd(x)

计算 x 的反余弦，输出以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

atand(y)
atand(y,x)

计算 y 或 y/x 的反正切，输出以度为单位。

sec(x)

计算 x 的正割，其中 x 以弧度为单位。

csc(x)

计算 x 的余割，其中 x 以弧度为单位。

cot(x)

计算 x 的余切，其中 x 以弧度表示。

secd(x)

计算 x 的割余弦，其中 x 以度为单位。

cscd(x)

计算 x 的余割，其中 x 以度为单位。

cotd(x)

计算 x 的余切，其中 x 以度为单位。

asec(x)

计算 x 的反 secant，输出以弧度为单位。

acsc(x)

计算 x 的反余割，输出以弧度为单位。

acot(x)

计算 x 的反余切，输出以弧度表示。

asecd(x)

计算 x 的反正割，输出以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

acscd(x)

计算 x 的反余割，输出以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

acotd(x)

计算 x 的反余切，输出以度为单位。如果 x 是一个矩阵，则 x 需要是一个方阵。

sech(x)

计算 x 的双曲余割。

csch(x)

计算 x 的双曲余割。

coth(x)

计算 x 的双曲余切。

asinh(x)

计算 x 的反双曲正弦。

acosh(x)

计算 x 的反双曲余弦。

atanh(x)

计算 x 的反双曲正切。

asech(x)

计算 x 的反双曲正割。

acsch(x)

计算 x 的反双曲余割。

acoth(x)

计算 x 的反双曲余切。

sinc(x)

计算归一化的 sinc 函数 $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$ 如果 $x \neq 0$，并且当 $x = 0$ 时为 $1$。

另见 cosc，它的导数。

cosc(x)

计算 $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$ 如果 $x \neq 0$，并且如果 $x = 0$ 则为 $0$。这是 sinc(x) 的导数。

另见 sinc.

deg2rad(x)

将 x 从度转换为弧度。

另见 rad2deg, sind, pi。

示例

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

将 x 从弧度转换为度。

另见 deg2rad。

示例

julia> rad2deg(pi)
180.0

hypot(x, y)

计算斜边 $\sqrt{|x|^2+|y|^2}$，避免溢出和下溢。

此代码是对 Carlos F. Borges 所描述的算法的实现：改进的 hypot(a,b) 算法。该文章可在线访问，链接为 https://arxiv.org/abs/1904.09481

hypot(x...)

计算斜边 $\sqrt{\sum |x_i|^2}$，避免溢出和下溢。

另请参见标准库中的 norm LinearAlgebra。

示例

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 溢出
ERROR: DomainError with -2.914184810805068e18:
sqrt 被调用时使用了负实数参数，但仅在使用复数参数时才会返回复数结果。尝试使用 sqrt(Complex(x))。
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

julia> hypot(3, 4im, 12.0)
13.0

julia> using LinearAlgebra

julia> norm([a, a, a, a]) == hypot(a, a, a, a)
true

log(x)

计算 x 的自然对数。

对于负的 Real 参数会抛出 DomainError。使用复数参数可以获得复数结果。沿负实轴有一个分支切割，其中 -0.0im 被视为在轴下方。

另请参见 ℯ, log1p, log2, log10。

示例

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log 被调用时使用了负实参数，但仅在使用复数参数时才会返回复数结果。尝试 log(Complex(x))。
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(-3 + 0im)
1.0986122886681098 + 3.141592653589793im

julia> log(-3 - 0.0im)
1.0986122886681098 - 3.141592653589793im

julia> log.(exp.(-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log(b,x)

计算 x 的底为 b 的对数。对于负的 Real 参数会抛出 DomainError。

示例

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log 被调用时使用了负的实数参数，但仅在使用复数参数时才会返回复数结果。尝试 log(Complex(x))。
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log 被调用时使用了负的实数参数，但仅在使用复数参数时才会返回复数结果。尝试 log(Complex(x))。
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0

log2(x)

计算 x 的以 2 为底的对数。对于负的 Real 参数会抛出 DomainError。

另请参见：exp2，ldexp，ispow2。

示例

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2 被负实数参数调用，但仅在使用复数参数时才会返回复数结果。尝试 log2(Complex(x))。
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

julia> log2.(2.0 .^ (-1:1))
3-element Vector{Float64}:
 -1.0
  0.0
  1.0

log10(x)

计算 x 的以 10 为底的对数。对于负的 Real 参数会抛出 DomainError。

示例

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10 被负实数参数调用，但仅在调用复数参数时才会返回复数结果。尝试 log10(Complex(x))。
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

准确的自然对数 1+x。对于小于 -1 的 Real 参数会抛出 DomainError。

示例

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
错误：-2.0 的 DomainError：
log1p 被调用时实数参数 < -1，但仅在使用复数参数时才会返回复数结果。尝试 log1p(Complex(x))。
堆栈跟踪：
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

返回 (x,exp)，使得 x 的大小在区间 $[1/2, 1)$ 或 0，并且 val 等于 $x \times 2^{exp}$。

另见 significand, exponent, ldexp。

示例

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # 区间 [1, 2) 代替
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # 指数会导致错误
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

计算 x 的自然底数指数，换句话说就是 $ℯ^x$。

另请参见 exp2，exp10 和 cis。

示例

julia> exp(1.0)
2.718281828459045

julia> exp(im * pi) ≈ cis(pi)
true

exp2(x)

计算 x 的以 2 为底的指数，换句话说就是 $2^x$。

另见 ldexp, <<。

示例

julia> exp2(5)
32.0

julia> 2^5
32

julia> exp2(63) > typemax(Int)
true

exp10(x)

计算 x 的以 10 为底的指数，换句话说就是 $10^x$。

示例

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

计算 $x \times 2^n$。

另见 frexp, exponent。

示例

julia> ldexp(5.0, 2)
20.0

modf(x)

返回一个元组 (fpart, ipart)，包含一个数字的分数部分和整数部分。两个部分与参数具有相同的符号。

示例

julia> modf(3.5)
(0.5, 3.0)

julia> modf(-3.5)
(-0.5, -3.0)

expm1(x)

准确计算 $e^x-1$。它避免了在直接计算 exp(x)-1 时对于小值 x 的精度损失。

示例

julia> expm1(1e-16)
1.0e-16

julia> exp(1e-16) - 1
0.0

round([T,] x, [r::RoundingMode])
round(x, [r::RoundingMode]; digits::Integer=0, base = 10)
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

对数字 x 进行四舍五入。

如果没有关键字参数，x 将被四舍五入为整数值，返回类型为 T 的值，或者如果没有提供 T，则返回与 x 相同类型的值。如果该值无法用 T 表示，将抛出 InexactError，类似于 convert。

如果提供了 digits 关键字参数，则会四舍五入到小数点后指定的位数（如果为负，则在小数点前），以 base 为基数。

如果提供了 sigdigits 关键字参数，则会四舍五入到指定的有效数字，以 base 为基数。

RoundingMode r 控制四舍五入的方向；默认值为 RoundNearest，它四舍五入到最近的整数，平局（0.5 的分数值）将四舍五入到最近的偶数。请注意，如果全局四舍五入模式被更改，round 可能会给出不正确的结果（参见 rounding）。

在四舍五入到浮点类型时，将四舍五入到该类型可表示的整数（和 Inf），而不是实际的整数。Inf 被视为比 floatmax(T) 大一个 ulp，以确定“最近”，类似于 convert。

示例

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

julia> round(pi; digits=3, base=2)
3.125

julia> round(123.456; sigdigits=2)
120.0

julia> round(357.913; sigdigits=4, base=2)
352.0

julia> round(Float16, typemax(UInt128))
Inf16

julia> floor(Float16, typemax(UInt128))
Float16(6.55e4)

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

扩展

要将 round 扩展到新的数值类型，通常只需定义 Base.round(x::NewType, r::RoundingMode)。

RoundingMode

用于控制浮点运算的舍入模式的类型（通过 rounding/setrounding 函数），或作为舍入到最接近整数的可选参数（通过 round 函数）。

当前支持的舍入模式有：

• RoundNearest（默认）
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

默认的舍入模式。舍入到最接近的整数，平局（0.5的分数值）舍入到最接近的偶数。

RoundNearestTiesAway

四舍五入到最接近的整数，平局时向远离零的方向舍入（C/C++ round 行为）。

RoundNearestTiesUp

四舍五入到最接近的整数，平局时向正无穷大舍入（Java/JavaScript round 行为）。

向零取整

使用这种舍入模式的 round 是 trunc 的别名。

RoundFromZero

从零舍入。

示例

julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06

向上取整

round 使用这种舍入模式是 ceil 的别名。

向下取整

round 使用这种舍入模式是 floor 的别名。

round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]])
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=0, base=10)
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits, base=10)

返回与复数值 z 最近的整数值，类型与 z 相同，使用指定的 RoundingMode 进行平局处理。第一个 RoundingMode 用于舍入实部，而第二个用于舍入虚部。

RoundingModeReal 和 RoundingModeImaginary 默认为 RoundNearest，它舍入到最近的整数，平局（0.5 的分数值）舍入到最近的偶数整数。

示例

julia> round(3.14 + 4.5im)
3.0 + 4.0im

julia> round(3.14 + 4.5im, RoundUp, RoundNearestTiesUp)
4.0 + 5.0im

julia> round(3.14159 + 4.512im; digits = 1)
3.1 + 4.5im

julia> round(3.14159 + 4.512im; sigdigits = 3)
3.14 + 4.51im

ceil([T,] x)
ceil(x; digits::Integer= [, base = 10])
ceil(x; sigdigits::Integer= [, base = 10])

ceil(x) 返回与 x 相同类型的最接近的整数值，该值大于或等于 x。

ceil(T, x) 将结果转换为类型 T，如果向上取整的值无法表示为 T，则会抛出 InexactError。

关键字 digits、sigdigits 和 base 的工作方式与 round 相同。

要支持新类型的 ceil，请定义 Base.round(x::NewType, ::RoundingMode{:Up})。

floor([T,] x)
floor(x; digits::Integer= [, base = 10])
floor(x; sigdigits::Integer= [, base = 10])

floor(x) 返回与 x 相同类型的最接近的整数值，该值小于或等于 x。

floor(T, x) 将结果转换为类型 T，如果向下取整的值无法表示为 T，则会抛出 InexactError。

关键字 digits、sigdigits 和 base 的工作方式与 round 相同。

要支持新类型的 floor，请定义 Base.round(x::NewType, ::RoundingMode{:Down})。

trunc([T,] x)
trunc(x; digits::Integer= [, base = 10])
trunc(x; sigdigits::Integer= [, base = 10])

trunc(x) 返回与 x 相同类型的最接近的整数值，其绝对值小于或等于 x 的绝对值。

trunc(T, x) 将结果转换为类型 T，如果截断值无法表示为 T，则抛出 InexactError。

关键字 digits、sigdigits 和 base 的工作方式与 round 相同。

要支持 trunc 用于新类型，请定义 Base.round(x::NewType, ::RoundingMode{:ToZero})。

另请参见: %, floor, unsigned, unsafe_trunc。

示例

julia> trunc(2.22)
2.0

julia> trunc(-2.22, digits=1)
-2.2

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

返回类型 T 的最近整数值，其绝对值小于或等于 x 的绝对值。如果该值无法被 T 表示，将返回一个任意值。另见 trunc。

示例

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

返回参数的最小值，依据 isless。如果任何参数为 missing，则返回 missing。另请参见 minimum 函数以从集合中获取最小元素。

示例

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

返回参数的最大值，依据 isless。如果任何参数为 missing，则返回 missing。另请参见 maximum 函数以从集合中获取最大元素。

示例

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

返回 (min(x,y), max(x,y))。

另请参见 extrema，它返回 (minimum(x), maximum(x))。

示例

julia> minmax('c','b')
('b', 'c')

clamp(x, lo, hi)

如果 lo <= x <= hi，则返回 x。如果 x > hi，则返回 hi。如果 x < lo，则返回 lo。参数会提升到一个共同的类型。

另见 clamp!, min, max。

示例

julia> clamp.([pi, 1.0, big(10)], 2.0, 9.0)
3-element Vector{BigFloat}:
 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
 2.0
 9.0

julia> clamp.([11, 8, 5], 10, 6)  # 一个 lo > hi 的例子
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

将 x 限制在 typemin(T) 和 typemax(T) 之间，并将结果转换为类型 T。

另见 trunc。

示例

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

julia> trunc(Int, 4pi^2)
39

clamp(x::Integer, r::AbstractUnitRange)

将 x 限制在范围 r 内。

clamp!(array::AbstractArray, lo, hi)

将 array 中的值限制在指定范围内，原地修改。另见 clamp。

示例

julia> row = collect(-4:4)';

julia> clamp!(row, 0, Inf)
1×9 adjoint(::Vector{Int64}) with eltype Int64:
 0  0  0  0  0  1  2  3  4

julia> clamp.((-4:4)', 0, Inf)
1×9 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0  1.0  2.0  3.0  4.0

abs(x)

x 的绝对值。

当 abs 应用于有符号整数时，可能会发生溢出，导致返回负值。此溢出仅在 abs 应用于有符号整数的最小可表示值时发生。也就是说，当 x == typemin(typeof(x)) 时，abs(x) == x < 0，而不是 -x，这可能是预期的结果。

另请参见: abs2, unsigned, sign。

示例

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # 在 typemin(Int8) 处溢出
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

julia> maximum(abs, [1, -2, 3, -4])
4

Checked

Checked 模块提供了内置有符号和无符号整数类型的算术函数，当发生溢出时会抛出错误。它们的命名方式类似于 checked_sub、checked_div 等。此外，add_with_overflow、sub_with_overflow、mul_with_overflow 返回未检查的结果和一个布尔值，表示是否发生了溢出。

Base.checked_abs(x)

计算 abs(x)，在适用的情况下检查溢出错误。例如，标准的二进制补码有符号整数（例如 Int）无法表示 abs(typemin(Int))，因此会导致溢出。

溢出保护可能会带来明显的性能损失。

Base.checked_neg(x)

计算 -x，在适用的情况下检查溢出错误。例如，标准的二进制补码有符号整数（例如 Int）无法表示 -typemin(Int)，因此会导致溢出。

溢出保护可能会带来明显的性能损失。

Base.checked_add(x, y)

计算 x+y，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_sub(x, y)

计算 x-y，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_mul(x, y)

计算 x*y，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_div(x, y)

计算 div(x,y)，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_rem(x, y)

计算 x%y，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_fld(x, y)

计算 fld(x,y)，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_mod(x, y)

计算 mod(x,y)，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_cld(x, y)

计算 cld(x,y)，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.checked_pow(x, y)

计算 ^(x,y)，在适用的情况下检查溢出错误。

溢出保护可能会带来明显的性能损失。

Base.add_with_overflow(x, y) -> (r, f)

计算 r = x+y，标志 f 表示是否发生了溢出。

Base.sub_with_overflow(x, y) -> (r, f)

计算 r = x-y，标志 f 表示是否发生了溢出。

Base.mul_with_overflow(x, y) -> (r, f)

计算 r = x*y，标志 f 表示是否发生了溢出。

abs2(x)

x 的平方绝对值。

这比 abs(x)^2 更快，特别是对于复杂数，因为 abs(x) 需要通过 hypot 计算平方根。

另见 abs, conj, real。

示例

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

julia> sum(abs2, [1+2im, 3+4im])  # LinearAlgebra.norm(x)^2
30

copysign(x, y) -> z

返回 z，其大小与 x 相同，符号与 y 相同。

示例

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

如果 x==0，返回零，否则返回 $x/|x|$（即，对于实数 x，返回 ±1）。

另请参见 signbit，zero，copysign，flipsign。

示例

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

julia> sign(0 + im)
0.0 + 1.0im

signbit(x)

如果 x 的符号值为负，则返回 true，否则返回 false。

另请参见 sign 和 copysign。

示例

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

如果 y 为负，则返回 x 的符号翻转。例如 abs(x) = flipsign(x,x)。

示例

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

返回 $\sqrt{x}$。

对于负的 Real 参数会抛出 DomainError。请改用复数负参数。请注意，sqrt 在负实轴上有一个分支切割。

前缀运算符 √ 等同于 sqrt。

另请参见: hypot。

示例

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im 在分支切割下方
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

isqrt(n::Integer)

整数平方根：最大的整数 m，使得 m*m <= n。

julia> isqrt(5)
2

cbrt(x::Real)

返回 x 的立方根，即 $x^{1/3}$。接受负值（当 $x < 0$ 时返回负实根）。

前缀运算符 ∛ 等价于 cbrt。

示例

julia> cbrt(big(27))
3.0

julia> cbrt(big(-27))
-3.0

real(z)

返回复数 z 的实部。

另请参见：imag, reim, complex, isreal, Real。

示例

julia> real(1 + 3im)
1

real(T::Type)

返回表示类型 T 的值的实部的类型。例如：对于 T == Complex{R}，返回 R。等价于 typeof(real(zero(T)))。

示例

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

返回一个数组，包含数组 A 中每个条目的实部。

等价于 real.(A)，但当 eltype(A) <: Real 时，A 会被直接返回而不进行复制，并且当 A 具有零维时，返回一个0维数组（而不是标量）。

示例

julia> real([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 1
 0
 3

julia> real(fill(2 - im))
0-dimensional Array{Int64, 0}:
2

imag(z)

返回复数 z 的虚部。

另请参见：conj, reim, adjoint, angle。

示例

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

返回一个数组，包含数组 A 中每个条目的虚部。

等价于 imag.(A)，但当 A 具有零维时，返回一个0维数组（而不是标量）。

示例

julia> imag([1, 2im, 3 + 4im])
3-element Vector{Int64}:
 0
 2
 4

julia> imag(fill(2 - im))
0-dimensional Array{Int64, 0}:
-1

reim(z)

返回复数 z 的实部和虚部的元组。

示例

julia> reim(1 + 3im)
(1, 3)

reim(A::AbstractArray)

返回一个包含两个数组的元组，分别包含 A 中每个条目的实部和虚部。

等价于 (real.(A), imag.(A))，但当 eltype(A) <: Real 时，A 会在不复制的情况下返回以表示实部，并且当 A 具有零维时，返回一个0维数组（而不是标量）。

示例

julia> reim([1, 2im, 3 + 4im])
([1, 0, 3], [0, 2, 4])

julia> reim(fill(2 - im))
(fill(2), fill(-1))

conj(z)

计算复数 z 的共轭。

另见：angle, adjoint。

示例

julia> conj(1 + 3im)
1 - 3im

conj(A::AbstractArray)

返回一个数组，其中包含数组 A 中每个条目的复共轭。

等价于 conj.(A)，但当 eltype(A) <: Real 时，A 会在不复制的情况下返回，并且当 A 具有零维时，返回一个零维数组（而不是标量）。

示例

julia> conj([1, 2im, 3 + 4im])
3-element Vector{Complex{Int64}}:
 1 + 0im
 0 - 2im
 3 - 4im

julia> conj(fill(2 - im))
0-dimensional Array{Complex{Int64}, 0}:
2 + 1im

angle(z)

计算复数 z 的相位角（以弧度为单位）。

返回一个数字 -pi ≤ angle(z) ≤ pi，因此在负实轴上是不连续的。

另见: atan, cis, rad2deg.

示例

julia> rad2deg(angle(1 + im))
45.0

julia> rad2deg(angle(1 - im))
-45.0

julia> rad2deg(angle(-1 + 1e-20im))
180.0

julia> rad2deg(angle(-1 - 1e-20im))
-180.0

cis(x)

通过使用欧拉公式：$\cos(x) + i \sin(x) = \exp(i x)$，提供了比 exp(im*x) 更高效的方法。

另请参见 cispi, sincos, exp, angle。

示例

julia> cis(π) ≈ -1
true

cispi(x)

cis(pi*x) 的更精确方法（特别是对于较大的 x）。

另请参见 cis, sincospi, exp, angle。

示例

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.03055685464595456im

binomial(n::Integer, k::Integer)

二项式系数 $\binom{n}{k}$ 是多项式展开 $(1+x)^n$ 中第 $k$ 项的系数。

如果 $n$ 是非负的，那么它表示从 $n$ 个项目中选择 k 个的方式数：

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

其中 $n!$ 是 factorial 函数。

如果 $n$ 是负的，那么它根据以下恒等式定义：

\[\binom{n}{k} = (-1)^k \binom{k-n-1}{k}\]

另见 factorial。

示例

julia> binomial(5, 3)
10

julia> factorial(5) ÷ (factorial(5-3) * factorial(3))
10

julia> binomial(-5, 3)
-35

外部链接

• 二项式系数 在维基百科上。

binomial(x::Number, k::Integer)

广义二项式系数，对于 k ≥ 0 由多项式定义

\[\frac{1}{k!} \prod_{j=0}^{k-1} (x - j)\]

当 k < 0 时返回零。

对于整数 x 的情况，这等同于普通的整数二项式系数

\[\binom{n}{k} = \frac{n!}{k! (n-k)!}\]

对非整数 k 的进一步推广在数学上是可能的，但涉及伽马函数和/或贝塔函数，这些在Julia标准库中没有提供，但在外部包如 SpecialFunctions.jl 中可用。

外部链接

• 二项式系数 在维基百科上。

factorial(n::Integer)

n 的阶乘。如果 n 是一个 Integer，则阶乘作为整数计算（提升到至少 64 位）。请注意，如果 n 不小，这可能会导致溢出，但您可以使用 factorial(big(n)) 来以任意精度精确计算结果。

另见 binomial。

示例

julia> factorial(6)
720

julia> factorial(21)
ERROR: OverflowError: 21 is too large to look up in the table; consider using `factorial(big(21))` instead
Stacktrace:
[...]

julia> factorial(big(21))
51090942171709440000

外部链接

• Factorial 在维基百科上。

gcd(x, y...)

最大公约数（正数）（如果所有参数为零，则为零）。参数可以是整数和有理数。

示例

julia> gcd(6, 9)
3

julia> gcd(6, -9)
3

julia> gcd(6, 0)
6

julia> gcd(0, 0)
0

julia> gcd(1//3, 2//3)
1//3

julia> gcd(1//3, -2//3)
1//3

julia> gcd(1//3, 2)
1//3

julia> gcd(0, 0, 10, 15)
5

lcm(x, y...)

最小公倍数（正数）（如果任何参数为零，则为零）。参数可以是整数和有理数。

示例

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

julia> lcm(1//3, 2//3)
2//3

julia> lcm(1//3, -2//3)
2//3

julia> lcm(1//3, 2)
2//1

julia> lcm(1, 3, 5, 7)
105

gcdx(a, b)

计算 a 和 b 的最大公约数（正）及其贝祖系数，即满足 $ua+vb = d = gcd(a, b)$ 的整数系数 u 和 v。gcdx(a, b) 返回 $(d, u, v)$。

参数可以是整数和有理数。

示例

julia> gcdx(12, 42)
(6, -3, 1)

julia> gcdx(240, 46)
(2, -9, 47)

ispow2(n::Number) -> Bool

测试 n 是否为整数的二次幂。

另见 count_ones, prevpow, nextpow。

示例

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

最小的 a^n 不小于 x，其中 n 是非负整数。a 必须大于 1，x 必须大于 0。

另见 prevpow。

示例

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

不大于 x 的最大 a^n，其中 n 是非负整数。a 必须大于 1，x 必须不小于 1。

另请参见 nextpow，isqrt。

示例

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

nextprod(factors::Union{Tuple,AbstractVector}, n)

大于或等于 n 的下一个整数，可以表示为 $\prod k_i^{p_i}$，其中 $p_1$、$p_2$ 等为整数，$k_i$ 为 factors 中的因子。

示例

julia> nextprod((2, 3), 105)
108

julia> 2^2 * 3^3
108

invmod(n::Integer, m::Integer)

取 n 在模 m 下的逆：y 使得 $n y = 1 \pmod m$，并且 $div(y,m) = 0$。如果 $m = 0$，或者 $gcd(n,m) \neq 1$，则会抛出错误。

示例

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

invmod(n::Integer, T) where {T <: Base.BitInteger}
invmod(n::T) where {T <: Base.BitInteger}

计算类型为 T 的整数环中 n 的模逆，即模 2^N，其中 N = 8*sizeof(T)（例如，对于 Int32，N = 32）。换句话说，这些方法满足以下恒等式：

n * invmod(n) == 1
(n * invmod(n, T)) % T == 1
(n % T) * invmod(n, T) == 1

请注意，这里的 * 是整数环 T 中的模乘法。

将整数类型所隐含的模数作为显式值指定通常不方便，因为根据定义，模数太大而无法由该类型表示。

模逆的计算效率远高于一般情况，使用的算法在 https://arxiv.org/pdf/2204.04342.pdf 中进行了描述。

powermod(x::Integer, p::Integer, m)

计算 $x^p \pmod m$。

示例

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

ndigits(n::Integer; base::Integer=10, pad::Integer=1)

计算以 base 进制表示的整数 n 的位数（base 不能为 [-1, 0, 1]），可选地用零填充到指定大小（结果永远不会小于 pad）。

另见 digits, count_ones.

示例

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

julia> string(1022, base=16)
"3fe"

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

在 sum 中使用的归约运算符。与 + 的主要区别在于小整数会被提升为 Int/UInt。

widemul(x, y)

将 x 和 y 相乘，结果为更大的类型。

另见 promote, Base.add_sum.

示例

julia> widemul(Float32(3.0), 4.0) isa BigFloat
true

julia> typemax(Int8) * typemax(Int8)
1

julia> widemul(typemax(Int8), typemax(Int8))  # == 127^2
16129

evalpoly(x, p)

评估多项式 $\sum_k x^{k-1} p[k]$，其中系数为 p[1]、p[2] 等；也就是说，系数按 x 的幂的升序给出。如果系数的数量是静态已知的，即当 p 是一个 Tuple 时，循环将在编译时展开。该函数使用霍纳法则生成高效代码，如果 x 是实数，或者使用类似 Goertzel 的 ^[DK62] 算法，如果 x 是复数。

示例

julia> evalpoly(2, (1, 2, 3))
17

@evalpoly(z, c...)

计算多项式 $\sum_k z^{k-1} c[k]$，其中系数为 c[1]、c[2]，...；也就是说，系数按 z 的幂的升序给出。此宏扩展为高效的内联代码，使用霍纳法则，或者对于复数 z，使用更高效的类似 Goertzel 的算法。

另见 evalpoly。

示例

julia> @evalpoly(3, 1, 0, 1)
10

julia> @evalpoly(2, 1, 0, 1)
5

julia> @evalpoly(2, 1, 1, 1)
7

@fastmath expr

执行转换后的表达式，该表达式调用可能违反严格 IEEE 语义的函数。这允许以最快的方式进行操作，但结果是未定义的 – 在执行此操作时要小心，因为它可能会改变数值结果。

这设置了 LLVM Fast-Math flags，并对应于 clang 中的 -ffast-math 选项。有关更多详细信息，请参见 性能注释的说明。

示例

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672