Mathematics

-(x)

단항 음수 연산자.

참고: abs, flipsign.

예제

julia> -1
-1

julia> -(2)
-2

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

julia> -(true)  # Int로 승격됨
-1

julia> -(0x003)
0xfffd

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

Date와 Time의 덧셈은 DateTime을 생성합니다. Time의 시, 분, 초 및 밀리초 부분은 Date의 연도, 월 및 일과 함께 사용되어 새로운 DateTime을 만듭니다. Time 유형의 비영(0이 아닌) 마이크로초 또는 나노초는 InexactError가 발생하게 됩니다.

+(x, y...)

덧셈 연산자.

중위 x+y+z+...는 이 함수를 모든 인수와 함께 호출합니다. 즉, +(x, y, z, ...)는 기본적으로 (x+y) + z + ...를 왼쪽부터 시작하여 호출합니다.

큰 수를 더할 때 기본 Int를 포함한 대부분의 정수 유형에서 오버플로우가 발생할 수 있습니다.

예제

julia> 1 + 20 + 4
25

julia> +(1, 20, 4)
25

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

julia> typemax(Int) + 1 < 0
true

-(x, y)

뺄셈 연산자.

예제

julia> 2 - 3
-1

julia> -(2, 4.5)
-2.5

*(x, y...)

곱셈 연산자.

중위 연산자 x*y*z*...는 이 함수를 모든 인수와 함께 호출합니다. 즉, *(x, y, z, ...)로 호출되며, 기본적으로 (x*y) * z * ...를 왼쪽부터 시작하여 호출합니다.

2pi와 같은 나란히 놓인 표현도 *(2, pi)를 호출합니다. 이 연산은 리터럴 *보다 우선 순위가 높다는 점에 유의하세요. 또한, 나란히 놓인 표현 "0x..." (변수 이름이 x로 시작하는 변수에 대한 정수 0)는 부호 없는 정수 리터럴과 충돌하므로 금지됩니다: 0x01 isa UInt8.

대부분의 정수 유형, 기본 Int를 포함하여, 큰 수를 곱할 때 오버플로우가 발생할 수 있습니다.

예제

julia> 2 * 7 * 8
112

julia> *(2, 7, 8)
112

julia> [2 0; 0 3] * [1, 10]  # 행렬 * 벡터
2-element Vector{Int64}:
  2
 30

julia> 1/2pi, 1/2*pi  # 나란히 놓인 표현이 더 높은 우선 순위
(0.15915494309189535, 1.5707963267948966)

julia> x = [1, 2]; x'x  # 수반 벡터 * 벡터
5

/(x, y)

오른쪽 나눗셈 연산자: y의 역수에 x를 오른쪽에서 곱합니다.

정수 인수에 대해 부동 소수점 결과를 제공합니다. 정수 나눗셈에 대해서는 ÷를, Rational 결과에 대해서는 //를 참조하세요.

예제

julia> 1/2
0.5

julia> 4/2
2.0

julia> 4.5/2
2.25

A / B

행렬 오른쪽 나누기: A / B는 (B' \ A')'와 동등하며, 여기서 \는 왼쪽 나누기 연산자입니다. 정방 행렬의 경우, 결과 X는 A == X*B를 만족합니다.

또한: rdiv!.

예제

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

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

julia> isapprox(A, X*B)
true

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

\(x, y)

왼쪽 나눗셈 연산자: x의 역수에 y를 왼쪽에서 곱하는 것입니다. 정수 인수에 대해 부동 소수점 결과를 제공합니다.

예제

julia> 3 \ 6
2.0

julia> inv(3) * 6
2.0

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

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

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

^(x, y)

지수 연산자.

x와 y가 정수인 경우 결과가 오버플로우될 수 있습니다. 과학적 표기법으로 숫자를 입력하려면 1.2 * 10^3 대신 Float64 리터럴인 1.2e3을 사용하세요.

y가 Int 리터럴(예: x^2의 2 또는 x^-3의 -3)인 경우, Julia 코드는 컴파일러에 의해 Base.literal_pow(^, x, Val(y))로 변환되어 지수의 값에 대한 컴파일 타임 특수화를 가능하게 합니다. (기본적으로 우리는 Base.literal_pow(^, x, Val(y)) = ^(x,y)를 가지고 있으며, 일반적으로 ^ == Base.^입니다. 단, ^가 호출 네임스페이스에서 정의되지 않은 경우에 한합니다.) y가 음의 정수 리터럴인 경우, 기본적으로 Base.literal_pow는 연산을 inv(x)^-y로 변환하며, 여기서 -y는 양수입니다.

또한 exp2, <<를 참조하세요.

예제

julia> 3^5
243

julia> 3^-1  # Base.literal_pow 사용
0.3333333333333333

julia> p = -1;

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

julia> 3.0^p
0.3333333333333333

julia> 10^19 > 0  # 정수 오버플로우
false

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

fma(x, y, z)

x*y+z를 계산하지만 중간 결과인 x*y를 반올림하지 않습니다. 일부 시스템에서는 x*y+z보다 이 작업이 상당히 더 비쌉니다. fma는 특정 알고리즘에서 정확성을 향상시키기 위해 사용됩니다. muladd를 참조하세요.

muladd(x, y, z)

결합된 곱셈-덧셈: x*y+z를 계산하지만, 성능을 위해 덧셈과 곱셈을 서로 또는 주변 연산과 병합할 수 있습니다. 예를 들어, 하드웨어가 이를 효율적으로 지원하는 경우 fma로 구현될 수 있습니다. 결과는 서로 다른 머신에서 다를 수 있으며, 상수 전파 또는 기타 최적화로 인해 동일한 머신에서도 다를 수 있습니다. fma를 참조하세요.

예제

julia> muladd(3, 2, 1)
7

julia> 3 * 2 + 1
7

muladd(A, y, z)

결합된 곱셈-덧셈, A*y .+ z, 행렬-행렬 또는 행렬-벡터 곱셈을 위한 것입니다. 결과는 항상 A*y와 같은 크기를 가지지만, z는 더 작거나 스칼라일 수 있습니다.

예제

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

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

inv(x)

x의 곱셈 역수를 반환합니다. 여기서 x*inv(x) 또는 inv(x)*x는 반올림 오차를 제외하고 one(x) (곱셈 항등원)을 생성합니다.

x가 숫자인 경우, 이는 본질적으로 one(x)/x와 동일하지만, 일부 유형의 경우 inv(x)가 약간 더 효율적일 수 있습니다.

예제

julia> inv(2)
0.5

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

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

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

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

유클리드(정수) 나눗셈의 몫. 일반적으로 분수 부분이 없는 수학적 연산 x/y와 동등합니다.

참고: cld, fld, rem, divrem.

예제

julia> 9 ÷ 4
2

julia> -5 ÷ 3
-1

julia> 5.0 ÷ 2
2.0

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

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

유클리드(정수) 나눗셈의 몫. x / y를 계산하고, 반올림 모드 r에 따라 정수로 반올림합니다. 다시 말해, 다음과 같은 양입니다.

round(x / y, r)

중간 반올림 없이.

또한 이 함수의 특수 사례인 fld 및 cld를 참조하십시오.

예제:

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

fld(x, y)

x / y보다 작거나 같은 가장 큰 정수. div(x, y, RoundDown)와 동등합니다.

또한 div, cld, fld1를 참조하세요.

예제

julia> fld(7.3, 5.5)
1.0

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

fld(x, y)는 부동 소수점 숫자의 실제 값을 기반으로 엄격하게 올림 반올림을 구현하기 때문에 직관적이지 않은 상황이 발생할 수 있습니다. 예를 들어:

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

여기서 발생하는 일은 0.1로 작성된 부동 소수점 숫자의 실제 값이 숫자 값 1/10보다 약간 크다는 것입니다. 반면 6.0은 숫자 6을 정확하게 나타냅니다. 따라서 6.0 / 0.1의 실제 값은 60보다 약간 작습니다. 나눗셈을 수행할 때, 이는 정확히 60.0으로 반올림되지만, fld(6.0, 0.1)는 항상 실제 값의 바닥을 취하므로 결과는 59.0입니다.

cld(x, y)

x / y보다 크거나 같은 가장 작은 정수. div(x, y, RoundUp)와 동일합니다.

자세한 내용은 div, fld를 참조하세요.

예제

julia> cld(5.5, 2.2)
3.0

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

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

r 범위에서 y를 찾아라. 여기서 $x ≡ y (mod n)$이고, n = length(r)이다. 즉, y = mod(x - first(r), n) + first(r)이다.

자세한 내용은 mod1를 참조하라.

예제

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

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

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

x를 y로 나눈 나머지, 또는 동등하게 y로 나눈 후 내림한 나눗셈에 대한 x의 나머지, 즉 중간 반올림 없이 계산할 경우 x - y*fld(x,y)입니다.

결과는 y와 같은 부호를 가지며, 크기는 abs(y)보다 작습니다(일부 예외가 있으니 아래의 주석을 참조하세요).

참고: rem, div, fld, mod1, invmod.

