数学

数学运算符

# *`基地。:-`*-Method

-(x)

一元减运算符。

请参阅: 腹肌, flipsign,flipsign.

*例子*

julia> -1
-1

julia> -(2)
-2

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

julia> -(true)  # promotes to Int
-1

julia> -(0x003)
0xfffd

# *`基地。:+`*-函数

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

添加一个 日期 用一个 时间 产生一个 日期时间. 小时、分钟、秒和毫秒部分 时间 与……的年、月、日一起使用。 日期 创建新的 日期时间. 非零微秒或纳秒在 时间 类型将导致 N.恐怖,恐怖 被扔了。

+(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

-(x, y)

减法运算符。

*例子*

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

# *`基地。:*`*-Method

&ast;(x, y...)

乘法运算符。

中缀 x&ast;y&ast;z&ast;。.. 使用所有参数调用此函数，即 &ast;（x，y，z，。..)，默认情况下，然后调用 (x&ast;y)&ast;z&ast;。.. 从左边开始。

并置如 2pi 还调用 *(2,pi). 请注意，此操作的优先级高于文字 *. 还要注意，并置"0x…"(整数0乘以变量名开头的变量 x）被禁止，因为它与无符号整数字面量冲突: 0x01isa UInt8.

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

*例子*

julia> 2 &ast; 7 &ast; 8
112

julia> &ast;(2, 7, 8)
112

julia> [2 0; 0 3] &ast; [1, 10]  # matrix &ast; vector
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2&ast;pi  # juxtaposition has higher precedence
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # adjoint vector &ast; vector
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];

朱莉娅>X=A/B
2×3矩阵{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

朱莉娅>isapprox（A，X&ast;B）
真的

julia>isapprox（X，A&ast;pinv（B））
真的

# *`基地。:\`*-Method

\(x, y)

左除法运算符：乘法 y 通过逆 x 在左边。给出整数参数的浮点结果。

*例子*

julia> 3 \ 6
2.0

julia> inv(3) &ast; 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) &ast; x
2-element Vector{Float64}:
  6.5
 -7.0

# *`基地。:^`*-Method

^(x, y)

求幂运算符。

如果 x 和 y 是整数，结果可能溢出。要在科学记数法中输入数字，请使用 漂浮64文字如 1.2e3 而不是 1.2 &ast; 10^3.

如果 y 是一个 Int型 字面（例如 2 在 x^2 或 -3 在 x^-3），朱莉娅代码 x^y 被编译器转换为 基地。literal_pow(^,x,Val(y))，以启用对指数值的编译时特化。（作为默认回退，我们有 基地。literal_pow(^,x,Val(y))=^(x,y)，通常在哪里 ^==基数。^ 除非 ^ 已在调用命名空间中定义。)如果 y 是一个负整数字面量，则 基地。[医]文学 将操作转换为 inv(x)^-y 默认情况下，其中 -y 是肯定的。

请参阅 exp2, <<.

*例子*

julia> 3^5
243

julia> 3^-1  # uses 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  # integer overflow
false

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

# *`基地。fma`*-函数

fma(x, y, z)

计算机 x*y+z 不舍入中间结果 x*y. 在某些系统上，这比 x*y+z. fma 用于提高某些算法的准确性。见 穆拉德.

# *`基地。穆拉德`*-函数

muladd(x, y, z)

组合乘加：计算 x*y+z，但允许加法和乘法相互合并或与周围操作合并以获得性能。例如，这可以被实现为 fma如果硬件有效地支持它。结果可能在不同的机器上不同，也可能由于持续传播或其他优化而在同一台机器上不同。见 fma.

*例子*

julia> muladd(3, 2, 1)
7

julia> 3 &ast; 2 + 1
7

muladd(A, y, z)

组合乘加, A*y．+z，用于矩阵-矩阵或矩阵-向量乘法。结果总是与大小相同 A*y，但是 z 可能更小，或标量。

兼容性

Julia1.6这些方法需要Julia1.6或更高版本。

*例子*

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

# *`基地。因维`*-Method

inv(x)

返回的乘法逆 x，这样 x*inv(x) 或 inv(x)*x 产量 一(x)（乘性身份）直至舍入误差。

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

*例子*

julia> inv(2)
0.5

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

julia> inv(1 + 2im) &ast; (1 + 2im)
1.0 + 0.0im

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

兼容性

朱莉娅1.2 inv(::缺失) 至少需要Julia1.2。

# *`基地。分区`*-函数

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

来自欧几里德（整数）除法的商。一般相当于没有小数部分的数学运算x/y。

请参阅: 中大, 消防处, 快速眼动, n.分管,分管.

*例子*

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

# *`基地。分区`*-Method

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

来自欧几里德（整数）除法的商。计算机 x/y，根据舍入模式舍入为整数 r. 换句话说，数量

round(x / y, r)

没有任何中间舍入。

兼容性

Julia1.4采用a的三参数方法 圆模/圆模 需要Julia1.4或更高版本。

请参阅 消防处和 中大，这是该函数的特例。

兼容性

朱莉娅1.9 RoundFromZero的 至少需要Julia1.9。

*例子:*

julia> div(4, 3, RoundToZero) # Matches div(4, 3)
1
julia> div(4, 3, RoundDown) # Matches fld(4, 3)
1
julia> div(4, 3, RoundUp) # Matches 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

因为 div(x,y) 根据浮点数的真实值实现严格正确的截断舍入，可能会出现不直观的情况。例如:

julia> div(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，但是 div(6.0,0.1,圆球) 总是截断真值，所以结果是 59.0.

# *`基地。消防处`*-函数

fld(x, y)

小于或等于的最大整数 x/y. 相当于 div(x,y,圆).

请参阅 分区, 中大, 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,综述).

请参阅 分区, 消防处.

*例子*

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

# *`基地。国防部`*-函数

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

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

减少 x 模数,模数 y，或等同地，其余的 x 经过楼层划分 y，即 x-y*fld(x,y) 如果计算没有中间舍入。

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

注意当与浮点值一起使用时，确切的结果可能无法由类型表示，因此可能会发生舍入错误。特别是，如果确切的结果非常接近 y，那么它可能四舍五入为 y.

请参阅: 快速眼动, 分区, 消防处, mod1, 因弗莫德.

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

朱莉娅>国防部.(-5:5, 3)'
1×11adjoint(::向量{Int64}）与eltype Int64:
 1  2  0  1  2  0  1  2  0  1  2

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

查找 y 范围内 r 这样， x ≡ y （mod n），在哪里 n=长度(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此方法至少需要Julia1.3。

# *`基地。快速眼动`*-函数

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

欧几里德除法的余数，返回与 x，并且比 y. 这个值总是精确的。

请参阅: 分区, 国防部, mod1, n.分管,分管.

*例子*

julia> x = 15; y = 4;

julia> x % y
3

julia> x == div(x, y) &ast; 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

# *`基地。快速眼动`*-Method

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

计算 x 整数除法后 y，用商根据舍入模式进行舍入 r. 换句话说，数量

x - y &ast; round(x / y, r)

没有任何中间舍入。

如果 r==RoundNearest，那么结果是确切的，并在区间$[-

/ 2,

/ 2]$. 请参阅 RoundNearest拢潞.

如果 r==RoundToZero （默认），那么结果是确切的，并且在区间$[0,

)$如果 x 为正，或$(-

,0]$否则。请参阅 圆托泽罗.

*如果 r==RoundDown，则结果在区间如果 y 为正数，或 ]否则。结果可能不确切，如果 x 和 y 有不同的迹象，并 abs(x)<abs(y). 请参阅 四舍五入. *如果 r==综述，则结果在区间 ]如果 y 为正数，或否则。结果可能不确切，如果 x 和 y 有相同的标志，并 abs(x)<abs(y). 请参阅 综述. *如果 r==RoundFromZero，则结果在区间 ]如果 y 为正数，或否则。结果可能不确切，如果 x 和 y 有相同的标志，并 abs(x)<abs(y). 请参阅 RoundFromZero的.

