Engee 文档

数学对象

数学运算符

# *'基。:-'`-Method</no-翻译>

-(x)

一元减运算符。

另请参阅说明 'abs', 'flipsign'。

例子

julia> -1
-1

julia> -(2)
-2

julia> -[1 2; 3 4]
2×2 Matrix{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

# *'基。:-'`-Method</no-翻译>

-(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`开头的变量）被禁止，因为它与无符号整数的字面量冲突：`0x01isa 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`的倒数。

返回整数参数的浮点结果。 请参阅描述 ÷'用于整数除法或 '`’类型的结果 '理性。

例子

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'）字面量（例如，表达式+x2+中的`2`或+x-3+中的-3`），则Julia代码中的表达式`x^y由编译器转换为'Base。literal_pow(^,x,Val(y))`允许在编译时对指数值进行特化。 （默认备份选项是'Base。literal_pow（^，x，Val（y））=^（x，y），其中，作为一项规则’^==基数。^，除非在调用的命名空间中指定了'^'。）如果’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#整数溢出
错误

julia>大(10)^19==1e19
真的
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`的值可以更小或标量。

兼容性：Julia1.6

这些方法需要至少1.6的Julia版本。

例子

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
兼容性：Julia1.2

对于’inv(::Missing)`需要至少1.2的Julia版本。

 
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’舍入为整数。 换句话说，价值

round(x / y, r)

没有任何中间舍入。

兼容性：Julia1.4

有三个参数接受’RoundingMode’的方法需要至少1.4的Julia版本。

另请参阅说明 'fld'和 'cld'，此函数的特殊情况。

兼容性：Julia1.9

RoundFromZero需要至少1.9的Julia版本。

例子:

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'，这样 ，其中’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
兼容性：Julia1.3

此方法需要1.3或更高版本的Julia。

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

"X"除以"y"的整数的余数，相当于"x"除以"y"的余数，结果向下取整，即"x-y*fld(x,y)"在没有中间舍入的情况下计算。

结果的符号将等于符号’y`，其绝对值将小于’abs（y）`（除了一些例外，请参阅下面的注释）。

使用浮点值时，可能无法使用此类型来表示准确的结果，因此可能会出现舍入错误。 特别是，如果确切的结果非常接近`y`，则可以将其四舍五入为`y'。

另请参阅说明 'rem', 'div', 'fld', 'mod1', 'invmod'。

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia>国防部(8.9,3)
2.9000000000000004

julia>mod（eps（），3）
2.220446049250313e-16缧

julia>mod（-eps（），3）
3.0

julia>国防部.(-5:5, 3)'
1×11adjoint(::向量{Int64}）与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]$. 另请参阅说明 '最圆的'。

  • 使用’r==RoundToZero'（默认），结果将是准确的，并且在$[0的范围内,

    y

    )$带正`x’或$(-

    y

    ,0]$否则。 另请参阅说明 'RoundToZero`。

  • 使用’r==RoundDown'，结果将在范围内 用一个积极的’y’或 ]否则。 如果`x`和`y`具有不同的符号，并且`abs(x)<abs(y)'，则结果可能不准确。 另请参阅说明 'RoundDown'。

  • 使用’r==RoundUp'，结果将在范围内 ]用一个积极的’y’或 否则。 如果`x`和`y`具有相同的符号，并且`abs(x)<abs(y)'，则结果可能不准确。 另请参阅说明 '综述`。

  • 使用’r==RoundFromZero`，结果将在范围内 ]用一个积极的’y’或 否则。 如果`x`和`y`具有相同的符号，并且`abs(x)<abs(y)'，则结果可能不准确。 另请参阅说明 'RoundFromZero'。

兼容性：Julia1.9

RoundFromZero需要至少1.9的Julia版本。

例子:

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`，结果将在范围内 ]. 作为一项规则，这将是最准确的结果。 另请参阅说明 '最圆的'。

  • 使用’r==RoundToZero`，结果将在范围内 ]带有正’x’或 ]否则。 另请参阅说明 'RoundToZero`。

  • 使用’r==RoundDown'，结果将在范围内 ]. 另请参阅说明 'RoundDown'。

  • 使用’r==RoundUp'，结果将在范围内 ]. 另请参阅说明 '综述`。

例子

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

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

整数除以`2π’的余数，在范围内返回 .