julia> mod(8, 3)
2

julia> mod(9, 3)
0

julia> mod(8.9, 3)
2.9000000000000004

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

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

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

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

y::T를 찾아라. 여기서 x ≡ y (mod n)이며, n은 T에서 표현 가능한 정수의 수이고, y는 [typemin(T),typemax(T)] 범위의 정수이다. 만약 T가 모든 정수를 표현할 수 있다면 (예: T == BigInt), 이 연산은 T로의 변환에 해당한다.

예제

julia> x = 129 % Int8
-127

julia> typeof(x)
Int8

julia> x = 129 % BigInt
129

julia> typeof(x)
BigInt

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

유클리드 나눗셈에서의 나머지로, x와 같은 부호를 가지며 y보다 크기가 작은 값을 반환합니다. 이 값은 항상 정확합니다.

참고: div, mod, mod1, divrem.

예제

julia> x = 15; y = 4;

julia> x % y
3

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

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

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

y로 정수 나눗셈을 한 후 x의 나머지를 계산하며, 몫은 반올림 모드 r에 따라 반올림됩니다. 즉, 다음과 같은 양입니다.

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

중간 반올림 없이.

• r == RoundNearest인 경우, 결과는 정확하며 구간 $[-|y| / 2, |y| / 2]$에 있습니다. RoundNearest를 참조하십시오.
• r == RoundToZero(기본값)인 경우, 결과는 정확하며 x가 양수일 때 구간 $[0, |y|)$에, 그렇지 않으면 $(-|y|, 0]$에 있습니다. RoundToZero를 참조하십시오.
• r == RoundDown인 경우, 결과는 y가 양수일 때 구간 $[0, y)$에, 그렇지 않으면 $(y, 0]$에 있습니다. x와 y의 부호가 다르고 abs(x) < abs(y)인 경우 결과가 정확하지 않을 수 있습니다. RoundDown를 참조하십시오.
• r == RoundUp인 경우, 결과는 y가 양수일 때 구간 $(-y, 0]$에, 그렇지 않으면 $[0, -y)$에 있습니다. x와 y의 부호가 같고 abs(x) < abs(y)인 경우 결과가 정확하지 않을 수 있습니다. RoundUp를 참조하십시오.
• r == RoundFromZero인 경우, 결과는 y가 양수일 때 구간 $(-y, 0]$에, 그렇지 않으면 $[0, -y)$에 있습니다. x와 y의 부호가 같고 abs(x) < abs(y)인 경우 결과가 정확하지 않을 수 있습니다. RoundFromZero를 참조하십시오.

예제:

julia> x = 9; y = 4;

julia> x % y  # rem(x, y)와 동일
1

julia> x ÷ y  # div(x, y)와 동일
2

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

rem2pi(x, r::RoundingMode)

x를 2π로 정수 나눈 나머지를 계산하며, 몫은 반올림 모드 r에 따라 반올림됩니다. 즉, 다음과 같은 양입니다.

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

중간 반올림 없이 계산됩니다. 내부적으로 2π의 고정밀 근사를 사용하므로 rem(x,2π,r)보다 더 정확한 결과를 제공합니다.

• r == RoundNearest인 경우, 결과는 구간 $[-π, π]$에 있습니다. 일반적으로 가장 정확한 결과입니다. RoundNearest도 참조하십시오.
• r == RoundToZero인 경우, 결과는 x가 양수일 때 구간 $[0, 2π]$에 있으며, 그렇지 않으면 구간 $[-2π, 0]$에 있습니다. RoundToZero도 참조하십시오.
• r == RoundDown인 경우, 결과는 구간 $[0, 2π]$에 있습니다. RoundDown도 참조하십시오.
• r == RoundUp인 경우, 결과는 구간 $[-2π, 0]$에 있습니다. RoundUp도 참조하십시오.

예제

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

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

mod2pi(x)

2π로 나눈 후의 나머지로, 범위는 $[0,2π)$입니다.

이 함수는 수치적으로 정확한 2π로 나눈 후의 나머지의 부동 소수점 표현을 계산하므로, 부동 소수점 숫자 2π로 나눈 x의 나머지를 계산하는 mod(x,2π)와는 정확히 동일하지 않습니다.

예제

julia> mod2pi(9*pi/4)
0.7853981633974481

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

유클리드 나눗셈에서의 몫과 나머지. (div(x, y, r), rem(x, y, r))와 동등합니다. 기본값 r을 사용하면 이 호출은 (x ÷ y, x % y)와 동등합니다.

참고: fldmod, cld.

예제

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

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

fldmod(x, y)

나눗셈 후 내림한 몫과 나머지. divrem(x, y, RoundDown)에 대한 편리한 래퍼입니다. (fld(x, y), mod(x, y))와 동일합니다.

참고: fld, cld, fldmod1.

fld1(x, y)

바닥 나눗셈, mod1(x,y)와 일치하는 값을 반환합니다.

또한 mod1, fldmod1를 참조하세요.

예제

julia> x = 15; y = 4;

julia> fld1(x, y)
4

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

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

mod1(x, y)

바닥 나눗셈 후의 모듈로, 양수 y에 대해 범위 $(0, y]$에서 mod(r, y) == mod(x, y)가 성립하는 값 r을 반환하고, 음수 y에 대해 범위 $[y,0)$에서 성립합니다.

정수 인수와 양수 y에 대해, 이는 mod(x, 1:y)와 같으며, 따라서 1 기반 인덱싱에 자연스럽습니다. 반면에, mod(x, y) == mod(x, 0:y-1)는 오프셋이나 보폭을 가진 계산에 자연스럽습니다.

자세한 내용은 mod, fld1, fldmod1를 참조하세요.

예제

julia> mod1(4, 2)
2

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

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

fldmod1(x, y)

반환 (fld1(x,y), mod1(x,y)).

자세한 내용은 fld1, mod1를 참조하세요.

//(num, den)

두 정수 또는 유리수를 나누어 Rational 결과를 제공합니다. 더 일반적으로, //는 정수 또는 유리 구성 요소가 있는 다른 숫자 유형의 정확한 유리 나누기에 사용할 수 있으며, 예를 들어 정수 구성 요소가 있는 복소수와 같은 경우입니다.

부동 소수점 (AbstractFloat) 인수는 //에 의해 허용되지 않습니다 (값이 유리하더라도). 인수는 Integer, Rational 또는 그 조합의 하위 유형이어야 합니다.

예제

julia> 3 // 5
3//5

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

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

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

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

주어진 정수 유형의 구성 요소를 가진 Rational 숫자로 부동 소수점 숫자 x를 근사화합니다. 결과는 tol보다 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

<<(x, n)

왼쪽 비트 시프트 연산자, x << n. n >= 0인 경우, 결과는 x를 n 비트만큼 왼쪽으로 시프트하며, 0으로 채워집니다. 이는 x * 2^n과 같습니다. n < 0인 경우, 이는 x >> -n과 같습니다.

예제

julia> Int8(3) << 2
12

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

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

자세한 내용은 >>, >>>, exp2, ldexp를 참조하세요.

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

왼쪽 비트 시프트 연산자, B << n. n >= 0인 경우 결과는 B의 요소가 n 위치만큼 뒤로 이동하며, false 값으로 채워집니다. n < 0인 경우 요소는 앞으로 이동합니다. B >> -n과 동일합니다.

예제

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

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

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

>>(x, n)

오른쪽 비트 시프트 연산자, x >> n. n >= 0인 경우, 결과는 x를 n 비트만큼 오른쪽으로 시프트하며, x >= 0일 경우 0으로 채우고, x < 0일 경우 1로 채워 x의 부호를 유지합니다. 이는 fld(x, 2^n)과 동일합니다. n < 0인 경우, 이는 x << -n과 동일합니다.

예제

julia> Int8(13) >> 2
3

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

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

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

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

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

또한 >>>, <<를 참조하세요.

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

오른쪽 비트 시프트 연산자, B >> n. n >= 0인 경우, 결과는 B의 요소가 n 위치만큼 앞으로 이동하며, false 값으로 채워집니다. n < 0인 경우, 요소가 뒤로 이동합니다. B << -n과 동일합니다.

예제

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

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

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

>>>(x, n)

부호 없는 오른쪽 비트 시프트 연산자, x >>> n. n >= 0인 경우, 결과는 x를 n 비트만큼 오른쪽으로 시프트하고 0으로 채웁니다. n < 0인 경우, 이는 x << -n과 같습니다.

Unsigned 정수 타입의 경우, 이는 >>와 같습니다. Signed 정수 타입의 경우, 이는 signed(unsigned(x) >> n)과 같습니다.

예제

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

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

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

BigInt는 무한 크기를 가진 것으로 간주되므로 채우기가 필요 없으며 이는 >>와 같습니다.

또한 >>, <<를 참조하세요.

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

부호 없는 오른쪽 비트 시프트 연산자, B >>> n. B >> n과 동일합니다. 자세한 내용과 예시는 >>를 참조하세요.

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