兼容性

朱莉娅1.9 RoundFromZero的 至少需要Julia1.9。

*例子:*

julia> x = 9; y = 4;

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

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

julia>x==div(x,y)&ast;y+rem(x,y)
真的

# *`基地。数学。rem2pi`*-函数

rem2pi(x, r::RoundingMode)

计算 x 整数除法后 2π，用商根据舍入模式进行舍入 r. 换句话说，数量

x - 2π&ast;round(x/(2π),r)

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

*如果 r==RoundNearest，则结果在区间 ]. 这通常是最准确的结果。请参阅 RoundNearest拢潞. *如果 r==RoundToZero，则结果在区间 ]如果 x 是积极的，。或 ]否则。请参阅 圆托泽罗. *如果 r==RoundDown，则结果在区间 ]. 请参阅 四舍五入. *如果 r==综述，则结果在区间 ]. 请参阅 综述.

*例子*

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

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

# *`基地。数学。mod2pi`*-函数

mod2pi(x)

除以后模数 2π，在范围内返回 .

此函数计算通过数值精确除法后的模的浮点表示 2π，因此与 国防部(x,2π)，这将计算模 x 相对于除以浮点数 2π.

注意根据输入值的格式最接近2π的可表示值可能小于2π。例如，表达式 mod2pi(2π) 不会回来 0，因为中间值的 2*π 是一个 漂浮64 和 2*Float64(π)<2*大(π). 见 rem2pi以更精细地控制这种行为。

*例子*

julia> mod2pi(9&ast;pi/4)
0.7853981633974481

# *`基地。n.分管,分管`*-函数

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

欧几里德除法的商和余数. 相当于 (div(x,y,r),rem(x,y,r)). 等价地，默认值为 r，这个调用相当于 (x≠y,x%y).

请参阅: fldmod的, 中大.

*例子*

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

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

# *`基地。fldmod的`*-函数

fldmod(x, y)

除法后的分解商和模数. 一个方便的包装器 divrem（x，y，RoundDown）. 相当于 (fld(x,y),mod(x,y)).

请参阅: 消防处, 中大, fldmod1.

# *`基地。fld1`*-函数

fld1(x, y)

地板划分，返回一个与 mod1(x,y)

请参阅 mod1, fldmod1.

*例子*

julia> x = 15; y = 4;

julia> fld1(x, y)
4

julia> x == fld(x, y) &ast; y + mod(x, y)
true

julia> x == (fld1(x, y) - 1) &ast; y + mod1(x, y)
true

# *`基地。mod1`*-函数

mod1(x, y)

地板分割后的模数，返回一个值 r 这样， mod(r,y)==mod(x,y) 范围内 ]为正 y 而在范围内为负 y.

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

请参阅 国防部, 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`*-函数

fldmod1(x, y)

回来吧 (fld1(x,y),mod1(x,y)).

请参阅 fld1, mod1.

# *`基地。://`*-函数

//(num, den)

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

注意浮点([医抽象浮])参数是不允许的 // （即使值是理性的）。参数必须是 整数, 理性的，或其复合材料。

*例子*

julia> 3 // 5
3//5

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

julia> (1+2im) // (3+4im)
11//25 + 2//25&ast;im

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

# *`基地。合理化`*-函数

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

近似浮点数 x 作为一个 理性的编号与给定整数类型的组件。结果将不同于 x 不超过 托尔.

*例子*

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

# *`基地。:<<`*-函数

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

左位移运算符, B[n. 为 n>=0，结果是 B 随着元素的移动 n 向后的位置，充满 错误 价值观。如果 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 位，填充 0s.这相当于 x&ast;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 位置向前，充满 错误 价值观。如果 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 位，填充 0s如果 x>=0, 1s如果 x<0，保留 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. 相当于 B>>n. 见 >>的细节和示例。

>>>(x, n)

无符号右位移位运算符, x>>>n. 为 n>=0，结果是 x 右移 n 位，填充 0s.为 n<0，这相当于 x<←n.

为 未签名整数类型，这相当于 >>. 为 签署整数类型，这相当于 签名(无符号(x)>n).

*例子*

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

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

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

比金特s被视为具有无限大小，因此不需要填充，这相当于 >>.

请参阅 >>, <<.

# *`基地。bitrotate碌录潞陆`*-函数

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

bitrotate(x,k) 实现按位旋转。它返回 x 它的钻头向左旋转 k 时代。的负值 k 将改为向右旋转。

兼容性

Julia1.5此功能需要Julia1.5或更高版本。

请参阅: <<, [医循环换档], 比特阵列.

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, 符号，或字面值。语法 :标识符 评估为 符号.

请参阅: Expr, 符号, 元。解析,解析

*例子*

julia> expr = :(a = b + 2&ast;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)

用均匀间隔的元素和优化的存储构造一个专门的数组（一个 抽象,抽象）从论点。在数学上，一个范围是由以下三个参数唯一确定的 开始, 步骤, 停止 和 长度. 范围的有效调用是:

*致电 范围 与任何三个 开始, 步骤, 停止, 长度. *致电 范围 与两个 开始, 停止, 长度. 在这种情况下 步骤 将被假定为正的一个。如果两个参数都是整数，则 单位范围将被退回。 *致电 范围 与一个 停止 或 长度. 开始 和 步骤 将被假定为正的一个。

要构造降序范围，请指定负步长，例如 范围(5,1;步骤=-1) => [5,4,3,2,1]. 否则，一个 停止 值小于 开始 值，与默认 步骤 的 +1，构造空范围。空范围被归一化，使得 停止 比 开始，例如 范围(5, 1) == 5:4.

有关返回类型的其他详细信息，请参阅扩展帮助。请参阅 罗格兰奇对于对数间隔的点。

*例子*

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>范围(;停止=6)
基地。OneTo(6)

julia>范围(;停止=6.5)
1.0:1.0:6.0

如果 长度 未指定及 停止-开始 不是整数倍 步骤，之前结束的范围 停止 会产生。

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

特别注意确保合理计算中间值。为了避免这种引起的开销，请参阅 林兰格构造函数。

兼容性

朱莉娅1.1 停止 作为位置参数至少需要Julia1.1。

兼容性

Julia1.7没有关键字参数的版本和 开始 作为关键字参数至少需要Julia1.7。

兼容性

朱莉娅1.8版本与 停止 作为唯一的关键字参数，或 长度 作为唯一的关键字参数，至少需要Julia1.8。

*扩展帮助*

范围 会产生一个 基地。一个,一个 当参数是整数和

*只限 长度 被提供 *只限 停止 被提供

范围 会产生一个 单位范围 当参数是整数和

*只限 开始 和 停止 已提供 *只限 长度 和 停止 已提供

A 单位范围 如果不产生 步骤 被提供，即使指定为一个。

# *`基地。一个,一个`*-类型

Base.OneTo(n)

定义一个 N.抽象,抽象 这表现得像 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 是自动推导的），由一个参数化 参考书erence价值,a 步骤，而 伦gth。默认情况下 参考书 是起始值 r[1]，但也可以将其作为 r[偏移量] 对于其他一些索引 1<=偏移<=len. 语法 a：b 或 a：b：c，其中任何 a, b，或 c 是浮点数，创建一个 斯特普朗格伦.

兼容性

Julia1.7第4个类型参数 L 至少需要Julia1.7。

# *`基地。罗格兰奇`*-函数

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

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

这类似于 地球空间 在Python中。不像 N.能量交换 在Mathematica中，您指定元素的数量而不是比率。不像 日志空间 在Python和Matlab中， 开始 和 停止 参数始终是结果的第一个和最后一个元素，而不是应用于某些基础的权力。

*例子*

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 &ast; 4000)  # middle element is the geometric mean
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # arithmetic mean
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