此函数将结果计算为浮点数，该浮点数表示整数除以数值精确值`2π’的余数。 因此，它不完全匹配函数`mod(x,2π)`，该函数计算`x`的整数除以值`2π`的余数，用浮点数表示。

根据输入值的格式，2π的最接近的可表示值可能小于2π。 例如，表达式’mod2pi(2π)'不会返回'0`，因为中间值`2*π`类型为`Float64`，并且`2*Float64(π)<2*big(π)'。 请参阅功能说明 'rem2pi'，它允许您更精确地控制此行为。

例子

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’和在范围内 为负’y'。

使用整数参数和正值’y`，这等于’mod(x,1:y)`，这自然适用于以one开头的索引。 另一方面，'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)

两个整数或有理数的除法，给出如下结果 '理性`。 更一般地，`//`可用于具有整数或有理分量的其他数字类型的精确有理除法，例如具有整数分量的复数。

请注意，参数是浮点（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 时，结果为向左移位 n 位并用零（0）补零的 x。这等同于 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 时，结果为将元素向后移位 n 个位置并用 false 填充空位后的 B。若 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’的值是负数，它会向右移动。

兼容性：Julia1.5

此功能需要1.5或更高的Julia版本。

另请参阅说明 <<, '循环换档', '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`括在引号中，返回抽象语法树(AST)expr'。 AST可以具有类型`Expr，`Symbol`或文字值。 语法':identifier’的结果是一个`符号'。

另请参阅说明 'Expr', '符号', '元。解析`

例子

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('start`)、step(step)、end(stop)和length(`length')。 可接受的数组调用:

  • 使用"start"，"step"，"stop"，"length"中的任意三个参数调用"range"。

  • 使用两个参数"start"，"stop"，"length"调用"range"。 在这种情况下，`步骤’被假定为一个。 如果两个参数都是整数，则返回 'UnitRange'。

  • 用一个"停止"或"长度"参数调用"范围"。 参数"start"和"step"假定为一个。

有关返回类型的详细信息，请参阅扩展帮助。 另外，请参阅功能说明。 '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>范围(1,10,长度=101)
1.0:0.09:10.0

julia>范围(1,100,步=5)
1:5:96

julia>范围（停止=10，长度=5）
6:10

julia>范围（停止=10，步骤=1，长度=5）
6:1:10

julia>范围（开始=1，步骤=1，停止=10）
1:1:10

julia>范围（;长度=10）
基地。OneTo(10)

julia>范围(;停止=6)
基地。OneTo(6)

julia>范围(;停止=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`。

兼容性：Julia1.1

要使用`stop’作为位置参数，需要至少1.1的Julia版本。
兼容性：Julia1.7

没有命名参数和具有命名’start’参数的版本需要Julia至少1.7的版本。
兼容性：Julia1.8

具有单个命名参数"stop"或"length"的版本需要至少1.8的Julia版本。

高级帮助

'Range’函数输出’Base。当参数是整数和:

  • 仅指定’length’参数;

  • 只指定"停止"参数。

当参数为整数和:

  • 只指定"开始"和"停止";

  • 只指定"长度"和"停止"。

如果指定了’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'。

兼容性：Julia1.7

第4个类型参数’L’需要至少1.7的Julia版本。

 
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'用于具有线性间隔的点。

兼容性：Julia1.11

此功能要求Julia的版本不低于1.11。

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

范围，其元素位于`开始`和`停止’之间的对数间隔，并且间隔由参数`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`是不允许的。 使用，例如，`圆。(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]
兼容性：Julia1.11

这种类型要求Julia版本不低于1.11。

 
==(x, y)

通用相等运算符。 它用作备份选项 ===. 它应该应用于所有具有相等概念的类型，基于实例表示的抽象值。 例如，所有数值类型都按数值进行比较，而不考虑类型。 字符串作为字符序列进行比较，而不考虑编码。 相同类型的集合通常通过一组键进行比较，如果它们相等（==），则比较每个键的值。 如果所有这些对都相等（`=='），则返回值true。 通常不考虑其他属性（例如精确类型）。