bitrotate(x, k)는 비트 회전을 구현합니다. 이는 x의 비트를 k번 왼쪽으로 회전한 값을 반환합니다. k의 음수 값은 대신 오른쪽으로 회전합니다.

참고: <<, circshift, BitArray.

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

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

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

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

:expr

표현식 expr을 인용하여 expr의 추상 구문 트리(AST)를 반환합니다. AST는 Expr, Symbol 또는 리터럴 값일 수 있습니다. 구문 :identifier는 Symbol으로 평가됩니다.

참고: Expr, Symbol, Meta.parse

예제

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

julia> sym = :some_identifier
:some_identifier

julia> value = :0xff
0xff

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

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

인수로부터 균등 간격의 요소와 최적화된 저장소를 가진 특수화된 배열 (즉, AbstractRange)을 생성합니다. 수학적으로 범위는 start, step, stop 및 length 중 임의의 세 개에 의해 고유하게 결정됩니다. 유효한 범위 호출은 다음과 같습니다:

• start, step, stop, length 중 임의의 세 개로 range를 호출합니다.
• start, stop, length 중 두 개로 range를 호출합니다. 이 경우 step은 1로 가정됩니다. 두 인수가 정수인 경우 UnitRange가 반환됩니다.
• stop 또는 length 중 하나로 range를 호출합니다. start와 step은 1로 가정됩니다.

반환된 유형에 대한 추가 세부정보는 확장 도움말을 참조하십시오. 로그 간격의 점에 대해서는 logrange도 참조하십시오.

예제

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

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

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

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

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

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

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

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

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

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

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

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

length가 지정되지 않고 stop - start가 step의 정수 배수가 아닌 경우, stop 이전에 끝나는 범위가 생성됩니다.

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

중간 값이 합리적으로 계산되도록 특별한 주의가 기울여집니다. 이로 인한 오버헤드를 피하려면 LinRange 생성자를 참조하십시오.

확장 도움말

range는 인수가 정수일 때 Base.OneTo를 생성합니다.

• 오직 length만 제공된 경우
• 오직 stop만 제공된 경우

range는 인수가 정수일 때 UnitRange를 생성합니다.

• 오직 start와 stop만 제공된 경우
• 오직 length와 stop만 제공된 경우

step이 제공된 경우, 심지어 1로 지정되더라도 UnitRange는 생성되지 않습니다.

Base.OneTo(n)

1:n처럼 동작하는 AbstractUnitRange를 정의하되, 하한이 1로 보장된다는 점에서 타입 시스템에 의해 보장됩니다.

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

범위 r는 r[i]가 타입 T의 값을 생성하는 범위입니다(첫 번째 형태에서 T는 자동으로 유추됩니다). 이는 ref 값, step, 및 길이 len으로 매개변수화됩니다. 기본적으로 ref는 시작 값 r[1]이지만, 대안으로 다른 인덱스 1 <= offset <= len에 대해 r[offset]의 값으로 제공할 수 있습니다. a:b 또는 a:b:c 구문에서 a, b, 또는 c가 부동 소수점 숫자인 경우 StepRangeLen을 생성합니다.

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

주어진 끝점 사이에 로그적으로 간격이 있는 요소로 구성된 특수 배열을 만듭니다. 즉, 연속 요소의 비율은 길이에서 계산된 상수입니다.

이는 Python의 geomspace와 유사합니다. Mathematica의 PowerRange와는 달리, 비율이 아니라 요소의 수를 지정합니다. Python 및 Matlab의 logspace와는 달리, start 및 stop 인수는 항상 결과의 첫 번째 및 마지막 요소이며, 어떤 기본에 적용된 거듭제곱이 아닙니다.

예제

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

julia> ans[2] ≈ sqrt(10 * 4000)  # 중간 요소는 기하 평균
true

julia> range(10, 40, length=3)[2] ≈ (10 + 40)/2  # 산술 평균
true

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

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

자세한 내용은 LogRange 유형을 참조하십시오.

선형 간격의 점에 대해서는 range도 참조하십시오.

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

start와 stop 사이에 로그적으로 간격이 있는 요소를 가진 범위로, 간격은 len에 의해 조절됩니다. logrange에 의해 반환됩니다.

LinRange와 마찬가지로, 첫 번째 및 마지막 요소는 제공된 값과 정확히 일치하지만, 중간 값은 작은 부동 소수점 오류가 있을 수 있습니다. 이러한 값은 생성 시 저장된 끝점의 로그를 사용하여 계산되며, 종종 T보다 더 높은 정밀도로 저장됩니다.

예제

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

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

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

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

정수 eltype T는 허용되지 않습니다. 예를 들어 round.(Int, xs)를 사용하거나 일부 정수 기반의 명시적인 거듭제곱을 사용하십시오:

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

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

==(x, y)

일반적인 동등성 연산자입니다. ===로 대체됩니다. 동등성 개념이 있는 모든 유형에 대해 구현되어야 하며, 이는 인스턴스가 나타내는 추상 값에 기반합니다. 예를 들어, 모든 숫자 유형은 유형을 무시하고 숫자 값으로 비교됩니다. 문자열은 인코딩을 무시하고 문자 시퀀스로 비교됩니다. 동일한 유형의 컬렉션은 일반적으로 키 집합을 비교하며, 이들이 ==이면 각 키에 대한 값을 비교하여 모든 쌍이 ==이면 true를 반환합니다. 다른 속성은 일반적으로 고려되지 않습니다(예: 정확한 유형).

이 연산자는 부동 소수점 수에 대한 IEEE 의미론을 따릅니다: 0.0 == -0.0 및 NaN != NaN.

결과는 Bool 유형이며, 피연산자 중 하나가 missing인 경우 missing이 반환됩니다 (삼값 논리). 컬렉션은 일반적으로 all과 유사한 삼값 논리를 구현하며, 피연산자 중 하나라도 누락된 값을 포함하면 누락을 반환하고 다른 모든 쌍이 같으면 true를 반환합니다. 항상 Bool 결과를 얻으려면 isequal 또는 ===를 사용하십시오.

구현

새로운 숫자 유형은 이 함수를 새 유형의 두 인수에 대해 구현하고 가능한 경우 프로모션 규칙을 통해 다른 유형과의 비교를 처리해야 합니다.

isequal는 ==로 대체되므로 ==의 새로운 메서드는 Dict 유형이 키를 비교하는 데 사용됩니다. 귀하의 유형이 사전 키로 사용될 경우, 따라서 hash도 구현해야 합니다.

어떤 유형이 ==, isequal, 및 isless를 정의하는 경우, 비교의 일관성을 보장하기 위해 <도 구현해야 합니다.

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

같지 않음 비교 연산자. 항상 ==와 반대의 답을 제공합니다.

구현

새로운 유형은 일반적으로 이를 구현하지 않고, 대신 기본 정의 !=(x,y) = !(x==y)에 의존해야 합니다.

예제

julia> 3 != 2
true

julia> "foo" ≠ "foo"
false

!=(x)

x와 !=를 사용하여 인수를 비교하는 함수를 만듭니다. 즉, y -> y != x와 동등한 함수입니다. 반환된 함수는 Base.Fix2{typeof(!=)} 유형이며, 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

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

항상 ===와 반대의 답변을 제공합니다.

예시

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

julia> a ≢ b
true

julia> a ≢ a
false

<(x, y)

작은 비교 연산자. isless로 대체됩니다. 부동 소수점 NaN 값의 동작 때문에 이 연산자는 부분 순서를 구현합니다.

구현

표준 부분 순서를 가진 새로운 유형은 새로운 유형의 두 인수에 대해 이 함수를 구현해야 합니다. 표준 전체 순서를 가진 유형은 대신에 isless를 구현해야 합니다.

또한 isunordered를 참조하십시오.

예제

julia> 'a' < 'b'
true

julia> "abc" < "abd"
true

julia> 5 < 3
false

<(x)

x와 비교하는 함수를 생성합니다. 이 함수는 <를 사용하여 y -> y < x와 동등한 함수입니다. 반환된 함수는 Base.Fix2{typeof(<)} 유형이며, 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

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

작거나 같음 비교 연산자. (x < y) | (x == y)로 대체됩니다.

예제

julia> 'a' <= 'b'
true

julia> 7 ≤ 7 ≤ 9
true

julia> "abc" ≤ "abc"
true

julia> 5 <= 3
false

<=(x)

x와 비교하는 함수를 생성합니다 <=, 즉 y -> y <= x와 동등한 함수입니다. 반환된 함수는 Base.Fix2{typeof(<=)} 유형이며, 이는 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

>(x, y)

보다 큰 비교 연산자. y < x로 대체됩니다.

구현

일반적으로 새로운 타입은 이 함수를 대신하여 <를 구현하고, 대체 정의 >(x, y) = y < x에 의존해야 합니다.

예제

julia> 'a' > 'b'
false

julia> 7 > 3 > 1
true

julia> "abc" > "abd"
false

julia> 5 > 3
true

>(x)