查看 罗格兰奇类型以获取更多细节。

请参阅 范围为线性间隔的点。

兼容性

Julia1.11此功能至少需要Julia1.11。

# *`基地。罗格兰奇`*-类型

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

元素之间以对数间隔的范围 开始 和 停止，间距由 伦. 返回者 罗格兰奇.

像 林兰格，第一个和最后一个元素将完全是那些提供，但中间值可能有小的浮点错误。这些是使用端点的日志计算的，这些日志存储在构造中，通常比 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

注意integer eltype 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这种类型至少需要Julia1.11。

# *`基地。:==`*-函数

==(x, y)

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

此运算符遵循浮点数的IEEE语义: 0.0 == -0.0 和 南！=南.

结果是类型的 布尔，除非其中一个操作数是 失踪，在这种情况下 失踪 被返回（https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]）。集合通常实现类似于以下的三值逻辑 全部，如果任何操作数包含缺失值并且所有其他对相等，则返回missing。使用方法 等效;等效或 ===总是得到一个 布尔 结果。

*实施*

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

平等和哈希是密切相关的;被认为是两个值 等效;等效*必须*具有相同 哈希和默认情况下 等效;等效 回落到 ==. 如果类型自定义的行为 == 和/或 等效;等效，则 哈希必须类似地实施以确保 等效;等效 和 哈希 同意。 套装s, Dict,Dicts，以及许多其他内部实现假设这个不变性成立。

如果某些类型定义 ==, 等效;等效，和 无为那么它也应该实现 <以确保比较的一致性。

# *`基地。:!=`*-函数

!=(x)

创建一个函数，将其参数与 x 使用 !=，即等价于 y->y！=x. 返回的函数是类型 基地。修正2{typeof(!=)}，从而可用于实施专门的方法。

兼容性

Julia1.2此功能至少需要Julia1.2。

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

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

*实施*

新类型通常不应该实现这一点，并依赖于回退定义 !=（x，y）=！(x==y) 相反。

*例子*

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

# *`核心。:!==`*-函数

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

总是给出相反的答案 ===.

*例子*

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

julia> a ≢ b
true

julia> a ≢ a
false

# *`基地。:<`*-函数

<(x)

创建一个函数，将其参数与 x 使用 <，即等价于 y->y<x. 返回的函数是类型 基地。修正2{typeof(<)}，从而可用于实施专门的方法。

兼容性

Julia1.2此功能至少需要Julia1.2。

<(x, y)

小于比较运算符。回落到 无障碍. 由于浮点NaN值的行为，此运算符实现了部分顺序。

*实施*

具有规范偏序的新类型应为新类型的两个参数实现此函数。具有规范总顺序的类型应该实现 无为代替。

请参阅 无序,无序.

*例子*

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

# *`基地。:<=`*-函数

<=(x)

创建一个函数，将其参数与 x 使用 <=，即等价于 y->y<=x. 返回的函数是类型 基地。修正2{typeof(<=)}，从而可用于实施专门的方法。

兼容性

Julia1.2此功能至少需要Julia1.2。

<=(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. 返回的函数是类型 基地。修正2{typeof(>)}，从而可用于实施专门的方法。

兼容性

Julia1.2此功能至少需要Julia1.2。

>(x, y)

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

*实施*

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

*例子*

julia> 'a' > 'b'
false

朱莉娅>7>3>1
真的

朱莉娅>"abc">"abd"
错误

朱莉娅>5>3
真的

# *`基地。:>=`*-函数

>=(x)

创建一个函数，将其参数与 x 使用 >=，即等价于 y->y>=x. 返回的函数是类型 基地。修正2{typeof(>=)}，从而可用于实施专门的方法。

兼容性

Julia1.2此功能至少需要Julia1.2。

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

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

*例子*

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

# *`基地。cmp技术`*-函数

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

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

*例子*

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

cmp(<, x, y)

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

cmp(x,y)

返回-1，0或1取决于是否 x 小于、等于或大于 y，分别。使用由 无为.

*例子*

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})
[...]

# *`基地。:~`*-函数

~(x)

按位不。

请参阅: !, &, [|]（/base/math#Base。:

*例子*

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

# *`基地。:&`*-函数

x & y

按位和。工具/工具https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]，返回 失踪如果一个操作数是 失踪 另一个是 真的. 函数申请表加括号: (&)(x,y).

另见：[|]（/base/math#Base。:

), 异或, &&.

*例子*

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[三值逻辑]，返回 失踪如果一个操作数是 失踪 另一个是 错误.

请参阅: &, 异或, [||](/基数/数学#

*例子*

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[三值逻辑]，返回 失踪如果其中一个参数是 失踪.

中缀操作 a＞b 是一个同义词 异或(a,b)，而 ⊻ 可以通过制表符完成键入 \异或 或 [美]维巴 在朱莉娅REPL。

*例子*

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[三值逻辑]，返回 失踪如果其中一个参数是 失踪.

中缀操作 a＞b 是一个同义词 nand(a,b)，而 ⊼ 可以通过制表符完成键入 与非 或 [医]驳船 在朱莉娅REPL。

*例子*

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. 工具/工具https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]，返回 失踪如果其中一个参数是 失踪 而另一个不是 真的.

中缀操作 a＞b 是一个同义词 也不是(a,b)，而 ⊽ 可以通过制表符完成键入 \也不 或 \巴维 在朱莉娅REPL。

*例子*

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

# *`基地。:!`*-函数

!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 返回a 复合函数而不是匿名函数。

!(x)

布尔不。工具/工具https://en.wikipedia.org/wiki/Three-valued_logic[三值逻辑]，返回 失踪如果 x 是 失踪.

请参阅对于按位不。

*例子*