运算符遵循浮点数的IEEE语义’0.0==-0.0’和’NaN！=南'。

结果是`Bool’类型，除非缺少其中一个操作数（missing')，然后返回值’missing'(https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]）。 集合通常实现三元逻辑，如 'all'：如果任何操作数包含缺失值，并且所有其他对都相等，则返回缺失值。 要始终获得’Bool’类型的结果，请使用 '等效或 ===.

实施

新的数值类型应该具有此函数的实现，以比较新类型的两个参数，并与其他类型进行比较，如果可能的话，应用提升规则。

`=='运算符用作备份选项 'isequal'，所以新的'=='方法将用于比较键，如 'Dict'。 如果你的类型要用作字典键，它也应该有一个实现。 '哈希'。

如果为类型定义了'==, 'isequal'和 'isless，它也必须有一个实现 '<'用于比较的一致性。

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

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

实施

通常，新类型不需要此运算符的实现，因为它们使用备份定义`！=（x，y）=！(x==y)`。

例子

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false
!=(x)

创建一个函数，其参数通过"x"进行比较 !='，即相当于+y→y的函数！=x+'。 返回的函数类型为"Base"。修正2{typeof(!=)}`并可用于实施专门的方法。

兼容性：Julia1.2

此功能需要至少1.2的Julia版本。

 
!==(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"。修正2{typeof(<)}`并可用于实施专门的方法。

兼容性：Julia1.2