x와 >를 사용하여 인수를 비교하는 함수를 만듭니다. 즉, y -> y > x와 동등한 함수입니다. 반환된 함수는 Base.Fix2{typeof(>)} 유형이며, 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

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

크거나 같은 비교 연산자. y <= x로 대체됩니다.

예제

julia> 'a' >= 'b'
false

julia> 7 ≥ 7 ≥ 3
true

julia> "abc" ≥ "abc"
true

julia> 5 >= 3
true

>=(x)

x와 비교하는 함수를 생성합니다. 이 함수는 >=를 사용하여 y -> y >= x와 동등한 함수입니다. 반환된 함수는 Base.Fix2{typeof(>=)} 유형이며, 특수화된 메서드를 구현하는 데 사용할 수 있습니다.

cmp(x,y)

x가 y보다 작으면 -1, 같으면 0, 크면 1을 반환합니다. isless에 의해 구현된 전체 순서를 사용합니다.

예제

julia> cmp(1, 2)
-1

julia> cmp(2, 1)
1

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

cmp(<, x, y)

x가 y보다 작으면 -1, 같으면 0, 크면 1을 반환합니다. 첫 번째 인자는 사용할 "작다" 비교 함수를 지정합니다.

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

두 문자열을 비교합니다. 두 문자열의 길이가 같고 각 인덱스의 문자가 두 문자열에서 동일하면 0을 반환합니다. a가 b의 접두사이거나 a가 알파벳 순서에서 b보다 앞에 오면 -1을 반환합니다. b가 a의 접두사이거나 b가 알파벳 순서에서 a보다 앞에 오면 1을 반환합니다(기술적으로는 유니코드 코드 포인트에 의한 사전식 순서).

예제

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

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

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

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

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

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

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

~(x)

비트 반전.

참고: !, &, |.

예제

julia> ~4
-5

julia> ~10
-11

julia> ~true
false

x & y

비트 단위 AND. 삼값 논리를 구현하며, 한 피연산자가 missing이고 다른 피연산자가 true인 경우 missing를 반환합니다. 함수 적용 형태를 위해 괄호를 추가하세요: (&)(x, y).

또한: |, xor, &&를 참조하세요.

예제

julia> 4 & 10
0

julia> 4 & 12
4

julia> true & missing
missing

julia> false & missing
false

x | y

비트wise or. 삼값 논리를 구현하며, 한 피연산자가 missing이고 다른 피연산자가 false인 경우 missing를 반환합니다.

참고: &, xor, ||.

예제

julia> 4 | 10
14

julia> 4 | 1
5

julia> true | missing
true

julia> false | missing
missing

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

x와 y의 비트 단위 배타적 OR. 삼값 논리를 구현하며, 인수 중 하나가 missing인 경우 missing를 반환합니다.

중위 연산 a ⊻ b는 xor(a,b)의 동의어이며, ⊻는 Julia REPL에서 \xor 또는 \veebar를 탭 완성하여 입력할 수 있습니다.

예제

julia> xor(true, false)
true

julia> xor(true, true)
false

julia> xor(true, missing)
missing

julia> false ⊻ false
false

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

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

x와 y의 비트 단위 nand(논리곱의 부정). 삼값 논리를 구현하며, 인수 중 하나가 missing인 경우 missing를 반환합니다.

중위 연산 a ⊼ b는 nand(a,b)의 동의어이며, ⊼는 Julia REPL에서 \nand 또는 \barwedge를 탭 완성하여 입력할 수 있습니다.

예제

julia> nand(true, false)
true

julia> nand(true, true)
false

julia> nand(true, missing)
missing

julia> false ⊼ false
true

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

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

x와 y의 비트 단위 nor (not or). 삼값 논리를 구현하며, 인수 중 하나가 missing이고 다른 하나가 true가 아닐 경우 missing를 반환합니다.

중위 연산 a ⊽ b는 nor(a,b)의 동의어이며, ⊽는 Julia REPL에서 \nor 또는 \barvee를 탭 완성하여 입력할 수 있습니다.

예제

julia> nor(true, false)
false

julia> nor(true, true)
false

julia> nor(true, missing)
false

julia> false ⊽ false
true

julia> false ⊽ missing
missing

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

!(x)

부울 부정. 삼값 논리를 구현하며, x가 missing인 경우 missing를 반환합니다.

비트 단위 부정에 대해서는 ~를 참조하세요.

예제

julia> !true
false

julia> !false
true

julia> !missing
missing

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

!f::Function

프레디케이트 함수 부정: !의 인수가 함수일 때, f의 불리언 부정을 계산하는 합성 함수를 반환합니다.

자세한 내용은 ∘를 참조하세요.

예제

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

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

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

x && y

단락 평가 불리언 AND.

또한 &, 삼항 연산자 ? :, 및 제어 흐름 매뉴얼 섹션을 참조하십시오.

예제

julia> x = 3;

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

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

x || y

단락 평가 불리언 OR.

참고: |, xor, &&.

예제

julia> pi < 3 || ℯ < 3
true

julia> false || true || println("둘 다 참이 아닙니다!")
true

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

부정확한 동등성 비교. 두 숫자는 상대적 거리 또는 절대적 거리가 허용 오차 범위 내에 있을 경우 동등하다고 비교됩니다: isapprox는 norm(x-y) <= max(atol, rtol*max(norm(x), norm(y)))일 때 true를 반환합니다. 기본 atol(절대 허용 오차)은 0이며 기본 rtol(상대 허용 오차)은 x와 y의 유형에 따라 달라집니다. 키워드 인수 nans는 NaN 값이 동등한 것으로 간주되는지 여부를 결정합니다(기본값은 false).

실수 또는 복소수 부동 소수점 값의 경우, atol > 0이 지정되지 않으면 rtol은 x 또는 y의 유형 중 더 큰 값의 eps의 제곱근으로 기본 설정됩니다(가장 정밀도가 낮음). 이는 약 절반의 유효 숫자의 동등성을 요구하는 것에 해당합니다. 그렇지 않은 경우, 예를 들어 정수 인수의 경우 또는 atol > 0이 제공된 경우 rtol은 기본값이 0입니다.

norm 키워드는 숫자 (x,y)에 대해 기본적으로 abs로 설정되며, 배열에 대해서는 LinearAlgebra.norm으로 설정됩니다(대체 norm 선택이 때때로 유용할 수 있습니다). x와 y가 배열인 경우, norm(x-y)가 유한하지 않으면(즉, ±Inf 또는 NaN), 비교는 x와 y의 모든 요소가 구성 요소별로 대략 동등한지 확인하는 것으로 되돌아갑니다.

이진 연산자 ≈는 기본 인수로 isapprox와 동일하며, x ≉ y는 !isapprox(x,y)와 동일합니다.

x ≈ 0(즉, 기본 허용 오차로 0과 비교하는 것)은 기본 atol이 0이므로 x == 0과 동일합니다. 이러한 경우 적절한 atol을 제공하거나(또는 norm(x) ≤ atol을 사용) 코드를 재배치해야 합니다(예: x ≈ y를 사용하기보다는 x - y ≈ 0을 사용). 비제로 atol을 자동으로 선택하는 것은 불가능합니다. 이는 문제의 전체 스케일링(즉, "단위")에 따라 달라지기 때문입니다: 예를 들어, x - y ≈ 0에서 atol=1e-9는 x가 미터 단위의 지구의 반지름일 경우 터무니없이 작은 허용 오차이지만, x가 미터 단위의 수소 원자의 반지름일 경우 터무니없이 큰 허용 오차입니다.

예제

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

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

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

julia> 0.1 + 1e-10 ≈ 0.1
true

julia> 1e-10 ≈ 0
false

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

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

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

≈를 사용하여 인수를 x와 비교하는 함수를 만듭니다. 즉, y -> y ≈ x와 동등한 함수입니다.

여기서 지원되는 키워드 인수는 2인수 isapprox와 동일합니다.

sin(x)

x의 사인 값을 계산합니다. 여기서 x는 라디안 단위입니다.

자세한 내용은 sind, sinpi, sincos, cis, asin를 참조하세요.

예제

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

julia> sind(45)
0.7071067811865476

julia> sinpi(1/4)
0.7071067811865475

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

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

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

cos(x)

x가 라디안일 때 x의 코사인을 계산합니다.

또한 cosd, cospi, sincos, cis를 참조하세요.

sincos(x)

동시에 x의 사인과 코사인을 계산합니다. 여기서 x는 라디안 단위이며, 튜플 (sine, cosine)을 반환합니다.

또한 cis, sincospi, sincosd를 참조하세요.

tan(x)

x가 라디안 단위일 때 x의 탄젠트를 계산합니다.

sind(x)

x가 도 단위일 때 x의 사인 값을 계산합니다. x가 행렬인 경우, x는 정사각형 행렬이어야 합니다.

cosd(x)

x의 코사인을 계산합니다. 여기서 x는 도 단위입니다. x가 행렬인 경우, x는 정방 행렬이어야 합니다.

tand(x)

x가 도 단위일 때 x의 탄젠트를 계산합니다. x가 행렬인 경우, x는 정방 행렬이어야 합니다.