julia> !true
false

julia> !false
true

julia> !missing
missing

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

# *`&&`*-密码_

x && y

短路布尔和。

这相当于 x？ y：错误：它返回 错误 如果 x 是 错误 和评估的结果 y 如果 x 是 真的. 请注意，如果 y 是一个表达式，它仅在 x 是 真的，这被称为"短路"行为。

也, y 不需要有布尔值。这意味着 (条件)&&(声明) 可作为简写 如果条件；语句；结束 对于任意 声明.

请参阅 &，三元运算符 ? :，以及关于控制流程。

*例子*

julia> x = 3;

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

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

julia> x > 0 && "not a boolean"
"not a boolean"

# *`||`*-密码_

x || y

短路布尔或。

这相当于 x？真：y：它返回 真的 如果 x 是 真的 和评估的结果 y 如果 x 是 错误. 请注意，如果 y 是一个表达式，它仅在 x 是 错误，这被称为"短路"行为。

也, y 不需要有布尔值。这意味着 （条件）//（声明） 可作为简写 如果！(条件);语句;结束 对于任意 声明.

另见：[|]（/base/math#Base。:

), 异或, &&.

*例子*

julia> pi < 3 || ℯ < 3
true

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

julia> pi < 3 || "not a boolean"
"not a boolean"

数学函数

# *`基地。[医]伊萨普罗克斯`*-函数

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

创建一个函数，将其参数与 x 使用 ≈，即等价于 y->y≠x.

这里支持的关键字参数与2参数中的关键字参数相同 [医]伊萨普罗克斯.

兼容性

Julia1.5此方法需要Julia1.5或更高版本。

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

不精确的平等比较。两个数字比较相等，如果它们的相对距离_or_它们的绝对距离在公差范围内: [医]伊萨普罗克斯 申报表 真的 如果 norm(x-y)<=max(atol,rtol&ast;max(norm(x),norm(y))). 默认值 atol公司 （绝对容差）为零，默认值为 rtol （相对公差）取决于 x 和 y. 关键字参数 南斯 确定NaN值是否被视为相等（默认为false）。

对于实数或复数浮点值，如果 atol>0 未指定, rtol 默认为 每股收益的类型 x 或 y，以较大者为准（最不精确）。这对应于要求有效数字的大约一半的相等。否则，例如整数参数或 atol>0 已供应, rtol 默认值为零。

该 规范 关键字默认为 腹肌 对于数字 (x,y) 而到 线性代数。规范 对于数组（其中一个替代 规范 选择有时是有用的）。何时 x 和 y 是数组，如果 规范(x-y) 不是有限的（即 ±Inf 或 南），比较回退到检查是否所有元素 x 和 y 是近似相等的组成部分。

二元运算符 ≈ 相当于 [医]伊萨普罗克斯 使用默认参数，以及 x＜y 相当于 !isapprox(x,y).

请注意 x＜0 （即，与默认容差相比为零）相当于 x==0 自默认 atol公司 是 0. 在这种情况下，你应该提供适当的 atol公司 （或使用 标准(x)≤atol）或重新排列您的代码（例如使用 x＜y 而不是 x-y＜0). 不可能选择非零 atol公司 自动，因为它取决于您的问题的整体缩放（"单位"）：例如，在 x-y＜0, atol=1e-9 是一个荒谬的小容忍，如果 x 是https://en.wikipedia.org/wiki/Earth_radius[地球半径]以米为单位，但如果 x 是https://en.wikipedia.org/wiki/Bohr_radius[氢原子的半径]以米为单位。

兼容性

朱莉娅1.6通过 规范 关键字参数比较数字（非数组）参数时需要Julia1.6或更高版本。

*例子*

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

# *`基地。罪`*-Method

sin(x::T) where {T <: Number} -> float(T)

计算正弦 x，在哪里 x 是弧度。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

请参阅 辛德, 辛皮, 辛科斯, 独联体, 阿辛.

*例子*

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&ast;pi/6), digits=3)
0.866 + 0.5im

# *`基地。[医]`*-Method

cos(x::T) where {T <: Number} -> float(T)

计算余弦的 x，在哪里 x 是弧度。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

请参阅 cosd, 科斯皮, 辛科斯, 独联体.

# *`基地。数学。辛科斯`*-Method

sincos(x::T) where T -> Tuple{float(T),float(T)}

同时计算正弦和余弦 x，在哪里 x 以弧度为单位，返回一个元组 （正弦，余弦）.

扔一个 N.域名,域名如果 isinf(x)，返回一个 (T(NaN),T(NaN)) 如果 伊斯南(x).

请参阅 独联体, 辛科斯皮, 辛科斯德.

# *`基地。谭`*-Method

tan(x::T) where {T <: Number} -> float(T)

计算切线 x，在哪里 x 是弧度。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

请参阅 坦.

# *`基地。数学。辛德`*-函数

sind(x::T) where T -> float(T)

计算正弦 x，在哪里 x 以度为单位。如果 x 是矩阵, x 需要是方阵。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。cosd`*-函数

cosd(x::T) where T -> float(T)

计算余弦的 x，在哪里 x 以度为单位。如果 x 是矩阵, x 需要是方阵。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。坦德`*-函数

tand(x::T) where T -> float(T)

计算切线 x，在哪里 x 以度为单位。如果 x 是矩阵, x 需要是方阵。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。辛科斯德`*-函数

sincosd(x::T) where T -> Tuple{float(T),float(T)}

同时计算正弦和余弦 x，在哪里 x 以度为单位，返回一个元组 （正弦，余弦）.

扔一个 N.域名,域名如果 isinf(x)，返回一个 (T(NaN),T(NaN)) 元组if 伊斯南(x).

兼容性

Julia1.3此功能至少需要Julia1.3。

# *`基地。数学。辛皮`*-函数

sinpi(x::T) where T -> float(T)

计算/计算更准确地说 罪(pi*x)，特别是对于大 x.

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

请参阅 辛德, 科斯皮, 辛科斯皮.

# *`基地。数学。科斯皮`*-函数

cospi(x::T) where T -> float(T)

计算/计算更准确地说 cos(pi*x)，特别是对于大 x.

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

请参阅: 西斯皮, 辛科斯德, 科斯皮.

# *`基地。数学。坦皮`*-函数

tanpi(x::T) where T -> float(T)

计算/计算更准确地说 谭(pi*x)，特别是对于大 x.

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

兼容性

Julia1.10此功能至少需要Julia1.10。

请参阅 坦德, 辛皮, 科斯皮, 辛科斯皮.

# *`基地。数学。辛科斯皮`*-函数

sincospi(x::T) where T -> Tuple{float(T),float(T)}

同时计算 辛皮(x)和 cospi(x)（的正弦和余弦 π*x，在哪里 x 以弧度为单位），返回一个元组 （正弦，余弦）.

扔一个 N.域名,域名如果 isinf(x)，返回一个 (T(NaN),T(NaN)) 元组if 伊斯南(x).

兼容性

Julia1.6此功能需要Julia1.6或更高版本。

请参阅: 西斯皮, 辛科斯德, 辛皮.

# *`基地。辛`*-Method

sinh(x)

计算双曲正弦 x.

请参阅 罪.

# *`基地。科什`*-Method

cosh(x)

计算双曲余弦 x.

请参阅 [医].

# *`基地。坦`*-Method

tanh(x)

计算双曲正切 x.

请参阅 谭, 阿坦.

*例子*

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 .&ast; (1:3))
3-element Vector{ComplexF64}:
 0.0 + 0.7615941559557649im
 0.0 + 0.9640275800758169im
 0.0 + 0.9950547536867306im

# *`基地。阿辛`*-Method

asin(x::T) where {T <: Number} -> float(T)

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

返回a T(南) 如果 伊斯南(x).

请参阅 阿辛德用于以度为单位的输出。

*例子*

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

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

# *`基地。助理文书主任`*-Method

acos(x::T) where {T <: Number} -> float(T)

计算反余弦的 x，其中输出以弧度为单位

返回a T(南) 如果 伊斯南(x).

# *`基地。阿坦`*-Method

atan(y)
atan(y, x)

计算的反切 y 或 y/x，分别。

对于一个实数参数，这是正_x_轴和点(1,y)之间的弧度角，返回区间中的值 ].

对于两个参数，这是正_x_轴和点（x，y）之间的弧度角，返回间隔中的值 ]. 这对应于一个标准https://en.wikipedia.org/wiki/Atan2[脧锚脧赂`阿坦2`]功能。请注意，按照惯例 atan(0.0,x) 被定义为和 atan(-0.0,x) 被定义为何时 x<0.

请参阅 xref:base/math.adoc#Base.Math.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矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。acosd`*-函数