此功能需要至少1.2的Julia版本。

 
<=(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。修正2{typeof(<=)}'并可用于实施专门的方法。

兼容性：Julia1.2

此功能需要至少1.2的Julia版本。

 
>(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"。修正2{typeof(>)}`并可用于实施专门的方法。

兼容性：Julia1.2

此功能需要至少1.2的Julia版本。

 
>=(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"。修正2{typeof(>=)}`并可用于实施专门的方法。

兼容性：Julia1.2

此功能需要至少1.2的Julia版本。

 
cmp(x,y)

返回—​1、0或1，具体取决于`x`的值是否相应地小于、等于或大于`y'。 使用’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

按位"和"。 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，返回 'missing'如果其中一个操作数缺失（missing）而另一个为true（true）。 使用括号应用函数形式：(&)(x,y)。

另请参阅说明 |, '异或', &&.

例子

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false
x | y

按位"或"。 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，返回 'missing'如果其中一个操作数缺失（missing）而另一个为true（false）。

另请参阅说明 &, '异或', ||.

例子

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing
xor(x, y)
⊻(x, y)

位"独占或"为`x`和`y`。 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，返回 'missing'，如果其中一个参数缺失（'missing`）。

中缀操作’a⊻b`与`xor(a,b)同义，您可以在REPL Julia中的\xor`或`\veebar`的TAB键上使用自动完成键入`⊻`。

例子

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)

位"而不是"（nand）为`x`和`y`。 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，返回 'missing'，如果其中一个参数缺失（'missing`）。

中缀操作’a⊼b`与`nand(a,b)同义，您可以在REPL Julia中的\nand`或`\barwedge`的TAB键上使用自动完成键入`⊼`。

例子

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)

位"或不"（nor）为`x`和`y`。 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，返回 'missing'，如果其中一个参数丢失（missing）而另一个不是（true）。

中缀操作’a⊽b`与`nor(a,b)同义，您可以在REPL Julia中的\nor`或`\barvee`的TAB键上使用自动完成键入`⊽`。

例子

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)

逻辑上的"不"。 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑]，返回 missing'如果`x’缺失（'missing）。

另请参阅位"不"的描述: .

例子

julia> !true
false

julia> !false
true

julia>！失踪
失踪

julia>.![真假真]
1×3比特矩阵:
 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: |-| <  ⇒ |()-()| < "
兼容性：Julia1.9

从Julia1.9开始，`！f’返回 'ComposedFunction'而不是匿名函数。

 
x && y

根据缩写方案计算的逻辑"和"。

请参阅 '&'，三元运算符'？ :'和手册的部分关于 执行顺序。

例子

julia> x = 3;

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

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

根据缩写方案计算的逻辑"或"。

另请参阅说明 |, '异或', &&.

例子

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’返回’true`if'norm(x-y)<=max(atol,rtol*max(norm(x),norm(y))'。 Atol'（绝对错误）的默认值为零，`rtol（相对错误）的默认值取决于类型`x`和`y'。 命名参数’nans’确定是否将NaN值视为相等（默认情况下为false，即否）。

对于实浮点值或复数浮点值，除非指定’atol>0`，否则`rtol’的默认值是 `eps'类型为’x’或’y'，取决于哪一个更大（精度最低）。 在这种情况下，大约一半的有效字符必须相等。 否则，例如，对于整数参数或指定’atol>0`时，`rtol’的默认值将为零。

命名参数"norm"默认为数值"(x,y)"或"LinearAlgebra"的"abs"。norm’用于数组（有时选择不同的`norm`是有意义的）。 当’x’和’y’是数组时，如果值是`norm(x-y)如果`x`不是有限的（即，±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`将非常小https://en.wikipedia.org/wiki/Earth_radius [地球半径]以米为单位，或者如果`x`是荒谬的大https://en.wikipedia.org/wiki/Bohr_radius [氢原子的半径]以米为单位。

兼容性：Julia1.6

要在比较数字参数（而不是数组）时传递命名的"norm"参数，需要至少1.6的Julia版本。

例子

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]) # использование `norm`
true
isapprox(x; kwargs...) / ≈(x; kwargs...)

创建一个函数，其参数通过`≈与`x’进行比较，即相当于+y→y≈x+`的函数。

支持与双参数函数"isapprox"中相同的命名参数。

兼容性：Julia1.5

此方法需要1.5或更高版本的Julia。

 
sin(x)

计算’x’的正弦，其中`x`的值以弧度给出。

另请参阅说明 '信德', '辛皮', '辛科斯', '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>辛皮(1/4)
0.7071067811865475

julia>圆.（sincos（pi/6），数字=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’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
cosd(x)

计算`x’的余弦，其中`x`的值以度为单位设置。 如果’x’是矩阵，那么矩阵’x’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
tand(x)

计算`x’的切线，其中’x’的值以度为单位设置。 如果’x’是矩阵，那么矩阵’x’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
sincosd(x)

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

兼容性：Julia1.3

此功能需要1.3或更高版本的Julia。

 
sinpi(x)

计算方法 具有比`sin(pi*x)'更高的精度，特别是对于`x’的大值。

另请参阅说明 '信德', `cospi'和 'sincospi'。

cospi(x)

计算方法 具有比`cos(pi*x)'更高的精度，特别是对于`x’的大值。

tanpi(x)

计算方法 具有比`tan(pi*x)'更高的精度，特别是对于`x’的大值。

兼容性：Julia1.10

此功能需要Julia至少1.10的版本。

另请参阅说明 'tand', '辛皮', `cospi'和 'sincospi'。

sincospi(x)

同时计算 'sinpi(x)'及 'cospi（x）（'π*x’的正弦和余弦，其中’x’的值以弧度给出）并返回元组（正弦，余弦）`。

兼容性：Julia1.6

此功能需要至少1.6的Julia版本。

另请参阅说明 '西斯皮', '辛科斯德', '辛皮'。

sinh(x)

计算’x’的双曲正弦。

cosh(x)

计算`x’的双曲余弦。

tanh(x)

计算’x’的双曲正切。

另请参阅说明 '谭'和 '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`的arcsin。

另外，请参阅功能说明。 '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`的arccosine。

atan(y)
atan(y, x)

分别计算反正切`y’或’y/x'。

如果有一个真正的参数，它将是_x_轴的正方向和点（1，y）之间的弧度角。 返回值将在范围内 ].

如果有两个参数，这将是_x_轴的正方向和点（x，y）之间的弧度角。 返回值将在范围内 ]. 这对应于标准功能https://en.wikipedia.org/wiki/Atan2 ['atan2']。 注意，根据标准’atan(0.0,x)'被定义为 ，和’atan(-0.0,x)'--as 为’x<0'。

另请参阅说明 `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’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
acosd(x)

计算`x`的arccosine，输出值以度为单位。 如果’x’是矩阵，那么矩阵’x’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
atand(y)
atand(y,x)

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

兼容性：Julia1.7

单参数方法支持方阵作为从Julia1.7版本开始的参数。

 
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)