sincosd(x)

동시에 x의 사인과 코사인을 계산합니다. 여기서 x는 도 단위입니다.

sinpi(x)

\[\sin(\pi x)\]

를 sin(pi*x)보다 더 정확하게 계산합니다. 특히 큰 x에 대해 그렇습니다.

또한 sind, cospi, sincospi를 참조하세요.

cospi(x)

\[\cos(\pi x)\]

를 cos(pi*x)보다 더 정확하게 계산합니다. 특히 큰 x에 대해.

tanpi(x)

\[\tan(\pi x)\]

를 tan(pi*x)보다 더 정확하게 계산합니다, 특히 큰 x에 대해.

또한 tand, sinpi, cospi, sincospi를 참조하십시오.

sincospi(x)

동시에 sinpi(x)와 cospi(x) (여기서 x는 라디안 단위의 π*x의 사인과 코사인)를 계산하여 튜플 (sine, cosine)을 반환합니다.

또한 참조: cispi, sincosd, sinpi.

sinh(x)

x의 쌍곡선 사인(hyperbolic sine)을 계산합니다.

cosh(x)

x의 쌍곡선 코사인 값을 계산합니다.

tanh(x)

x의 쌍곡선 탄젠트를 계산합니다.

자세한 내용은 tan, atanh를 참조하세요.

예제

julia> tanh.(-3:3f0)  # 여기서 3f0은 Float32입니다.
7-element Vector{Float32}:
 -0.9950548
 -0.9640276
 -0.7615942
  0.0
  0.7615942
  0.9640276
  0.9950548

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

asin(x)

x의 역 사인 값을 계산하며, 출력은 라디안 단위입니다.

출력이 도 단위인 asind도 참조하세요.

예제

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

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

acos(x)

x의 역코사인 값을 계산하며, 출력은 라디안 단위입니다.

atan(y)
atan(y, x)

y 또는 y/x의 역탄젠트를 계산합니다.

하나의 실수 인수에 대해, 이는 양의 x-축과 점 (1, y) 사이의 라디안 각도로, $[-\pi/2, \pi/2]$ 구간의 값을 반환합니다.

두 개의 인수에 대해, 이는 양의 x-축과 점 (x, y) 사이의 라디안 각도로, $[-\pi, \pi]$ 구간의 값을 반환합니다. 이는 표준 atan2 함수에 해당합니다. 관례에 따라 atan(0.0,x)는 $\pi$로 정의되고, atan(-0.0,x)는 x < 0일 때 $-\pi$로 정의됩니다.

도에 대한 atand도 참조하십시오.

예제

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

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

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

asind(x)

x의 역 사인 값을 계산하며, 출력은 도 단위입니다. x가 행렬인 경우, x는 정사각형 행렬이어야 합니다.

acosd(x)

x의 역코사인을 계산하며, 출력은 도 단위입니다. x가 행렬인 경우, x는 정사각형 행렬이어야 합니다.

atand(y)
atand(y,x)

y 또는 y/x의 역탄젠트를 계산하며, 출력은 도 단위입니다.

sec(x)

x가 라디안일 때 x의 시컨트(secant)를 계산합니다.

csc(x)

x가 라디안일 때 x의 코시컨트를 계산합니다.

cot(x)

x가 라디안 단위일 때 x의 코탄젠트를 계산합니다.

secd(x)

x가 도 단위일 때 x의 시컨트를 계산합니다.

cscd(x)

x가 도 단위일 때 x의 코시컨트를 계산합니다.

cotd(x)

x가 도 단위일 때 x의 코탄젠트를 계산합니다.

asec(x)

x의 역 시컨트(asec)를 계산합니다. 출력은 라디안 단위입니다.

acsc(x)

x의 역 코시컨트 값을 계산하며, 출력은 라디안 단위입니다.

acot(x)

x의 역 코탄젠트를 계산합니다. 출력은 라디안 단위입니다.

asecd(x)

x의 역 시컨트 값을 계산하며, 출력은 도 단위입니다. x가 행렬인 경우, x는 정방 행렬이어야 합니다.

acscd(x)

x의 역 코시컨트 값을 계산하며, 출력은 도 단위입니다. x가 행렬인 경우, x는 정방 행렬이어야 합니다.

acotd(x)

x의 역 코탄젠트를 계산하며, 출력은 도 단위입니다. x가 행렬인 경우, x는 정사각형 행렬이어야 합니다.

sech(x)

x의 쌍곡선 시컨트를 계산합니다.

csch(x)

x의 쌍곡선 코시컨을 계산합니다.

coth(x)

x의 쌍곡선 코탄젠트를 계산합니다.

asinh(x)

x의 역 쌍곡선 사인 값을 계산합니다.

acosh(x)

x의 역 쌍곡선 코사인 값을 계산합니다.

atanh(x)

x의 역쌍곡선 탄젠트를 계산합니다.

asech(x)

x의 역 쌍곡선 시컨트 값을 계산합니다.

acsch(x)

x의 역 쌍곡선 코세컨트를 계산합니다.

acoth(x)

x의 역 쌍곡선 코탄젠트를 계산합니다.

sinc(x)

정규화된 sinc 함수 $\operatorname{sinc}(x) = \sin(\pi x) / (\pi x)$를 계산합니다. 단, $x \neq 0$일 때는 이고, $x = 0$일 때는 $1$입니다.

또한 cosc와 그 도함수를 참조하세요.

cosc(x)

\[x \neq 0\]

일 때 $\cos(\pi x) / x - \sin(\pi x) / (\pi x^2)$를 계산하고, $x = 0$일 때는 $0$입니다. 이것은 sinc(x)의 도함수입니다.

또한 sinc를 참조하세요.

deg2rad(x)

x를 도에서 라디안으로 변환합니다.

또한 rad2deg, sind, pi를 참조하세요.

예제

julia> deg2rad(90)
1.5707963267948966

rad2deg(x)

x를 라디안에서 도로 변환합니다.

자세한 내용은 deg2rad를 참조하세요.

예제

julia> rad2deg(pi)
180.0

hypot(x, y)

두 변의 길이가 각각 $|x|$와 $|y|$인 직각삼각형의 빗변의 길이 $\sqrt{|x|^2+|y|^2}$를 계산합니다. 오버플로우와 언더플로우를 피합니다.

이 코드는 Carlos F. Borges의 hypot(a,b)에 대한 개선된 알고리즘을 설명하는 논문의 구현입니다. 이 기사는 arXiv에서 온라인으로 확인할 수 있으며, 링크는 https://arxiv.org/abs/1904.09481입니다.

hypot(x...)

여러 변의 길이가 각각 $|x_i|$인 직각삼각형의 빗변의 길이 $\sqrt{\sum |x_i|^2}$를 계산합니다. 오버플로우와 언더플로우를 피합니다.

또한 LinearAlgebra 표준 라이브러리의 norm을 참조하세요.

예제

julia> a = Int64(10)^10;

julia> hypot(a, a)
1.4142135623730951e10

julia> √(a^2 + a^2) # a^2가 오버플로우 발생
ERROR: DomainError with -2.914184810805068e18:
sqrt는 음의 실수 인수로 호출되었지만, 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. sqrt(Complex(x))를 시도해 보세요.
Stacktrace:
[...]

julia> hypot(3, 4im)
5.0

julia> hypot(-5.7)
5.7

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

julia> using LinearAlgebra

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

log(x)

x의 자연 로그를 계산합니다.

음수 Real 인수에 대해 DomainError를 발생시킵니다. 복소수 인수를 사용하여 복소수 결과를 얻으십시오. 음의 실축을 따라 분기 절단이 있으며, 이때 -0.0im은 축 아래에 있는 것으로 간주됩니다.

또한 ℯ, log1p, log2, log10를 참조하십시오.

예제

julia> log(2)
0.6931471805599453

julia> log(-3)
ERROR: DomainError with -3.0:
log은 음의 실수 인수로 호출되었지만 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. log(Complex(x))를 시도하십시오.
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

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

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

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

log(b,x)

x의 밑 b 로그를 계산합니다. 음수 Real 인수에 대해 DomainError를 발생시킵니다.

예제

julia> log(4,8)
1.5

julia> log(4,2)
0.5

julia> log(-2, 3)
ERROR: DomainError with -2.0:
log는 음수 실수 인수로 호출되었지만 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. log(Complex(x))를 시도해 보세요.
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

julia> log(2, -3)
ERROR: DomainError with -3.0:
log는 음수 실수 인수로 호출되었지만 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. log(Complex(x))를 시도해 보세요.
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

!!! 주의 b가 2 또는 10의 거듭제곱인 경우, log2 또는 log10를 사용해야 합니다. 이러한 함수는 일반적으로 더 빠르고 더 정확합니다. 예를 들어,

```jldoctest
julia> log(100,1000000)
2.9999999999999996

julia> log10(1000000)/2
3.0
```

log2(x)

x의 밑이 2인 로그를 계산합니다. 음수 Real 인수에 대해 DomainError를 발생시킵니다.