acosd(x)

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

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。阿坦德`*-函数

atand(y::T) where T -> float(T)
atand(y::T, x::S) where {T,S} -> promote_type(T,S)
atand(y::AbstractMatrix{T}) where T -> AbstractMatrix{Complex{float(T)}}

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

返回a 南 如果 伊斯南(y) 或 伊斯南(x). 返回的 南 是一个 T 在单参数版本中，或 促进型(T,S) 在两个参数版本中。

兼容性

Julia1.7自Julia1.7起，单参数方法支持方阵参数。

# *`基地。数学。sec`*-Method

sec(x::T) where {T <: Number} -> float(T)

计算割线 x，在哪里 x 是弧度。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

# *`基地。数学。csc`*-Method

csc(x::T) where {T <: Number} -> float(T)

计算 x，在哪里 x 是弧度。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

# *`基地。数学。婴儿床`*-Method

cot(x::T) where {T <: Number} -> float(T)

计算 x，在哪里 x 是弧度。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

# *`基地。数学。秘书处`*-函数

secd(x::T) where {T <: Number} -> float(T)

计算割线 x，在哪里 x 以度为单位。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

# *`基地。数学。cscd`*-函数

cscd(x::T) where {T <: Number} -> float(T)

计算 x，在哪里 x 以度为单位。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

# *`基地。数学。科德`*-函数

cotd(x::T) where {T <: Number} -> float(T)

计算 x，在哪里 x 以度为单位。

扔一个 N.域名,域名如果 isinf(x)，返回一个 T(南) 如果 伊斯南(x).

# *`基地。数学。亚欧会议`*-Method

asec(x::T) where {T <: Number} -> float(T)

计算逆割线 x，其中输出以弧度为单位。

# *`基地。数学。acsc`*-Method

acsc(x::T) where {T <: Number} -> float(T)

计算 x，其中输出以弧度为单位。

# *`基地。数学。阿科特`*-Method

acot(x::T) where {T <: Number} -> float(T)

计算的逆余切 x，其中输出以弧度为单位。

# *`基地。数学。asecd`*-函数

asecd(x)

计算逆割线 x，其中输出以度为单位。如果 x 是矩阵, x 需要是方阵。

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。acscd`*-函数

acscd(x)

计算 x，其中输出以度为单位。如果 x 是矩阵, x 需要是方阵。

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。acotd`*-函数

acotd(x)

计算的逆余切 x，其中输出以度为单位。如果 x 是矩阵, x 需要是方阵。

兼容性

Julia1.7矩阵参数需要Julia1.7或更高版本。

# *`基地。数学。谢氏`*-Method

sech(x::T) where {T <: Number} -> float(T)

计算双曲线割线 x.

返回a T(南) 如果 伊斯南(x).

# *`基地。数学。政务司司长`*-Method

csch(x::T) where {T <: Number} -> float(T)

计算双曲余弦 x.

返回a T(南) 如果 伊斯南(x).

# *`基地。数学。科特`*-Method

coth(x::T) where {T <: Number} -> float(T)

计算双曲余切 x.

返回a T(南) 如果 伊斯南(x).

# *`基地。阿辛`*-Method

asinh(x)

计算反双曲正弦 x.

# *`基地。阿科什`*-Method

acosh(x)

计算反双曲余弦 x.

# *`基地。阿坦`*-Method

atanh(x)

计算反双曲正切 x.

# *`基地。数学。阿塞奇`*-Method

asech(x::T) where {T <: Number} -> float(T)

计算反双曲线割线 x.

# *`基地。数学。acsch`*-Method

acsch(x::T) where {T <: Number} -> float(T)

计算逆双曲余弦 x.

# *`基地。数学。阿科特`*-Method

acoth(x::T) where {T <: Number} -> float(T)

计算逆双曲余切 x.

# *`基地。数学。中大`*-函数

sinc(x::T) where {T <: Number} -> float(T)

计算归一化sinc函数如果，并如果 .

返回a T(南) 如果 伊斯南(x).

请参阅 中远集团，其衍生物。

# *`基地。数学。中远集团`*-函数

cosc(x::T) where {T <: Number} -> float(T)

计算/计算如果，并如果 . 这是导数 sinc(x).

返回a T(南) 如果 伊斯南(x).

请参阅 中大.

# *`基地。数学。deg2rad`*-函数

deg2rad(x)

转换/转换 x 度到弧度。

请参阅 rad2deg, 辛德, 圆周率.

*例子*

julia> deg2rad(90)
1.5707963267948966

# *`基地。数学。rad2deg`*-函数

rad2deg(x)

转换/转换 x 从弧度到度。

请参阅 deg2rad.

*例子*

julia> rad2deg(pi)
180.0

# *`基地。数学。[医]hypot`*-函数

hypot(x, y)

计算斜边避免上溢和下溢。

这段代码是一个实现的算法描述：一个改进的算法为 hypot（a，b） 这篇文章可以在arXiv的链接上找到https://arxiv.org/abs/1904.09481

hypot(x...)

计算斜边避免上溢和下溢。

请参阅 规范 在 线性代数标准库。

*例子*

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

# *`基地。日志`*-Method

log(x)

计算自然对数 x.

扔一个 N.域名,域名为负 真实的争论。使用方法 综合体获得的参数 综合体结果。

分支切割 日志 具有沿负实轴切割的分支; -0.0im 被取为在轴的下方。

请参阅 ℯ, log1p, 日志2, 日志10.

*例子*

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

朱莉娅>日志.（exp.(-1:1))
3元素向量{Float64}:
 -1.0
  0.0
  1.0

# *`基地。日志`*-Method

log(b,x)

计算基数 b 对数的 x. 扔一个 N.域名,域名为负 真实的争论。

*例子*

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的幂, 日志2或 日志10应该使用，因为这些通常会更快，更准确。例如,

朱莉娅>日志(100,100000)
2.9999999999999996

朱莉娅>log10(1000000)/2
3.0

# *`基地。日志2`*-函数

log2(x)

计算的对数 x 到基地2。扔一个 N.域名,域名为负 真实的争论。

请参阅: 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

# *`基地。日志10`*-函数

log10(x)

计算的对数 x 到基地10。扔一个 N.域名,域名为负 真实的争论。

*例子*

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`*-函数