计算输出值以弧度为单位的arcsecond`x'。

acsc(x)

计算输出值以弧度为单位的`x`的反正秒。

acot(x)

计算以弧度为单位的输出值的反正切`x'。

asecd(x)

计算以度为单位的输出值的arcsecond`x'。 如果’x’是矩阵，那么矩阵’x’必须是正方形。

兼容性：Julia1.7

矩阵参数需要至少1.7的Julia版本。

 
acscd(x)

计算以度为单位的输出值的arcsecond`x'。 如果’x’是矩阵，那么矩阵’x’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
acotd(x)

计算以度为单位的输出值的反正切`x'。 如果’x’是矩阵，那么矩阵’x’必须是正方形。

兼容性：Julia1.7

矩阵参数要求Julia版本至少为1.7。

 
sech(x)

计算双曲线第二个’x'。

csch(x)

计算`x’的双曲线余弦。

coth(x)

计算`x’的双曲余切。

asinh(x)

计算’x’的双曲弧。

acosh(x)

计算`x’的双曲arccosine。

atanh(x)

计算双曲反正切`x'。

asech(x)

计算双曲arcsecond’x'。

acsch(x)

计算双曲arcsecond’x'。

acoth(x)

计算双曲线反正切`x`。

sinc(x)

计算归一化sinc函数 由 和 由 .

另请参阅此函数的导数 'cosc'。

cosc(x)

计算方法 由 和 由 . 这是函数`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)

计算斜边 ，避免溢出而超出下限。

此代码实现了文章A Improved Algorithm for`hypot(a,b)`（hypot(a,b)的改进算法）Carlos F.Borges中的算法。 这篇文章可以在arXiv门户网站上找到https://arxiv.org/abs/1904.09481 …​

hypot(x...)

计算斜边 ，避免溢出而超出下限。

另请参阅标准库中的’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 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’的自然对数。

返回错误 'DomainError'类型的负参数 '真实`。 使用复杂的参数来获得复杂的结果。 它在负实轴上有一个分支点，因此假设'-0.0im’位于轴下方。

另请参阅说明 ℯ, '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(-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)

根据`b`计算`x`的对数。 返回错误 '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
[...]

如果`b’是2或10的幂，则应使用 'log2'或 'log10'，因为这些功能通常会更快，更准确。 例子：:

julia>日志(100,100000)
2.9999999999999996
julia>log10(1000000)/2 3.0
 
log2(x)

计算`x`到底2的对数。 投掷物 `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)

根据10计算`x’的对数。 返回错误 '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'。 返回错误 'DomainError'类型的参数 `Real'值小于—​1。

例子

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’的绝对值在范围内 或等于零，而’val’等于 .

另请参阅说明 '意义', '指数'和 '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’的指数，即 ℯ .

另请参阅说明 'exp2`, 'exp10'和 'cis'。

