数学

-(x)

一元减号运算符。

另请参阅：abs，flipsign。

示例

julia> -1
-1

julia> -(2)
-2

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

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

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

+(x, y...)

加法运算符。x+y+z+... 会调用此函数并传入所有参数，即 +(x, y, z, ...)。

示例

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

-(x, y)

减法运算符。

示例

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

乘法运算符。x*y*z*... 会调用此函数并传入所有参数，即 *(x, y, z, ...)。

示例

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

/(x, y)

右除运算符：x 乘以 y 的右逆。对于整数参数，会给出浮点数结果。

示例

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 是一个 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 为正。

示例

julia> 3^5
243

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A^3
2×2 Matrix{Int64}:
 37   54
 81  118

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

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

查找满足 x ≡ y (mod n) 的 y::T，其中 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

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π) 不完全相同，后者将计算 x 相对于浮点数 2π 的除法的模数。

示例

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，使得 mod(r, y) == mod(x, y)，对于正数 y，范围在 $(0, 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 结果。

示例

julia> 3 // 5
3//5

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

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。

有关返回类型的更多详细信息，请参阅扩展帮助。

示例

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 时

Base.OneTo(n)

Base.OneTo — 类型

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自动推导），由一个reference值、一个step和length参数化。默认情况下，ref是起始值r[1]，但也可以选择将其提供为某个其他索引1 <= offset <= len的r[offset]的值。语法a:b或a:b:c，其中a、b或c中的任何一个都是浮点数，会创建一个StepRangeLen。

==(x, y)

通用相等运算符。回退到===。对于所有具有相等概念的类型，都应基于实例表示的抽象值实现此运算符。例如，所有数值类型都按数值进行比较，忽略类型。字符串作为字符序列进行比较，忽略编码。对于集合，==通常会递归地调用其所有内容，尽管也可能会考虑其他属性（例如数组的形状）。

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

结果类型为Bool，除非其中一个操作数为missing，在这种情况下，返回missing（三值逻辑）。对于集合，如果至少一个操作数包含missing值且所有非missing值都相等，则返回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)

分别根据x是否小于、等于或大于y返回-1、0或1。第一个参数指定要使用的小于比较函数。

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 中使用制表符补全\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 中使用制表符补全\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 中使用制表符补全\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

短路布尔 AND。

另请参阅&、三元运算符? :以及关于控制流的手册部分。

示例

julia> x = 3;

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

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

x || y

短路布尔 OR。

另请参阅：|、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])

不精确相等比较。如果两个数字的相对距离或绝对距离在容差范围内，则它们比较相等：如果norm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))，则isapprox返回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 是以米为单位的氢原子半径，则 atol=1e-9 是一个荒谬的大容差。

示例

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 以弧度为单位，返回一个元组 (sine, cosine)。

另请参见 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)$，其精度高于 sin(pi*x)，尤其是在 x 较大时。

另请参见 sind、cospi、sincospi。

cospi(x)

计算 $\cos(\pi x)$，其精度高于 cos(pi*x)，尤其是在 x 较大时。

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)  # Here 3f0 isa 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 的反正割值，输出结果以弧度为单位。

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)

如果 $x \neq 0$，则计算 $\sin(\pi x) / (\pi x)$；如果 $x = 0$，则计算 $1$。

另请参见 cosc，其导数。

cosc(x)

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

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 在以下文章中描述的算法：An Improved Algorithm for hypot(a,b)。文章可在 arXiv 上在线获取，链接为 https://arxiv.org/abs/1904.09481

hypot(x...)

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

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

示例

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2 overflows
ERROR: DomainError with -2.914184810805068e18:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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。使用复数负参数以获得复数结果。

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

示例

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

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 was called with a negative real argument but will only return a complex result if called with a complex argument. Try log(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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 was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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 was called with a negative real argument but will only return a complex result if called with a complex argument. Try 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)
ERROR: DomainError with -2.0:
log1p was called with a real argument < -1 but will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

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

示例

julia> frexp(12.8)
(0.8, 4)

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$。

示例

julia> ldexp(5., 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$。它避免了在 x 值较小时直接计算 exp(x)-1 所涉及的精度损失。

示例

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）。

示例

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> 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 行为）。

RoundToZero

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

RoundFromZero

远离零舍入。

示例

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

RoundUp

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

RoundDown

使用此舍入模式的 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，如果该值不能表示，则抛出InexactError。

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

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

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

floor(T, x)将结果转换为类型T，如果该值不能表示，则抛出InexactError。

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

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

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

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

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

另请参阅：%、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）。另请参阅 minimum 函数，以从集合中获取最小元素。

示例

julia> min(2, 5, 1)
1

max(x, y, ...)

返回参数的最大值（相对于 isless）。另请参阅 maximum 函数，以从集合中获取最大元素。

示例

julia> max(2, 5, 1)
5

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)  # an example where 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])  # overflow at typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

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.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。

另请参阅：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> .√(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 具有零维时返回一个 0 维数组（而不是标量）。

示例

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 的相位角（以弧度为单位）。

另请参阅：atan、cis。

示例

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

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

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

cis(x)

通过使用欧拉公式更有效地计算 exp(im*x)：$cos(x) + i sin(x) = \exp(i 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

外部链接

• 维基百科上的阶乘。

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 是否为 2 的整数幂。

另请参阅 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)

不小于 x 的最小 a^n，其中 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$ 等是整数，对于 factors 中的因子 $k_i$ 而言。

示例

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

julia> 2^2 * 3^3
108

invmod(n, m)

取 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

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)

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

示例

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

@evalpoly(z, c...)

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

另请参阅 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 快速数学标志，并对应于 clang 中的 -ffast-math 选项。有关更多详细信息，请参阅 有关性能注释的说明。

示例

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672