数学对象
数学运算符
# *'基。:-'`-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
# *'基。:+'`-Function</no-翻译>
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...)
的乘法运算符。
中缀表达式'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
# '基。:/`-Function</no-翻译>
/(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
# *'基。:\'`-Method</no-翻译>
\(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
#
'+Base。:^+'
-Method
^(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`为正数。
例子
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
真的
# '基。muladd'-Function
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'`-Method
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'-Method
div(x, y, r::RoundingMode=RoundToZero)
欧几里德(整数)除法的结果。 根据舍入模式计算`x/y’舍入为整数。 换句话说,价值
round(x / y, r)
没有任何中间舍入。
兼容性:Julia1.4
有三个参数接受’RoundingMode’的方法需要至少1.4的Julia版本。 |
兼容性: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'-Function</no-翻译>
fld(x, y)
小于或等于`x/y’的最大整数。 相当于’div(x,y,RoundDown)'。
例子
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'。
# '基。mod'-Function
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'。 |
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'-Function
rem(x, y)
%(x, y)
欧几里德除法的剩余部分,它返回一个符号等于`x’的符号并且比`y’少模的值。 此值始终是准确的。
例子
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'`-Method
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'-Function
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'-Function
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
# '基。mod1'-Function
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)`适用于具有偏移量或阵列步长的计算。
例子
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
# '基。://'-Function
//(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)
[...]
# '基。合理化'-Function
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
# '基。分子'-Function</no-翻译>
numerator(x)
有理表示的分子是’x'。
例子
julia> numerator(2//3)
2
julia> numerator(4)
4
# '基。:<<`-Function</no-翻译>
<<(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"
<<(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
# '基。:>>'-Function</no-翻译>
>>(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
# '基。:>>>`-Function</no-翻译>
>>>(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"
>>>(B::BitVector, n) -> BitVector
右边的位移运算符是无符号的,'B>>>n'。 相当于’B>>n'。 有关详细信息和示例,请参阅说明 >>
.
# '基。bitrotate'-Function
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"
# '基。::'-Function</no-翻译>
:expr
将表达式’expr`括在引号中,返回抽象语法树(AST)expr'。 AST可以具有类型`Expr
,`Symbol`或文字值。 语法':identifier’的结果是一个`符号'。
例子
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}
# '基。范围'-Function
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'。
# '基。StepRangeLen'-Type
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'-Function
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'-Type
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。 |
# '基。:==`-Function</no-翻译>
==(x, y)
通用相等运算符。 它用作备份选项 ===
. 它应该应用于所有具有相等概念的类型,基于实例表示的抽象值。 例如,所有数值类型都按数值进行比较,而不考虑类型。 字符串作为字符序列进行比较,而不考虑编码。 相同类型的集合通常通过一组键进行比较,如果它们相等(==
),则比较每个键的值。 如果所有这些对都相等(`=='),则返回值true。 通常不考虑其他属性(例如精确类型)。
运算符遵循浮点数的IEEE语义’0.0==-0.0’和’NaN!=南'。
结果是`Bool’类型,除非缺少其中一个操作数(missing'
),然后返回值’missing'(https://en.wikipedia.org/wiki/Three-valued_logic [三元逻辑])。 集合通常实现三元逻辑,如 'all':如果任何操作数包含缺失值,并且所有其他对都相等,则返回缺失值。 要始终获得’Bool’类型的结果,请使用 '等效或 ===
.
实施
新的数值类型应该具有此函数的实现,以比较新类型的两个参数,并与其他类型进行比较,如果可能的话,应用提升规则。
# *'基。:<'`-Function</no-翻译>
<(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版本。 |
# '基。:’-Function</no-翻译>
>(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版本。 |
# '基。cmp'-Function
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
# *'基。xor'`-Function
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'-Function
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'-Function
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
# '基。:!`-Function</no-翻译>
!(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'而不是匿名函数。 |
数学函数
# '基。isapprox'-Function
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'-Method
sin(x)
计算’x’的正弦,其中`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>辛皮(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
# '基。数学。辛科斯'-Method
sincos(x)
同时计算`x`的正弦和余弦,其中`x`的值以弧度设置,并返回元组`(正弦,余弦)`。
另请参阅说明 'cis', `sincospi'和 'sincosd'。
# '基。数学。sind'-Function
sind(x)
计算’x’的正弦,其中’x’的值以度为单位设置。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# '基。数学。cosd'-Function
cosd(x)
计算`x’的余弦,其中`x`的值以度为单位设置。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# '基。数学。tand'-Function
tand(x)
计算`x’的切线,其中’x’的值以度为单位设置。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# '基。数学。sincosd'-Function
sincosd(x)
同时计算`x`的正弦和余弦,其中`x`的值以度为单位设置。
兼容性:Julia1.3
此功能需要1.3或更高版本的Julia。 |
# '基。数学。sinpi'-Function
sinpi(x)
计算方法 具有比`sin(pi*x)'更高的精度,特别是对于`x’的大值。
另请参阅说明 '信德', `cospi'和 'sincospi'。
# '基。数学。tanpi'-Function
tanpi(x)
计算方法 具有比`tan(pi*x)'更高的精度,特别是对于`x’的大值。
兼容性:Julia1.10
此功能需要Julia至少1.10的版本。 |
另请参阅说明 'tand', '辛皮', `cospi'和 'sincospi'。
# *'基。tanh'`-Method
tanh(x)
计算’x’的双曲正切。
例子
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
# '基。atan'-Method
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'-Function
asind(x)
计算输出值以度为单位的`x`的弧。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# '基。数学。acosd'-Function
acosd(x)
计算`x`的arccosine,输出值以度为单位。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# '基。数学。atand'-Function
atand(y)
atand(y,x)
分别计算`y`或`y/x`的反正切,输出值以度为单位。
兼容性:Julia1.7
单参数方法支持方阵作为从Julia1.7版本开始的参数。 |
# '基。数学。asecd'-Function
asecd(x)
计算以度为单位的输出值的arcsecond`x'。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数需要至少1.7的Julia版本。 |
# '基。数学。acscd'-Function
acscd(x)
计算以度为单位的输出值的arcsecond`x'。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# '基。数学。acotd'-Function
acotd(x)
计算以度为单位的输出值的反正切`x'。 如果’x’是矩阵,那么矩阵’x’必须是正方形。
兼容性:Julia1.7
矩阵参数要求Julia版本至少为1.7。 |
# *'基。数学。hypot'`-Function
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
# '基。日志'-Method</no-翻译>
log(x)
计算`x’的自然对数。
返回错误 'DomainError'类型的负参数 '真实`。 使用复杂的参数来获得复杂的结果。 它在负实轴上有一个分支点,因此假设'-0.0im’位于轴下方。
例子
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
# '基。日志'-Method</no-翻译>
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
[...]
# '基。log2'-Function
log2(x)
计算`x`到底2的对数。 投掷物 `DomainError'表示否定 `真实'论点。
例子
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'-Function
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'-Function
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'-Function
frexp(val)
返回`(x,exp)'使得`x’的绝对值在范围内 或等于零,而’val’等于 .
例子
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))
# '基。数学。modf'-Function
modf(x)
从数字的小数部分和整数部分返回元组`(fpart,ipart)'。 这两个部分都有相同的符号作为参数。
例子
julia> modf(3.5)
(0.5, 3.0)
julia> modf(-3.5)
(-0.5, -3.0)
# '基。expm1'-Function
expm1(x)
精确计算 . 这避免了直接为x的小值计算exp(x)-1时发生的精度损失。
例子
julia> expm1(1e-16)
1.0e-16
julia> exp(1e-16) - 1
0.0
# '基。round'-Function
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以外的基数舍入到指定位数可能不准确。 例如,像这样的值
|
扩展
要将`round’扩展到新的数字类型,通常定义`Base就足够了。round(x::NewType,r::RoundingMode)'。
# '基。四舍五入。RoundingMode'—Type
RoundingMode
用于控制浮点运算的舍入模式的类型(通过 '四舍五入'/`setrounding'函数),或作为舍入到最接近的整数的可选参数(通过 `round'功能)。
目前支持的舍入模式有:
兼容性:Julia1.9
'RoundFromZero’至少需要Julia1.9。 以前的版本仅支持"BigFloat"的"RoundFromZero"。 |
# '基。四舍五入。RoundFromZero'-Constant
RoundFromZero
从零开始。
兼容性:Julia1.9
'RoundFromZero’至少需要Julia1.9。 以前的版本仅支持"BigFloat"的"RoundFromZero"。 |
例子
julia> BigFloat("1.0000000000000001", 5, RoundFromZero)
1.06
# *'基。round'`-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`的整数值 `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'`-Function
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})`.
# '基。地板'-Function
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'`-Function
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
# '基。clamp'-Function
clamp(x, lo, hi)
如果`lo<=x<=hi`,则返回`x'。 对于’x>hi',它返回’hi'。 当’x<lo’返回’lo’时。 参数被提升为通用类型。
兼容性: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版本。 |
# '基。钳子!`-Function</no-翻译>
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'-Function
abs(x)
`X’的绝对值。
当’abs’应用于有符号整数时,溢出和负值返回是可能的。 只有当`abs`应用于可以由有符号整数类型表示的最小值时,才会发生溢出,即当`x==typemin(typeof(x)),`abs(x)==x<0
,而不是像人们期望的`-x`时。
例子
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
# '基。勾选'-Module
Checked
Checked模块为返回溢出错误的内置有符号和无符号整数类型提供算术函数。 它们被称为’checked_sub','checked_div’等。 此外,'add_with_overflow','sub_with_overflow','mul_with_overflow’返回未选中的结果和指示存在溢出的布尔值。
# '基。检查过了。checked_abs'-Function
Base.checked_abs(x)
计算’abs(x)',检查溢出错误,如果适用. 例如,具有标准二进制附加代码(例如,Int
)的有符号整数不能表示’abs(typemin(Int))`,这会导致溢出。
溢出保护会导致性能明显下降。
# '基。检查过了。checked_neg'-Function
Base.checked_neg(x)
计算`-x',检查溢出错误(如果适用)。 例如,具有标准二进制附加代码(例如,Int
)的有符号整数不能表示'-typemin(Int)',这会导致溢出。
溢出保护会导致性能明显下降。
# '基。检查过了。add_with_overflow'-Function
Base.add_with_overflow(x, y) -> (r, f)
计算’r=x+y`,`f’标志表示是否发生溢出。
# '基。检查过了。sub_with_overflow'-Function
Base.sub_with_overflow(x, y) -> (r, f)
计算’r=x-y`,`f’标志表示是否发生溢出。
# '基。检查过了。mul_with_overflow'-Function
Base.mul_with_overflow(x, y) -> (r, f)
计算’r=x*y`,`f’标志表示是否发生溢出。
# '基。copysign'-Function
copysign(x, y) -> z
返回`z`的值,用符号`y`模`x'。
例子
julia> copysign(1, -2)
-1
julia> copysign(-1, 2)
1
# '基。符号'-Function
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'—Function
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'-Function
flipsign(x, y)
如果`y`的值为负数,则返回带有更改符号的`x`。 例如,'abs(x)=flipsign(x,x)'。
例子
julia> flipsign(5, 3)
5
julia> flipsign(5, -3)
-5
# '基。sqrt'-Method
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
# '基。数学。cbrt'—Method
cbrt(x::Real)
返回`x’的立方根,即 . 它也接受负值(返回负实根时 ).
前缀运算符'∛'等同于’cbrt'。
例子
julia> cbrt(big(27))
3.0
julia> cbrt(big(-27))
-3.0
# '基。real'-Function
real(z)
返回复数`z`的实部。
例子
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'`-Function
imag(z)
返回复数`z`的虚部。
例子
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'`-Function
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'-Function
conj(z)
计算复数`z’的共轭复数。
例子
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
# '基。cispi'-Function
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版本。 |
# '基。二项式'-Function
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
外部链接
-
https://en.wikipedia.org/wiki/Binomial_coefficient [二项式系数]在维基百科。
binomial(x::Number, k::Integer)
多项式为’k≥0’定义的广义二项式系数
当’k<0’返回零。
对于整数’x’相当于通常的整数二项式系数
对于非整数’k’的进一步概括在数学上是可能的,但包括gamma函数和/或beta函数,它们不是由Julia标准库提供的,但可以在外部软件包中使用,例如https://github.com/JuliaMath/SpecialFunctions.jl [特殊功能。jl]。
外部链接
-
https://en.wikipedia.org/wiki/Binomial_coefficient [二项式系数]在维基百科。
# '基。阶乘`-Function
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'-Function
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'-Function
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`-Function
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'-Function
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"以外的参数的支持。 |
# '基。nextprod'-Function
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`-Function
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'-Function
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`-Function
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
# '基。widemul'-Function
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'-Function
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'-Macro
@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'-Macro
@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'。[ - |\|| ⊕ ⊖ ⊞ ⊟ |++| ∪ ∨ ⊔ ± ∓ ∔ ∸ ≏ ⊎ ⊻ ⊽ ⋎ ⋓ ⟇ ⧺ ⧻ ⨈ ⨢ ⨣ ⨤ ⨥ ⨦ ⨧ ⨨ ⨩ ⨪ ⨫ ⨬ ⨭ ⨮ ⨹ ⨺ ⩁ ⩂ ⩅ ⩊ ⩌ ⩏ ⩐ ⩒ ⩔ ⩖ ⩗ ⩛ ⩝ ⩡ ⩢ ⩣]' 还有许多其他与箭头,比较和度有关的内容。