例子

julia> exp(1.0)
2.718281828459045

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

计算2`x’的指数，即 .

另请参阅说明 'ldexp'和 <<.

例子

julia> exp2(5)
32.0

julia> 2^5
32

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

计算10到`x’的指数，即 .

例子

julia> exp10(2)
100.0

julia> 10^2
100
ldexp(x, n)

计算方法 .

另请参阅说明 'frexp'和 '指数'。

例子

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)

精确计算 . 这避免了直接为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`的值，如果未指定`T`，则返回与’x’相同的类型。 返回错误 'InexactError'，如果不可能用类型`T’表示值，类似于函数 '转换'。

如果指定了命名参数"digits"，则基于"base"执行舍入到指定的小数位数（如果参数值为负数，则舍入到小数点）。

如果指定了命名参数’sigdigits`，则执行基于’base’的舍入到指定的有效位数。

舍入方向由参数设置 'RoundingMode'`r'。 默认情况下，使用舍入到最接近的整数。 'RoundNearest'，其中0.5的小数值四舍五入为最接近的偶数整数。 请注意，如果更改全局舍入模式，"舍入"可能会产生不正确的结果（请参阅 '四舍五入'）。

舍入到浮点类型是对由该类型（和Inf）表示的整数执行的，而不是对真整数执行的。 当确定最近的值时，Inf被认为是一个大于`floatmax(T)`的最小精度单位(ulp)的值，类似地 '转换'。

例子

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)

使用二进制浮点数时，基于2以外的基数舍入到指定位数可能不准确。 例如，像这样的值 Float64，由数字'1.15’表示，实际上是_1.15，但它将四舍五入为1.2。 例如:

julia>x=1.15
1.15
julia>大(1.15)1.14999999999999999911182158029987476766109466552734375

julia>x<115//100真

julia>round(x,digits=1)1.2

扩展

要将`round’扩展到新的数字类型，通常定义`Base就足够了。round(x::NewType,r::RoundingMode)'。

RoundingMode

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

目前支持的舍入模式有:

兼容性：Julia1.9

'RoundFromZero’至少需要Julia1.9。 以前的版本仅支持"BigFloat"的"RoundFromZero"。

 
RoundNearest

默认舍入模式。 四舍五入到最接近的整数，而ties（0.5的小数值）被四舍五入到最接近的偶数整数。

RoundNearestTiesAway

四舍五入到最接近的整数，并与零四舍五入（C/C++ 数学对象#Base.round行为）。

RoundNearestTiesUp

舍入到最接近的整数，关系舍入到正无穷大（Java/JavaScript） 数学对象#Base.round行为）。

RoundToZero

`round'使用此舍入模式是 'trunc'。

RoundFromZero

从零开始。

兼容性：Julia1.9

'RoundFromZero’至少需要Julia1.9。 以前的版本仅支持"BigFloat"的"RoundFromZero"。

例子

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

在这种舍入模式 'round'是一个别名 'ceil'。

RoundDown

在这种舍入模式 'round'是一个别名 '地板'。

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'用于0.5的小数值。 第一个 '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’的作用方式与for相同 '圆'。

对于支持`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’的作用方式与for相同 '圆'。

对于支持`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’的作用方式与for相同 '圆'。

对于支持`trunk`的新类型，请定义`Base。round(x::NewType,::RoundingMode{:ToZero})`.

另请参阅说明 %, '地板`, '未签名`, '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>最大(5,失踪,6)
失踪
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’时。 参数被提升为通用类型。

另请参阅说明 '夹！, 'min和 'max'。

兼容性：Julia1.3

要使用’missing’作为第一个参数，需要至少1.3的Julia版本。

例子

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’范围内。

兼容性：Julia1.6

此方法需要至少1.6的Julia版本。

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

将"数组"数组的每个值都带到指定的范围内。 另请参阅说明 '钳'。

兼容性：Julia1.3