참고: exp2, ldexp, ispow2.

예제

julia> log2(4)
2.0

julia> log2(10)
3.321928094887362

julia> log2(-2)
ERROR: DomainError with -2.0:
log2는 음수 실수 인수로 호출되었지만 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. log2(Complex(x))를 시도해 보세요.
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

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

log10(x)

x의 10을 밑으로 하는 로그를 계산합니다. 음수 Real 인수에 대해 DomainError를 발생시킵니다.

예제

julia> log10(100)
2.0

julia> log10(2)
0.3010299956639812

julia> log10(-2)
ERROR: DomainError with -2.0:
log10은 음수 실수 인수로 호출되었지만 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. log10(Complex(x))를 시도해 보세요.
Stacktrace:
 [1] throw_complex_domainerror(f::Symbol, x::Float64) at ./math.jl:31
[...]

log1p(x)

정확한 자연 로그 1+x의 값. Real 인수가 -1보다 작은 경우 DomainError를 발생시킵니다.

예제

julia> log1p(-0.5)
-0.6931471805599453

julia> log1p(0)
0.0

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p는 -1보다 작은 실수 인수로 호출되었지만 복소수 인수로 호출될 경우에만 복소수 결과를 반환합니다. log1p(Complex(x))를 시도해 보세요.
Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
[...]

frexp(val)

x의 크기가 $[1/2, 1)$ 또는 0인 (x, exp)를 반환하며, val은 x \times 2^{exp}와 같습니다.

자세한 내용은 significand, exponent, ldexp를 참조하세요.

예제

julia> frexp(6.0)
(0.75, 3)

julia> significand(6.0), exponent(6.0)  # 구간 [1, 2) 대신
(1.5, 2)

julia> frexp(0.0), frexp(NaN), frexp(-Inf)  # 지수는 오류를 발생시킴
((0.0, 0), (NaN, 0), (-Inf, 0))

exp(x)

x의 자연 밑 지수 함수를 계산합니다. 즉, $ℯ^x$입니다.

또한 exp2, exp10 및 cis를 참조하십시오.

예제

julia> exp(1.0)
2.718281828459045

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

exp2(x)

x의 밑 2 지수를 계산합니다. 즉, $2^x$입니다.

또한 ldexp, <<를 참조하세요.

예제

julia> exp2(5)
32.0

julia> 2^5
32

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

exp10(x)

x의 밑이 10인 지수를 계산합니다. 즉, $10^x$입니다.

예제

julia> exp10(2)
100.0

julia> 10^2
100

ldexp(x, n)

\[x \times 2^n\]

를 계산합니다.

자세한 내용은 frexp, exponent를 참조하세요.

예제

julia> ldexp(5.0, 2)
20.0

modf(x)

숫자의 분수 부분과 정수 부분을 포함하는 튜플 (fpart, ipart)를 반환합니다. 두 부분 모두 인수와 같은 부호를 가집니다.

예제

julia> modf(3.5)
(0.5, 3.0)

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

expm1(x)

정확하게 $e^x-1$를 계산합니다. 이는 작은 값의 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로 표현될 수 없는 경우 InexactError가 발생합니다. 이는 convert와 유사합니다.

digits 키워드 인자가 제공되면, 소수점 이하(또는 음수일 경우 소수점 위)의 지정된 자릿수로 반올림합니다. base는 10입니다.

sigdigits 키워드 인자가 제공되면, 지정된 유효 숫자 수로 반올림합니다. base는 10입니다.

RoundingMode r는 반올림 방향을 제어합니다. 기본값은 RoundNearest로, 이는 가장 가까운 정수로 반올림하며, 동점(0.5의 분수 값)은 가장 가까운 짝수 정수로 반올림됩니다. 전역 반올림 모드가 변경되면 round가 잘못된 결과를 줄 수 있습니다(자세한 내용은 rounding 참조).

부동 소수점 유형으로 반올림할 때, 해당 유형으로 표현 가능한 정수(및 Inf)로 반올림합니다. Inf는 "가장 가까운" 값을 결정하는 데 있어 floatmax(T)보다 하나 더 큰 ulp로 처리됩니다. 이는 convert와 유사합니다.

예제

julia> round(1.7)
2.0

julia> round(Int, 1.7)
2

julia> round(1.5)
2.0

julia> round(2.5)
2.0

julia> round(pi; digits=2)
3.14

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

julia> round(123.456; sigdigits=2)
120.0

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

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

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

julia> x = 1.15
1.15

julia> big(1.15)
1.149999999999999911182158029987476766109466552734375

julia> x < 115//100
true

julia> round(x, digits=1)
1.2

확장

round를 새로운 숫자 유형으로 확장하려면, 일반적으로 Base.round(x::NewType, r::RoundingMode)를 정의하는 것으로 충분합니다.

RoundingMode

부동 소수점 연산의 반올림 모드를 제어하는 데 사용되는 유형( rounding/setrounding 함수 사용) 또는 가장 가까운 정수로 반올림하기 위한 선택적 인수로 사용됩니다( round 함수 사용).

현재 지원되는 반올림 모드는 다음과 같습니다:

• RoundNearest (기본값)
• RoundNearestTiesAway
• RoundNearestTiesUp
• RoundToZero
• RoundFromZero
• RoundUp
• RoundDown

RoundNearest

기본 반올림 모드입니다. 가장 가까운 정수로 반올림하며, 동점(0.5의 분수 값)은 가장 가까운 짝수 정수로 반올림됩니다.

RoundNearestTiesAway

가장 가까운 정수로 반올림하며, 동점은 0에서 멀어지도록 반올림합니다 (C/C++ round 동작).

RoundNearestTiesUp

가장 가까운 정수로 반올림하며, 동점일 경우 양의 무한대로 반올림합니다 (Java/JavaScript round 동작).

RoundToZero

round 이 반올림 모드를 사용하는 것은 trunc의 별칭입니다.

RoundFromZero

제로에서 멀리 반올림합니다.

예제

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

RoundUp

round 이 반올림 모드를 사용하는 것은 ceil의 별칭입니다.

내림

round 이 반올림 모드를 사용하는 것은 floor의 별칭입니다.

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

복소수 값 z에 대해 지정된 RoundingMode들을 사용하여 z에 가장 가까운 정수 값을 반환합니다. 첫 번째 RoundingMode는 실수 구성 요소의 반올림에 사용되며, 두 번째는 허수 구성 요소의 반올림에 사용됩니다.

RoundingModeReal 및 RoundingModeImaginary는 기본적으로 RoundNearest로 설정되어 있으며, 이는 가장 가까운 정수로 반올림하며, 동점(0.5의 분수 값)은 가장 가까운 짝수 정수로 반올림됩니다.

예제

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

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

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

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

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

ceil(x)는 x보다 크거나 같은 x와 동일한 유형의 가장 가까운 정수 값을 반환합니다.

ceil(T, x)는 결과를 유형 T로 변환하며, ceiled 값이 T로 표현할 수 없는 경우 InexactError를 발생시킵니다.

키워드 digits, sigdigits 및 base는 round와 동일하게 작동합니다.

새로운 유형에 대해 ceil을 지원하려면 Base.round(x::NewType, ::RoundingMode{:Up})를 정의하십시오.

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

floor(x)는 x보다 작거나 같은 x와 동일한 유형의 가장 가까운 정수 값을 반환합니다.

floor(T, x)는 결과를 유형 T로 변환하며, 바닥 값이 T로 표현할 수 없는 경우 InexactError를 발생시킵니다.

키워드 digits, sigdigits 및 base는 round와 동일하게 작동합니다.

새로운 유형에 대해 floor를 지원하려면 Base.round(x::NewType, ::RoundingMode{:Down})를 정의하십시오.

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

trunc(x)는 x의 절대값보다 작거나 같은 같은 유형의 가장 가까운 정수 값을 반환합니다.

trunc(T, x)는 결과를 유형 T로 변환하며, 잘린 값이 T로 표현할 수 없는 경우 InexactError를 발생시킵니다.

키워드 digits, sigdigits 및 base는 round와 동일하게 작동합니다.

새로운 유형에 대해 trunc를 지원하려면 Base.round(x::NewType, ::RoundingMode{:ToZero})를 정의하십시오.

참고: %, floor, unsigned, unsafe_trunc.

예제

julia> trunc(2.22)
2.0

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

julia> trunc(Int, -2.22)
-2

unsafe_trunc(T, x)

타입 T의 절대값이 x의 절대값보다 작거나 같은 가장 가까운 정수 값을 반환합니다. 만약 그 값이 T로 표현할 수 없다면, 임의의 값이 반환됩니다. trunc도 참조하세요.

예제

julia> unsafe_trunc(Int, -2.2)
-2

julia> unsafe_trunc(Int, NaN)
-9223372036854775808

min(x, y, ...)

인수의 최소값을 isless에 따라 반환합니다. 인수 중 하나라도 missing인 경우 missing을 반환합니다. 컬렉션에서 최소 요소를 가져오려면 minimum 함수를 참조하세요.