log1p(x)

精确的自然对数 1+x. 扔一个 N.域名,域名为 真实的小于-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 在区间内有一个幅度或0，和 瓦尔 等于 .

请参阅 n.意义,意义, 指数, ldexp.

*例子*

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # interval [1, 2) instead
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # exponent would give an error
((0.0, 0), (NaN, 0), (-Inf, 0))

# *`基地。exp`*-Method

exp(x)

计算自然基指数 x，换句话说 .

请参阅 exp2, exp10和 独联体.

*例子*

julia> exp(1.0)
2.718281828459045

julia> exp(im &ast; pi) ≈ cis(pi)
true

# *`基地。exp2`*-函数

exp2(x)

计算基数2指数 x，换句话说 .

请参阅 ldexp, <<.

*例子*

julia> exp2(5)
32.0

julia> 2^5
32

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

# *`基地。exp10`*-函数

exp10(x)

计算基数10指数 x，换句话说 .

*例子*

julia> exp10(2)
100.0

julia> 10^2
100

# *`基地。数学。ldexp`*-函数

ldexp(x, n)

计算/计算 .

请参阅 弗里智浦, 指数.

*例子*

julia> ldexp(5.0, 2)
20.0

# *`基地。数学。modf的`*-函数

modf(x)

返回一个元组 （fpart，ipart） 数的小数部分和整数部分。这两个部分都有相同的符号作为参数。

*例子*

julia> modf(3.5)
(0.5, 3.0)

朱莉娅>modf(-3.5)
(-0.5, -3.0)

# *`基地。expm1`*-函数

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，或同类型的 x 如果没有 T 被提供。一个 N.恐怖,恐怖 如果值不能由 T，类似于 xref:base/base.adoc#Base.convert[转换/转换.

如果 数字 提供关键字参数，它舍入到小数点后的指定位数（如果是负数，则在之前），以base为单位 基地.

如果 [医]乙状结肠 提供了关键字参数，它以base为单位舍入到指定的有效位数 基地.

该 圆模/圆模 r 控制舍入的方向；默认值为 RoundNearest拢潞，舍入到最接近的整数，而ties（0.5的小数值）舍入到最接近的偶数整数。请注意 圆形 如果更改全局舍入模式，可能会给出不正确的结果（请参阅 四舍五入).

当舍入到浮点类型时，将舍入到该类型（和Inf）表示的整数而不是真整数。 Inf被视为一个ulp大于 最大浮标(T) 为确定"最近"的目的，类似于 转换/转换.

*例子*

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以外的基数舍入到指定的数字可能是不准确的。例如， 漂浮64表示的值 1.15 实际上_less_大于1.15，但将四舍五入为1.2。例如:

朱莉娅>x=1.15
1.15

朱莉娅>大(1.15)
1.149999999999999911182158029987476766109466552734375

朱莉娅>x<115//100
真的

朱莉娅>圆(x,数字=1)
1.2

*扩展*

以延伸 圆形 对于新的数字类型，通常定义就足够了 基地。round(x::NewType,r::RoundingMode).

# *`基地。四舍五入。圆模/圆模`*-类型

RoundingMode

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

目前支持的舍入模式有:

* RoundNearest拢潞(默认) * 往返旅行 * RoundNearestTiesUp * 圆托泽罗 * RoundFromZero的 * 综述 * 四舍五入

兼容性

朱莉娅1.9 RoundFromZero的 至少需要Julia1.9。以前的版本支持 RoundFromZero的 为 [医]大块头仅此而已。

# *`基地。四舍五入。RoundNearest拢潞`*-注册_

RoundNearest

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

# *`基地。四舍五入。往返旅行`*-注册_

RoundNearestTiesAway

四舍五入到最接近的整数，并与零四舍五入（C/C++ xref:base/math.adoc#Base.round[圆形 行为）。

# *`基地。四舍五入。RoundNearestTiesUp`*-注册_

RoundNearestTiesUp

舍入到最接近的整数，关系舍入到正无穷大（Java/JavaScript） xref:base/math.adoc#Base.round[圆形 行为）。

# *`基地。四舍五入。圆托泽罗`*-注册_

RoundToZero

圆形使用此舍入模式是 [医].

# *`基地。四舍五入。RoundFromZero的`*-注册_

RoundFromZero

从零开始。

兼容性

朱莉娅1.9 RoundFromZero的 至少需要Julia1.9。以前的版本支持 RoundFromZero的 为 [医]大块头仅此而已。

*例子*

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

# *`基地。四舍五入。综述`*-注册_

RoundUp

圆形使用此舍入模式是 齐尔.

# *`基地。四舍五入。四舍五入`*-注册_

RoundDown

圆形使用此舍入模式是 楼层.

# *`基地。圆形`*-Method

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

返回与复数值类型相同的最近的整数值 z 到 z，打破使用指定的关系圆模/圆模`s.第一个 xref:base/math.adoc#Base.Rounding.RoundingMode[`圆模/圆模用于舍入实数分量，而第二个用于舍入虚数分量。

[医]圆形 和 N.圆型,圆型 默认为 RoundNearest拢潞，舍入到最接近的整数，而ties（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])

锡尔(x) 返回与……相同类型的最接近的整数值 x 即大于等于 x. ceil(T,x) 将结果转换为类型 T，投掷 N.恐怖,恐怖 如果ceiled值不能表示为 T.

关键词 数字, [医]乙状结肠 和 基地 工作至于 圆形.

支持 齐尔 对于新类型，定义 基地。round(x::NewType,::RoundingMode{:Up}).

# *`基地。楼层`*-函数

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

楼层(x) 返回与……相同类型的最接近的整数值 x 即小于等于 x.

楼层(T,x) 将结果转换为类型 T，投掷 N.恐怖,恐怖 如果floored值不可表示a T.

关键词 数字, [医]乙状结肠 和 基地 工作至于 圆形.

支持 楼层 对于新类型，定义 基地。round(x::NewType,::RoundingMode{:Down}).

# *`基地。[医]`*-函数

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

中继(x) 返回与……相同类型的最接近的整数值 x 其绝对值小于或等于 x. trunc（T，x） 将结果转换为类型 T，投掷 N.恐怖,恐怖 如果截断值不可表示a T.

关键词 数字, [医]乙状结肠 和 基地 工作至于 圆形.