要使用"数组"中的"缺失"元素，需要至少1.3的Julia版本。

例子

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`, '未签名`, '标志'。

例子

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'和 '真实`。

例子

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`的值，用符号`y`模`x'。

例子

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1
sign(x)

如果’x==0’返回零，否则返回$x/

x

△（即实`x’的±1）。

另请参阅说明 '标志', '零`, `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)

申报表 .

返回错误 '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’的立方根，即 . 它也接受负值（返回负实根时 ).

前缀运算符'∛'等同于’cbrt'。

例子

julia> cbrt(big(27))
3.0

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

返回复数`z`的实部。

另请参阅说明 'imag', 'reim', '复杂', 'isreal', '真实`。

例子

julia> real(1 + 3im)
1
real(T::Type)

返回表示类型`T’值的实部的类型。 例如，对于'T==复数{R}'返回’R'。 相当于’typeof(real(zero(T)))'。

例子

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64
real(A::AbstractArray)

返回包含数组`A’中每个元素的实部的数组。

相当于’真实的。(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', '角度'。

例子

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’每个元素的实部和虚部。

相当于`（真实。（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’的共轭复数。

另请参阅说明 '角度', '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’的相位角。

返回数字'-pi≤角度(z)≤pi',因此,沿负实轴是不连续的.

另请参阅说明 '阿坦', '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)

使用欧拉公式`exp(im*x)'的更有效方法: .

另请参阅说明 'cispi', '辛科斯', 'exp'和 '角度'。

例子

julia> cis(π) ≈ -1
true
cispi(x)

更准确的方法是用于’cis(pi*x)'（特别是对于`x’的大值）。

另请参阅说明 'cis', 'sincospi`, 'exp'和 '角度'。

例子

julia> cispi(10000)
1.0 + 0.0im

julia> cispi(0.25 + 1im)
0.030556854645954562 + 0.03055685464595456im
兼容性：Julia1.6

此功能需要至少1.6的Julia版本。

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

多项式系数 ，表示系数 -分解中的第一个成员 通过多项式。

如果值为 非负，该系数显示了从`n`的集合中选择`k`元素的可能方式:

哪里 --这是一个功能 '阶乘'。

如果值为 如果为负，则将系数定义为身份

另请参阅说明 '阶乘'。

例子

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’定义的广义二项式系数

当’k<0’返回零。

对于整数’x’相当于通常的整数二项式系数

对于非整数’k’的进一步概括在数学上是可能的，但包括gamma函数和/或beta函数，它们不是由Julia标准库提供的，但可以在外部软件包中使用，例如https://github.com/JuliaMath/SpecialFunctions.jl [特殊功能。jl]。

外部链接

factorial(n::Integer)

阶乘是’n'。 如果’n’的值是整数（'Integer'），阶乘被计算为整数（前进到至少64位）。 请注意，对于`n’的大值，溢出是可能的，但您可以使用`factorial(big(n))`以任意精度精确计算结果。

另请参阅说明 '二项式`。

例子

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

最大的公共（正）除数（如果所有参数都为零，则为零）。 参数可以是整数或有理数。

兼容性：Julia1.4

Rational arguments需要至少1.4的Julia版本。

例子

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

最小的公共（正）倍数（如果其中一个参数为零，则为零）。 参数可以是整数或有理数。

兼容性：Julia1.4

Rational arguments需要至少1.4的Julia版本。

例子

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`的最大公（正）除数，以及它们的Bezoux系数，即满足条件的整数系数’u’和’v` . 申报表 .

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

兼容性：Julia1.4

Rational arguments需要至少1.4的Julia版本。

例子

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

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

贝祖系数不是唯一可能的。 Gcdx函数返回使用扩展欧几里德算法计算的最小Bezoux系数（参见Knut D.the art of programming. 艾迪 2. 第325页。 算法X)。 对于有符号整数，这些系数’u’和’v’在这个意义上是最小的 和 . 此外，符号’u’和’v`被选择为使得`d’的值为正。 对于无符号整数，系数’u’和’v’可以具有接近其`typemax`的值，然后只有对这些无符号整数进行模算术时，身份才为真。

 
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
兼容性：Julia1.6