예제

julia> min(2, 5, 1)
1

julia> min(4, missing, 6)
missing

max(x, y, ...)

인수의 최대값을 isless에 따라 반환합니다. 인수 중 하나라도 missing인 경우 missing을 반환합니다. 컬렉션에서 최대 요소를 가져오는 maximum 함수도 참조하십시오.

예제

julia> max(2, 5, 1)
5

julia> max(5, missing, 6)
missing

minmax(x, y)

반환: (min(x,y), max(x,y)).

또한 (minimum(x), maximum(x))을 반환하는 extrema도 참조하세요.

예제

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

clamp(x, lo, hi)

lo <= x <= hi인 경우 x를 반환합니다. x > hi인 경우 hi를 반환하고, x < lo인 경우 lo를 반환합니다. 인수는 공통 유형으로 승격됩니다.

자세한 내용은 clamp!, min, max를 참조하세요.

예제

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

julia> clamp.([11, 8, 5], 10, 6)  # lo > hi인 경우의 예
3-element Vector{Int64}:
  6
  6
 10

clamp(x, T)::T

x를 typemin(T)와 typemax(T) 사이로 제한하고 결과를 타입 T로 변환합니다.

자세한 내용은 trunc를 참조하세요.

예제

julia> clamp(200, Int8)
127

julia> clamp(-200, Int8)
-128

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

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

x를 범위 r 내에 있도록 제한합니다.

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

array의 값을 지정된 범위로 제한합니다. 제자리에서 수행됩니다. clamp도 참조하세요.

예제

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

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

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

abs(x)

x의 절대값입니다.

abs가 부호가 있는 정수에 적용될 때, 오버플로우가 발생할 수 있으며, 이로 인해 음수 값이 반환될 수 있습니다. 이 오버플로우는 abs가 부호가 있는 정수의 최소 표현 가능 값에 적용될 때만 발생합니다. 즉, x == typemin(typeof(x))일 때, abs(x) == x < 0이며, 예상할 수 있는 -x가 아닙니다.

참고: abs2, unsigned, sign.

예제

julia> abs(-3)
3

julia> abs(1 + im)
1.4142135623730951

julia> abs.(Int8[-128 -127 -126 0 126 127])  # typemin(Int8)에서 오버플로우
1×6 Matrix{Int8}:
 -128  127  126  0  126  127

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

Checked

Checked 모듈은 오버플로우가 발생할 때 오류를 발생시키는 내장된 부호 있는 및 부호 없는 정수 유형에 대한 산술 함수를 제공합니다. 이 함수들은 checked_sub, checked_div 등과 같이 명명됩니다. 또한, add_with_overflow, sub_with_overflow, mul_with_overflow는 체크되지 않은 결과와 오버플로우의 존재를 나타내는 불리언 값을 모두 반환합니다.

Base.checked_abs(x)

abs(x)를 계산하며, 해당하는 경우 오버플로우 오류를 확인합니다. 예를 들어, 표준 2의 보수 부호 있는 정수(예: Int)는 abs(typemin(Int))를 표현할 수 없으므로 오버플로우가 발생합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_neg(x)

-x를 계산하며, 해당되는 경우 오버플로우 오류를 확인합니다. 예를 들어, 표준 2의 보수 부호 있는 정수(예: Int)는 -typemin(Int)를 표현할 수 없으므로 오버플로우가 발생합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_add(x, y)

x+y를 계산하며, 해당하는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_sub(x, y)

x-y를 계산하며, 해당하는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_mul(x, y)

x*y를 계산하며, 해당되는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_div(x, y)

div(x,y)를 계산하며, 해당되는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_rem(x, y)

x%y를 계산하며, 해당되는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_fld(x, y)

fld(x,y)를 계산하며, 해당되는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_mod(x, y)

mod(x,y)를 계산하며, 해당되는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_cld(x, y)

cld(x,y)를 계산하며, 해당하는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

Base.checked_pow(x, y)

^(x,y)를 계산하며, 해당하는 경우 오버플로우 오류를 확인합니다.

오버플로우 보호는 눈에 띄는 성능 저하를 초래할 수 있습니다.

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

r = x+y를 계산하며, 플래그 f는 오버플로우가 발생했는지를 나타냅니다.

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

r = x-y를 계산하며, 플래그 f는 오버플로우가 발생했는지를 나타냅니다.

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

r = x*y를 계산하며, 플래그 f는 오버플로우가 발생했는지를 나타냅니다.

abs2(x)

x의 제곱 절대값입니다.

이는 특히 abs(x)가 hypot를 통해 제곱근을 요구하는 복소수의 경우 abs(x)^2보다 더 빠를 수 있습니다.

또한 abs, conj, real를 참조하세요.

예제

julia> abs2(-3)
9

julia> abs2(3.0 + 4.0im)
25.0

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

copysign(x, y) -> z

x의 크기를 가지며 y와 같은 부호를 가진 z를 반환합니다.

예제

julia> copysign(1, -2)
-1

julia> copysign(-1, 2)
1

sign(x)

x==0일 때는 0을 반환하고, 그렇지 않으면 $x/|x|$를 반환합니다 (즉, 실수 x에 대해 ±1).

자세한 내용은 signbit, zero, copysign, flipsign를 참조하세요.

예제

julia> sign(-4.0)
-1.0

julia> sign(99)
1

julia> sign(-0.0)
-0.0

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

signbit(x)

x의 부호 값이 음수이면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

또한 sign 및 copysign를 참조하십시오.

예제

julia> signbit(-4)
true

julia> signbit(5)
false

julia> signbit(5.5)
false

julia> signbit(-4.1)
true

flipsign(x, y)

y가 음수일 경우 x의 부호를 뒤집은 값을 반환합니다. 예를 들어 abs(x) = flipsign(x,x)입니다.

예시

julia> flipsign(5, 3)
5

julia> flipsign(5, -3)
-5

sqrt(x)

Return $\sqrt{x}$.

음수 Real 인수에 대해 DomainError를 발생시킵니다. 대신 복소수 음수 인수를 사용하세요. sqrt는 음의 실수 축을 따라 분기 절단이 있음을 유의하세요.

접두사 연산자 √는 sqrt와 동일합니다.

참고: hypot.

예제

julia> sqrt(big(81))
9.0

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

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

julia> sqrt(-81 - 0.0im)  # -0.0im은 분기 절단 아래에 있습니다
0.0 - 9.0im

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

isqrt(n::Integer)

정수 제곱근: m*m <= n을 만족하는 가장 큰 정수 m.

julia> isqrt(5)
2

cbrt(x::Real)

x의 세제곱근을 반환합니다. 즉, $x^{1/3}$입니다. 음수 값도 허용되며 ($x < 0$일 때 음의 실근을 반환합니다).

접두사 연산자 ∛는 cbrt와 동일합니다.

예제

julia> cbrt(big(27))
3.0

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

real(z)

복소수 z의 실수 부분을 반환합니다.

참고: imag, reim, complex, isreal, Real.

예제

julia> real(1 + 3im)
1

real(T::Type)

타입 T의 값의 실수 부분을 나타내는 타입을 반환합니다. 예: T == Complex{R}인 경우 R을 반환합니다. typeof(real(zero(T)))와 동등합니다.

예시

julia> real(Complex{Int})
Int64

julia> real(Float64)
Float64

real(A::AbstractArray)

배열 A의 각 항목의 실수 부분을 포함하는 배열을 반환합니다.

real.(A)와 동등하지만, eltype(A) <: Real인 경우 A는 복사 없이 반환되며, A가 0차원일 때는 스칼라 대신 0차원 배열이 반환됩니다.

예제

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

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

imag(z)

복소수 z의 허수 부분을 반환합니다.

참고: conj, reim, adjoint, angle.

예제

julia> imag(1 + 3im)
3

imag(A::AbstractArray)

배열 A의 각 항목의 허수 부분을 포함하는 배열을 반환합니다.

imag.(A)와 동등하지만, A가 0차원일 경우 스칼라 대신 0차원 배열이 반환됩니다.

예제

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

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

reim(z)

복소수 z의 실수 부분과 허수 부분을 튜플로 반환합니다.

예시

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

reim(A::AbstractArray)

A의 각 항목의 실수 부분과 허수 부분을 각각 포함하는 두 개의 배열로 이루어진 튜플을 반환합니다.

(real.(A), imag.(A))와 동등하지만, eltype(A) <: Real인 경우 A는 복사하지 않고 실수 부분을 나타내며, A가 0차원일 경우 스칼라 대신 0차원 배열이 반환됩니다.

예제

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

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

conj(z)

복소수 z의 복소수 켤레를 계산합니다.

참고: angle, adjoint.

예제

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

conj(A::AbstractArray)

배열 A의 각 항목에 대한 복소수 켤레를 포함하는 배열을 반환합니다.

conj.(A)와 동등하지만, eltype(A) <: Real인 경우 A는 복사 없이 반환되며, A가 0차원일 때는 스칼라 대신 0차원 배열이 반환됩니다.

예제

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

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

angle(z)