支持 [医] 对于新类型，定义 基地。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`*-函数

unsafe_trunc(T, x)

返回类型的最接近的整数值 T 其绝对值小于或等于 x. 如果该值不能由 T，将返回任意值。请参阅 [医].

*例子*

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

# *`基地。敏`*-函数

min(x, y, ...)

返回参数的最小值，相对于 无为. 如果任何参数是 失踪，返回 失踪. 请参阅 最低限额函数从集合中获取最小元素。

*例子*

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

# *`基地。麦克斯`*-函数

max(x, y, ...)

返回参数的最大值，相对于 无为. 如果任何参数是 失踪，返回 失踪. 请参阅 最大值函数从集合中获取最大元素。

*例子*

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

# *`基地。最大值`*-函数

minmax(x, y)

回来吧 (最小(x,y),最大(x,y)).

请参阅 极值,极值返回 (最小(x),最大(x)).

*例子*

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

# *`基地。夹钳/夹钳`*-函数

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

夹钳/夹钳 x 在射程内 r.

兼容性

Julia1.6此方法至少需要Julia1.6。

clamp(x, T)::T

夹钳/夹钳 x 之间 打字(T) 和 打字(T) 并将结果转换为类型 T.

请参阅 [医].

*例子*

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

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

clamp(x, lo, hi)

回来吧 x 如果 lo<=x<=hi. 如果 x>嗨，返回 嗨。. 如果 x<lo，返回 洛. 参数被提升为通用类型。

请参阅 钳子！, 敏, 麦克斯.

兼容性

朱莉娅1.3 失踪 作为第一个参数至少需要Julia1.3。

*例子*

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!(array::AbstractArray, lo, hi)

将值限制在 阵列 到指定范围，就地。请参阅 夹钳/夹钳.

兼容性

朱莉娅1.3 失踪 参赛作品 阵列 至少需要Julia1.3。

*例子*

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.

何时 腹肌 应用于有符号整数，可能会发生溢出，导致返回负值。此溢出仅在以下情况下发生 腹肌 应用于有符号整数的最小可表示值。也就是说，当 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])  # overflow at typemin(Int8)
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

# *`基地。检查过`*-模式_

Checked

Checked模块为内置有符号和无符号整数类型提供算术函数，当发生溢出时会引发错误。他们的名字就像 检查/检查, 检查_div 等。此外, add_with_overflow, 子_with_overflow, mul_with_overflow 返回未选中的结果和表示存在溢出的布尔值。

# *`基地。检查过了。检查_abs`*-函数

Base.checked_abs(x)

计算方法 abs(x)，在适用的情况下检查溢出错误。例如，标准二的补码有符号整数（例如 Int型)不能代表 abs(typemin(Int))，从而导致溢出。

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。支票-支票`*-函数

Base.checked_neg(x)

计算方法 -x，在适用的情况下检查溢出错误。例如，标准二的补码有符号整数（例如 Int型)不能代表 -打字(Int)，从而导致溢出。

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。支票_add`*-函数

Base.checked_add(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查/检查`*-函数