Julia1.6中增加了对"Integer"以外的参数的支持。

 
nextpow(a, x)

`A^n`至少为`x’的最小值，其中`n`为非负整数。 'A’的值必须大于一，`x’必须大于零。

另请参阅说明 'prevpow'。

例子

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16
prevpow(a, x)

最大值为`a^n'，不大于’x`，其中`n’为非负整数。 'A’的值必须大于一，并且’x’必须至少为一。

另请参阅说明 '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`的整数，可以写成 对于整数 , 以此类推的乘数 在’因素'。

例子

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

julia> 2^2 * 3^3
108
兼容性：Julia1.6

元组接受方法需要至少1.6的Julia版本。

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

取`n`模`m`，`y’的倒数，使 和 . 返回错误，如果 或 .

例子

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 …​

兼容性：Julia1.11

方法’invmod`n)`和`invmod(n,T)'要求Julia的版本不低于1.11。

 
powermod(x::Integer, p::Integer, 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）分配给给定的大小（结果永远不会小于`pad）。

另请参阅说明 '数字'和 '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`，产生具有较大类型的结果。

另请参阅说明 '促进'和 '基地。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]'，。..;按`x’度升序指定。 如果系数的数量是静态已知的，即当`p`是元组（Tuple）时，则在编译时展开循环。 该函数使用Horner方法为`x`的真实值或类似于Herzel算法的算法创建高效代码[Donald Knuth. 编程的艺术。 第2卷。 半数值算法。 第4.6.4节。]，如果’x`的值是复数。

兼容性：Julia1.4

此功能需要至少1.4的Julia版本。

例子

julia> evalpoly(2, (1, 2, 3))
17
@evalpoly(z, c...)

计算多项式 ]与系数’c[1]'’c[2]'，。..;按`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语义的函数。 这确保了尽可能快的操作，但结果是不确定的。 请谨慎使用，因为可以更改数值结果。

宏集https://llvm.org/docs/LangRef.html#fast-math-flags [LLVM的Fast-Math flags]并且对应于clang中的`-ffast-math’参数。 有关详细信息，请参阅 性能说明。

例子

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672

可配置二进制运算符

一些Unicode字符可用于定义支持中缀表示法的新二进制运算符。 例如，'⊗(x,y)=k(x,y)将函数⊗(otimes)定义为Kronecker乘积，并且可以使用中缀语法将其作为二进制运算符调用：`C=A⊗B，以及通常的前缀语法`C=⊗(A,B)'。

支持此类扩展的其他字符包括\odot'⊙'和\oplus`⊕'。

完整列表在分析器代码中：https://github.com/JuliaLang/julia/blob/master/src/julia-parser.scm

对那些被分析为`*` ( 在优先级方面），包括`* / ÷ % & ⋅ ∘ × |\| ∩ ∧ ⊗ ⊘ ⊙ ⊚ ⊛ ⊠ ⊡ ⊓ ∗ ∙ ∤ ⅋ ≀ ⊼ ⋄ ⋆ ⋇ ⋉ ⋊ ⋋ ⋌ ⋏ ⋒ ⟑ ⦸ ⦼ ⦾ ⦿ ⧶ ⧷ ⨇ ⨰ ⨱ ⨲ ⨳ ⨴ ⨵ ⨶ ⨷ ⨸ ⨻ ⨼ ⨽ ⩀ ⩃ ⩄ ⩋ ⩍ ⩎ ⩑ ⩓ ⩕ ⩘ ⩚ ⩜ ⩞ ⩟ ⩠ ⫛ ⊍ ▷ ⨝ ⟕ ⟖ ⟗`, 而那些被分析为''的包括'pass：c'。[ - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⟇ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣]' 还有许多其他与箭头，比较和度有关的内容。