복소수 z의 위상 각을 라디안 단위로 계산합니다.

-pi ≤ angle(z) ≤ pi 범위의 숫자를 반환하며, 따라서 음의 실축을 따라 불연속적입니다.

참고: atan, cis, rad2deg.

예제

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

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

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

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

cis(x)

오일러의 공식을 사용하여 exp(im*x)보다 더 효율적인 방법: $\cos(x) + i \sin(x) = \exp(i x)$.

또한 cispi, sincos, exp, angle를 참조하십시오.

예제

julia> cis(π) ≈ -1
true

cispi(x)

cis(pi*x)에 대한 더 정확한 방법 (특히 큰 x에 대해).

또한 cis, sincospi, exp, angle를 참조하세요.

예제

julia> cispi(10000)
1.0 + 0.0im

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

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

이항 계수 $\binom{n}{k}$는 $(1+x)^n$의 다항식 전개에서 $k$번째 항의 계수입니다.

만약 $n$이 비음이 아닌 경우, 이는 n 항목 중 k를 선택하는 방법의 수입니다:

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

여기서 $n!$는 factorial 함수입니다.

만약 $n$이 음수인 경우, 이는 다음의 항등식으로 정의됩니다:

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

자세한 내용은 factorial를 참조하세요.

예제

julia> binomial(5, 3)
10

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

julia> binomial(-5, 3)
-35

외부 링크

• 이항 계수 위키백과.

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

일반화된 이항 계수는 k ≥ 0에 대해 다항식으로 정의됩니다.

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

k < 0인 경우에는 0을 반환합니다.

정수 x의 경우, 이는 일반적인 정수 이항 계수와 동등합니다.

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

비정수 k에 대한 추가 일반화는 수학적으로 가능하지만, 감마 함수 및/또는 베타 함수를 포함하며, 이는 Julia 표준 라이브러리에서 제공되지 않지만 SpecialFunctions.jl과 같은 외부 패키지에서 사용할 수 있습니다.

외부 링크

• 이항 계수 위키백과.

factorial(n::Integer)

n의 팩토리얼. n이 Integer인 경우, 팩토리얼은 정수로 계산되며 (최소 64비트로 승격됨) n이 작지 않으면 오버플로우가 발생할 수 있습니다. 그러나 factorial(big(n))을 사용하여 임의의 정밀도로 결과를 정확하게 계산할 수 있습니다.

또한 binomial도 참조하십시오.

예제

julia> factorial(6)
720

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

julia> factorial(big(21))
51090942171709440000

외부 링크

• 팩토리얼 위키백과.

gcd(x, y...)

최대 공약수 (양수) (또는 모든 인수가 0인 경우 0). 인수는 정수 및 유리수일 수 있습니다.

예제

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

최소 공배수 (양수) (또는 인수가 0인 경우 0). 인수는 정수 및 유리수일 수 있습니다.

예제

julia> lcm(2, 3)
6

julia> lcm(-2, 3)
6

julia> lcm(0, 3)
0

julia> lcm(0, 0)
0

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

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

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

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

gcdx(a, b)

a와 b의 최대 공약수(양수)와 그들의 베주 계수, 즉 $ua+vb = d = gcd(a, b)$를 만족하는 정수 계수 u와 v를 계산합니다. gcdx(a, b)는 $(d, u, v)$를 반환합니다.

인수는 정수 및 유리수일 수 있습니다.

예제

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

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

ispow2(n::Number) -> Bool

n이 정수 형태의 2의 거듭제곱인지 테스트합니다.

자세한 내용은 count_ones, prevpow, nextpow를 참조하세요.

예제

julia> ispow2(4)
true

julia> ispow2(5)
false

julia> ispow2(4.5)
false

julia> ispow2(0.25)
true

julia> ispow2(1//8)
true

nextpow(a, x)

x보다 작지 않은 가장 작은 a^n으로, 여기서 n은 비부호 정수입니다. a는 1보다 커야 하고, x는 0보다 커야 합니다.

자세한 내용은 prevpow를 참조하세요.

예제

julia> nextpow(2, 7)
8

julia> nextpow(2, 9)
16

julia> nextpow(5, 20)
25

julia> nextpow(4, 16)
16

prevpow(a, x)

x보다 크지 않은 가장 큰 a^n, 여기서 n은 0 이상의 정수입니다. a는 1보다 커야 하며, x는 1보다 작아서는 안 됩니다.

자세한 내용은 nextpow, isqrt를 참조하세요.

예제

julia> prevpow(2, 7)
4

julia> prevpow(2, 9)
8

julia> prevpow(5, 20)
5

julia> prevpow(4, 16)
16

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

n 이상인 다음 정수로, factors에 있는 인수 $k_i$에 대해 정수 $p_1$, $p_2$ 등을 사용하여 $\prod k_i^{p_i}$로 표현될 수 있습니다.

예시

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

julia> 2^2 * 3^3
108

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

m로 모듈로 n의 역수를 취합니다: $n y = 1 \pmod m$인 $y$와 $div(y,m) = 0$입니다. $m = 0$이거나 $gcd(n,m) \neq 1$인 경우 오류가 발생합니다.

예제

julia> invmod(2, 5)
3

julia> invmod(2, 3)
2

julia> invmod(5, 6)
5

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

n의 모듈러 역수를 정수 링의 타입 T에서 계산합니다. 즉, 2^N로 모듈로 하며, 여기서 N = 8*sizeof(T)입니다 (예: Int32의 경우 N = 32). 다시 말해, 이러한 메서드는 다음과 같은 항등식을 만족합니다:

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

여기서 *는 정수 링 T에서의 모듈러 곱셈입니다.

정수 타입에 의해 암시된 모듈러스를 명시적인 값으로 지정하는 것은 종종 불편합니다. 왜냐하면 모듈러스는 정의상 타입으로 표현하기에는 너무 크기 때문입니다.

모듈러 역수는 https://arxiv.org/pdf/2204.04342.pdf에 설명된 알고리즘을 사용하여 일반적인 경우보다 훨씬 더 효율적으로 계산됩니다.

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

\[x^p \pmod m\]

를 계산합니다.

예제

julia> powermod(2, 6, 5)
4

julia> mod(2^6, 5)
4

julia> powermod(5, 2, 20)
5

julia> powermod(5, 2, 19)
6

julia> powermod(5, 3, 19)
11

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

정수 n을 base 진수로 썼을 때의 자릿수를 계산합니다 (base는 [-1, 0, 1]이 아니어야 함) 그리고 선택적으로 지정된 크기로 0으로 패딩할 수 있습니다 (결과는 결코 pad보다 작지 않습니다).

자세한 내용은 digits, count_ones를 참조하세요.

예제

julia> ndigits(0)
1

julia> ndigits(12345)
5

julia> ndigits(1022, base=16)
3

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

julia> ndigits(123, pad=5)
5

julia> ndigits(-123)
3

Base.add_sum(x, y)

sum에서 사용되는 축소 연산자. +와의 주요 차이점은 작은 정수가 Int/UInt로 승격된다는 점이다.

widemul(x, y)

x와 y를 곱하여 결과를 더 큰 타입으로 반환합니다.

자세한 내용은 promote, Base.add_sum를 참조하세요.

예제

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

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

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

evalpoly(x, p)

다항식 $\sum_k x^{k-1} p[k]$를 평가합니다. 여기서 계수는 p[1], p[2], ...로 주어지며, 즉 계수는 x의 거듭제곱에 따라 오름차순으로 주어집니다. 계수의 수가 정적으로 알려져 있을 때, 즉 p가 Tuple일 때 루프는 컴파일 시간에 펼쳐집니다. 이 함수는 x가 실수일 때 호너의 방법을 사용하여 효율적인 코드를 생성하거나, x가 복소수일 때 Goertzel과 유사한 ^[DK62] 알고리즘을 사용하여 효율적인 코드를 생성합니다.

예제

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

@evalpoly(z, c...)

다항식 $\sum_k z^{k-1} c[k]$를 계수 c[1], c[2], ...에 대해 평가합니다. 즉, 계수는 z의 거듭제곱에 따라 오름차순으로 주어집니다. 이 매크로는 호너의 방법 또는 복소수 z의 경우 더 효율적인 고에르첼과 유사한 알고리즘을 사용하는 효율적인 인라인 코드로 확장됩니다.

자세한 내용은 evalpoly를 참조하세요.

예제

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

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

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

@fastmath expr

변환된 표현식을 실행합니다. 이 표현식은 엄격한 IEEE 의미를 위반할 수 있는 함수를 호출합니다. 이는 가능한 가장 빠른 연산을 허용하지만 결과는 정의되지 않으므로 주의해야 합니다. 이렇게 하면 수치 결과가 변경될 수 있습니다.

이것은 LLVM Fast-Math 플래그를 설정하며, clang의 -ffast-math 옵션에 해당합니다. 자세한 내용은 성능 주석에 대한 노트를 참조하십시오.

예제

julia> @fastmath 1+2
3

julia> @fastmath(sin(3))
0.1411200080598672