Base.checked_sub(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查/检查`*-函数

Base.checked_mul(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查_div`*-函数

Base.checked_div(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查/检查`*-函数

Base.checked_rem(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查_fld`*-函数

Base.checked_fld(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查/检查`*-函数

Base.checked_mod(x, y)

计算方法 国防部(x,y)，在适用的情况下检查溢出错误。

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查_cld`*-函数

Base.checked_cld(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。检查_pow`*-函数

Base.checked_pow(x, y)

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

溢出保护可能会造成可察觉的性能损失。

# *`基地。检查过了。add_with_overflow`*-函数

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

计算方法 r=x+y，与国旗 f 指示是否发生溢出。

# *`基地。检查过了。子_with_overflow`*-函数

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

计算方法 r=x-y，与国旗 f 指示是否发生溢出。

# *`基地。检查过了。mul_with_overflow`*-函数

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

计算方法 r=x*y，与国旗 f 指示是否发生溢出。

# *`基地。abs2`*-函数

abs2(x)

的平方绝对值 x.

这可能比 abs(x)^2，特别是对于复杂的数字，其中 abs(x) 需要一个平方根通过 [医hypot].

请参阅 腹肌, 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 它的大小是 x 和相同的标志 y.

*例子*

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

# *`基地。签署`*-函数

sign(x)

如果返回零 x==0 和$x/

否则（即±1为实数） x).

请参阅 n.信号,信号, 零, [医副标题], 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

# *`基地。n.信号,信号`*-函数

signbit(x)

回来吧 真的 如果符号的值 x 是负的，否则 错误.

请参阅 签署和 [医副标题].

*例子*

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

# *`基地。flipsign,flipsign`*-函数

flipsign(x, y)

回来吧 x 如果它的标志被翻转 y 是消极的。例如 abs(x)=flipsign(x,x).

*例子*

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

# *`基地。sqrt,sqrt`*-Method

sqrt(x)

回来吧 .

扔一个 N.域名,域名为负 真实的争论。使用方法 综合体否定的参数，而不是获得一个 综合体结果。

前缀运算符 √ 相当于 sqrt,sqrt.

分支切割 sqrt,sqrt 具有沿负实轴切割的分支; -0.0im 被取为在轴的下方。

请参阅: [医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 is below the branch cut
0.0 - 9.0im

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

# *`基地。isqrt`*-函数

isqrt(n::Integer)

整数平方根：最大的整数 m 这样， m&ast;m<=n.

julia> isqrt(5)
2

# *`基地。数学。银监会`*-Method

cbrt(x::Real)

返回多维数据集根 x，即 . 负值被接受（返回负实根时 ).

前缀运算符 ∛ 相当于 银监会.

*例子*

julia> cbrt(big(27))
3.0

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

# *`基地。数学。第四根`*-Method

fourthroot(x)

返回第四根 x 通过申请 sqrt,sqrt 先后两次。

# *`基地。真实的`*-函数

real(A::AbstractArray)

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

相当于 真实的。(一)，除了当 eltype(A)<:真实 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

real(T::Type)

返回表示类型值的实部的类型 T. 例如：对于 T==复杂{R},回报 R. 相当于 类型(真实(零(T))).

*例子*

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(z)

返回复数的实数部分 z.

请参阅: 伊马格, 雷姆, 综合体, 伊斯雷亚尔, 真实的.

*例子*

julia> real(1 + 3im)
1

# *`基地。伊马格`*-函数

imag(A::AbstractArray)

返回一个数组，其中包含数组中每个条目的虚部 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

imag(z)

返回复数的虚部 z.

请参阅: [医], 雷姆, 伴随,伴随, 角度.

*例子*

julia> imag(1 + 3im)
3

# *`基地。雷姆`*-函数

reim(A::AbstractArray)

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

相当于 （真实的。（A），imag。（一）），除了当 eltype(A)<:真实 A 返回而不复制以表示真实部分，并且当 A 具有零维，返回0维数组（而不是标量）。

*例子*

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

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

reim(z)

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

*例子*

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

# *`基地。[医]`*-函数

conj(A::AbstractArray)

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

相当于 conj。(一)，除了当 eltype(A)<:真实 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

conj(z)

计算复数的复共轭 z.

请参阅: 角度, 伴随,伴随.

*例子*

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

# *`基地。角度`*-函数

angle(z)

以复数弧度计算相位角 z.

返回一个数字 -pi≤角度(z)≤pi，并且由此沿负实轴不连续。

请参阅: 阿坦, 独联体, 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) 通过使用欧拉公式: .

请参阅 西斯皮, 辛科斯, exp, 角度.

*例子*

julia> cis(π) ≈ -1
true

# *`基地。西斯皮`*-函数

cispi(x)

更准确的方法 顺式(pi*x) （特别是对于大 x).

请参阅 独联体, 辛科斯皮, exp, 角度.

*例子*

julia> cispi(10000)
1.0 + 0.0im

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

兼容性

Julia1.6此功能需要Julia1.6或更高版本。

# *`基地。二项式`*-函数

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

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

何时 k<0 它返回零。

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

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

*外部链接*

*二项式系数。

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

的_二项式系数_ ，是多项式展开中的th项 .

如果是非负的，那么它是选择的方式的数量 k 出的 n 项目:

哪里是 阶乘功能。

如果是负的，那么它是根据身份来定义的

请参阅 阶乘.

*例子*

julia> binomial(5, 3)
10

julia>阶乘(5)÷(阶乘(5-3)&ast;阶乘(3))
10

julia>二项式（-5,3）
-35

*外部链接*

*二项式系数。

# *`基地。阶乘`*-函数

factorial(n::Integer)

阶乘的 n. 如果 n 是一个 整数，阶乘计算为整数（提升为至少64位）。请注意，如果 n 是不小，但你可以使用 阶乘(大(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`*-函数

gcd(x, y...)

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

是除数如果存在整数这样， .

兼容性

Julia1.4Rational arguments需要Julia1.4或更高版本。

*例子*

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.4Rational arguments需要Julia1.4或更高版本。

*例子*

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`*-函数

gcdx(a, b...)

计算的最大公约数（正）除数 a 和 b 和它们的Bézout系数，即整数系数 u 和 v 那就满足了 . 申报表 .

对于两个以上的参数，即, gcdx(a,b,c,...) 递归计算Bézout系数，返回一个解 （d，u，v，w，。..) 到 .

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

兼容性

Julia1.4Rational arguments需要Julia1.4或更高版本。

兼容性

Julia1.12比两个更多或更少的参数需要Julia1.12或更高版本。

*例子*

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

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

julia> gcdx(15, 12, 20)
(1, 7, -7, -1)

[注] ==== 注意Bézout系数是_not_唯一定义的。 gcdx 返回由扩展欧几里德算法计算的最小Bézout系数。（Ref：D.Knuth，TAoCP，2/e，p.325，Algorithm X.）对于有符号整数，这些系数 u 和 v 在这个意义上是最小的。 ====

b/d

a/d

$. 此外， u 和 v 被选择是为了 d 是肯定的。对于无符号整数，系数 u 和 v 可能在他们附近 打字,打字，然后身份仅通过无符号整数的模算术保持。

# *`基地。ispow2`*-函数

ispow2(n::Number) -> Bool

测试是否 n 是2的整数次幂。

请参阅 n.计数,计数, 普雷普波, 下一条.

*例子*

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中添加了参数。

# *`基地。下一条`*-函数

nextpow(a, x)

最小的 a^n 不少于 x，在哪里 n 为非负整数。 a 必须大于1，并且 x 必须大于0。

请参阅 普雷普波.

*例子*

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 必须大于1，并且 x 不得小于1。

请参阅 下一条, isqrt.

*例子*

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

朱莉娅>prevpow(4,16)
16

# *`基地。下一个产品`*-函数

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

下一个大于或等于的整数 n 这可以写成对于整数 , ，等等，对于因素在 因素.

*例子*

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

julia> 2^2 &ast; 3^3
108

兼容性

Julia1.6接受元组的方法需要Julia1.6或更高版本。

# *`基地。因弗莫德`*-函数

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

计算的模块化逆 n 型的整数环中 T，即模 2^N 哪里 N=8*sizeof（T） （例如 N=32 为 Int32). 换句话说，这些方法满足以下身份:

n &ast; invmod(n) == 1
(n &ast; invmod(n, T)) % T == 1
(n % T) &ast; invmod(n, T) == 1

请注意 * 这里是整数环中的模块化乘法, T. 这将抛出一个错误，如果 n 是偶数，因为这样它就不是相对素数 2^N 因此没有这样的逆。

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

与使用以下算法的一般情况相比，计算模逆的效率要高得多https://arxiv.org/pdf/2204.04342.pdf…

兼容性

朱莉娅1.11 invmod(n) 和 invmod(n,T) 方法需要Julia1.11或更高版本。

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

取的逆 n 模数,模数 m: y 这样，，而 . 这将抛出一个错误，如果，或者如果 .

*例子*

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

# *`基地。[医]powermod`*-函数

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

# *`基地。n.尼吉特`*-函数

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

计算整数位数 n 写在基地 基地 (基地 不得在 [-1, 0, 1]），可选地用零填充到指定的大小（结果永远不会小于 垫,垫).

请参阅 数字, n.计数,计数.

*例子*

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

# *`基地。add_sum`*-函数

Base.add_sum(x, y)

中使用的还原运算符 总和. 主要区别于 +是小整数被提升为 Int型/UInt的.

# *`基地。宽幅,宽幅`*-函数

widemul(x, y)

乘以 x 和 y，给出结果作为更大的类型。

请参阅 推广, 基地。add_sum.

*例子*

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

julia> typemax(Int8) &ast; typemax(Int8)
1

julia>widemul（typemax（Int8），typemax（Int8））＃==127^2
16129

# *`基地。数学。[医]评价`*-函数

evalpoly(x, p)

评估多项式 ]为系数 p[1], p[2], …;也就是说，系数按幂的升序给出 x. 如果系数的数量是静态已知的，则在编译时展开循环，即当 p 是一个 元组. 此函数使用Horner方法生成高效代码，如果 x 是真实的，或者使用类似Goertzel的脚注：DK62[Donald Knuth，计算机编程艺术，第2卷：Seminumerical Algorithms，第4.6.4节。]算法if x 是复杂的。

兼容性

Julia1.4此功能需要Julia1.4或更高版本。

*例子*

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

# *`基地。数学。@evalpoly`*-马科罗_

@evalpoly(z, c...)

评估多项式 ]为系数 c[1], c[2], …;也就是说，系数按幂的升序给出 z. 此宏扩展为使用Horner方法或复杂的高效内联代码 z，更有效的类似Goertzel的算法。

请参阅 [医评价].

*例子*

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

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

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

# *`基地。快速数学。@fastmath`*-马科罗_

@fastmath expr

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

这设置了https://llvm.org/docs/LangRef.html#fast-math-flags[LLVM快速数学标志]，并对应于 -快速数学 选择在叮当。见性能注释说明了解更多细节。

*例子*

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672

可自定义二进制运算符

一些unicode字符可用于定义支持中缀表示法的新二进制运算符。例如 ⊗(x,y)=kron(x,y) 定义 ⊗ （otimes）函数是Kronecker产品，可以使用中缀语法将其称为二进制运算符: C=A≠B 以及与通常的前缀语法 C=∞(A,B).

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

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

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