Numbers

숫자

모든 숫자 유형에 대한 추상 슈퍼타입입니다.

Real <: Number

모든 실수에 대한 추상 슈퍼타입입니다.

AbstractFloat <: Real

모든 부동 소수점 수에 대한 추상 슈퍼타입입니다.

Integer <: Real

모든 정수에 대한 추상 슈퍼타입(예: Signed, Unsigned, 및 Bool).

또한 isinteger, trunc, div를 참조하십시오.

예제

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true

Signed <: Integer

모든 부호 있는 정수에 대한 추상 슈퍼타입입니다.

Unsigned <: Integer

모든 부호 없는 정수에 대한 추상 슈퍼타입입니다.

내장된 부호 없는 정수는 16진수로 출력되며, 접두사 0x가 붙고 동일한 방식으로 입력할 수 있습니다.

예제

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001

AbstractIrrational <: Real

정확한 무리수를 나타내는 숫자 유형으로, 다른 숫자 양과의 산술 연산에서 자동으로 올바른 정밀도로 반올림됩니다.

하위 유형 MyIrrational <: AbstractIrrational은 최소한 ==(::MyIrrational, ::MyIrrational), hash(x::MyIrrational, h::UInt), 및 convert(::Type{F}, x::MyIrrational) where {F <: Union{BigFloat,Float32,Float64}}를 구현해야 합니다.

하위 유형이 때때로 유리수를 나타내는 데 사용되는 경우(예: 정수 n에 대해 √n을 나타내는 제곱근 유형은 n이 완전 제곱일 때 유리한 결과를 제공합니다), isinteger, iszero, isone, 및 ==를 Real 값과 함께 구현해야 합니다(모두 AbstractIrrational 유형에 대해 기본적으로 false로 설정되므로), 그리고 hash를 해당하는 Rational과 같도록 정의해야 합니다.

Float16 <: AbstractFloat <: Real

16비트 부동 소수점 숫자 유형 (IEEE 754 표준). 이진 형식은 1 비트의 부호, 5 비트의 지수, 10 비트의 분수입니다.

Float32 <: AbstractFloat <: Real

32비트 부동 소수점 숫자 유형(IEEE 754 표준). 이진 형식은 1 비트의 부호, 8 비트의 지수, 23 비트의 분수입니다.

과학적 표기법의 지수는 소문자 f로 입력해야 하므로 2f3 === 2.0f0 * 10^3 === Float32(2_000)입니다. 배열 리터럴 및 이해에서 요소 유형은 대괄호 앞에 지정할 수 있습니다: Float32[1,4,9] == Float32[i^2 for i in 1:3].

또한 Inf32, NaN32, Float16, exponent, frexp를 참조하십시오.

Float64 <: AbstractFloat <: Real

64비트 부동 소수점 숫자 유형(IEEE 754 표준). 이진 형식은 1 비트의 부호, 11 비트의 지수, 52 비트의 분수로 구성됩니다. 다양한 비트에 접근하려면 bitstring, signbit, exponent, frexp, 및 significand를 참조하세요.

이는 부동 소수점 리터럴의 기본값이며, 1.0 isa Float64와 1/2, 2pi, log(2), range(0,90,length=4)와 같은 많은 연산에 사용됩니다. 정수와 달리 이 기본값은 Sys.WORD_SIZE에 따라 변경되지 않습니다.

과학적 표기법의 지수는 e 또는 E로 입력할 수 있으며, 따라서 2e3 === 2.0E3 === 2.0 * 10^3입니다. 이렇게 하는 것이 10^n보다 강력히 권장됩니다. 왜냐하면 정수가 오버플로우되기 때문입니다. 따라서 2.0 * 10^19 < 0이지만 2e19 > 0입니다.

또한 Inf, NaN, floatmax, Float32, Complex를 참조하세요.

BigFloat <: AbstractFloat

임의 정밀도 부동 소수점 숫자 유형.

Bool <: Integer

부울 타입, 값 true와 false를 포함합니다.

Bool은 일종의 숫자입니다: false는 수치적으로 0과 같고 true는 수치적으로 1과 같습니다. 게다가, false는 NaN 및 Inf에 대해 곱셈의 "강한 제로"로 작용합니다:

julia> [true, false] == [1, 0]
true

julia> 42.0 + true
43.0

julia> 0 .* (NaN, Inf, -Inf)
(NaN, NaN, NaN)

julia> false .* (NaN, Inf, -Inf)
(0.0, 0.0, -0.0)

if 및 기타 조건문을 통해 분기할 때는 오직 Bool만 허용됩니다. Julia에는 "진리값"이 없습니다.

비교는 일반적으로 Bool을 반환하며, 브로드캐스트된 비교는 Array{Bool} 대신 BitArray를 반환할 수 있습니다.

julia> [1 2 3 4 5] .< pi
1×5 BitMatrix:
 1  1  1  0  0

julia> map(>(pi), [1 2 3 4 5])
1×5 Matrix{Bool}:
 0  0  0  1  1

자세한 내용은 trues, falses, ifelse를 참조하세요.

Int8 <: Signed <: Integer

8비트 부호 있는 정수 타입.

숫자 n ∈ -128:127을 나타냅니다. 이러한 정수는 경고 없이 오버플로우되므로, typemax(Int8) + Int8(1) < 0입니다.

또한 Int, widen, BigInt를 참조하세요.

UInt8 <: Unsigned <: Integer

8비트 부호 없는 정수 타입.

16진수로 출력되며, 따라서 0x07 == 7입니다.

Int16 <: Signed <: Integer

16비트 부호 있는 정수 타입.

숫자 n ∈ -32768:32767을 나타냅니다. 이러한 정수는 경고 없이 오버플로우되므로 typemax(Int16) + Int16(1) < 0입니다.

또한 Int, widen, BigInt를 참조하세요.

UInt16 <: Unsigned <: Integer

16비트 부호 없는 정수 유형.

16진수로 출력되며, 따라서 0x000f == 15입니다.

Int32 <: Signed <: Integer

32비트 부호 있는 정수 유형입니다.

이러한 정수는 경고 없이 오버플로우되므로 typemax(Int32) + Int32(1) < 0입니다.

또한 Int, widen, BigInt를 참조하십시오.

UInt32 <: Unsigned <: Integer

32비트 부호 없는 정수 타입.

16진수로 출력되며, 따라서 0x0000001f == 31.

Int64 <: Signed <: Integer

64비트 부호 있는 정수형.

이러한 정수는 경고 없이 오버플로우되므로 typemax(Int64) + Int64(1) < 0입니다.

또한 Int, widen, BigInt를 참조하세요.

UInt64 <: Unsigned <: Integer

64비트 부호 없는 정수 유형.

16진수로 인쇄되며, 따라서 0x000000000000003f == 63입니다.

Int128 <: Signed <: Integer

128비트 부호 있는 정수 타입입니다.

이러한 정수는 경고 없이 오버플로우되므로 typemax(Int128) + Int128(1) < 0입니다.

또한 Int, widen, BigInt를 참조하세요.

UInt128 <: Unsigned <: Integer

128비트 부호 없는 정수 유형.

16진수로 인쇄되며, 따라서 0x0000000000000000000000000000007f == 127입니다.

Int

Sys.WORD_SIZE 비트 부호 있는 정수 타입, Int <: Signed <: Integer <: Real.

이는 대부분의 정수 리터럴의 기본 타입이며, Sys.WORD_SIZE에 따라 Int32 또는 Int64의 별칭입니다. 이는 length와 같은 함수가 반환하는 타입이며, 배열 인덱싱을 위한 표준 타입입니다.

정수는 경고 없이 오버플로우되므로, typemax(Int) + 1 < 0 및 10^19 < 0입니다. 오버플로우는 BigInt를 사용하여 피할 수 있습니다. 매우 큰 정수 리터럴은 더 넓은 타입을 사용하며, 예를 들어 10_000_000_000_000_000_000 isa Int128입니다.

정수 나눗셈은 div 별칭 ÷이며, 정수에 대해 작동하는 /는 Float64를 반환합니다.

또한 Int64, widen, typemax, bitstring를 참조하십시오.

UInt

Sys.WORD_SIZE 비트 부호 없는 정수 타입, UInt <: Unsigned <: Integer.

Int와 마찬가지로, 별칭 UInt는 주어진 컴퓨터의 Sys.WORD_SIZE 값에 따라 UInt32 또는 UInt64를 가리킬 수 있습니다.

16진수로 출력 및 파싱됨: UInt(15) === 0x000000000000000f.

BigInt <: Signed

임의 정밀도 정수 유형.

Complex{T<:Real} <: Number

실수형 및 허수형 부분이 T 타입인 복소수 타입입니다.

ComplexF16, ComplexF32 및 ComplexF64는 각각 Complex{Float16}, Complex{Float32} 및 Complex{Float64}의 별칭입니다.

참고: Real, complex, real.

Rational{T<:Integer} <: Real

유리수 타입으로, 분자와 분모의 타입은 T입니다. 유리수는 오버플로우를 검사합니다.

Irrational{sym} <: AbstractIrrational

기호 sym으로 표시되는 정확한 무리수를 나타내는 숫자 유형으로, π, ℯ 및 γ와 같은 값을 포함합니다.

또한 AbstractIrrational을 참조하십시오.

digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

주어진 진수에서 n의 자릿수를 가진 요소 유형 T(기본값 Int)의 배열을 반환하며, 선택적으로 지정된 크기로 0으로 패딩할 수 있습니다. 더 중요한 자릿수는 더 높은 인덱스에 위치하며, 따라서 n == sum(digits[k]*base^(k-1) for k in eachindex(digits))입니다.

또한 ndigits, digits!, 그리고 진수 2의 경우 bitstring, count_ones를 참조하십시오.

예제

julia> digits(10)
2-element Vector{Int64}:
 0
 1

julia> digits(10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits(-256, base = 10, pad = 5)
5-element Vector{Int64}:
 -6
 -5
 -2
  0
  0

julia> n = rand(-999:999);

julia> n == evalpoly(13, digits(n, base = 13))
true

digits!(array, n::Integer; base::Integer = 10)

주어진 진수에서 n의 자릿수를 배열에 채웁니다. 더 중요한 자릿수는 더 높은 인덱스에 위치합니다. 배열 길이가 부족하면 가장 덜 중요한 자릿수로 배열 길이까지 채워집니다. 배열 길이가 과도하면 초과 부분은 0으로 채워집니다.

예제

julia> digits!([2, 2, 2, 2], 10, base = 2)
4-element Vector{Int64}:
 0
 1
 0
 1

julia> digits!([2, 2, 2, 2, 2, 2], 10, base = 2)
6-element Vector{Int64}:
 0
 1
 0
 1
 0
 0

bitstring(n)

원시 타입의 리터럴 비트 표현을 제공하는 문자열입니다.

또한 count_ones, count_zeros, digits를 참조하세요.

예제

julia> bitstring(Int32(4))
"00000000000000000000000000000100"

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"

parse(::Type{SimpleColor}, rgb::String)

tryparse(SimpleColor, rgb::String)의 유사체로, nothing을 반환하는 대신 오류를 발생시킵니다.

parse(::Type{Platform}, triplet::AbstractString)

문자열 플랫폼 트리플렛을 다시 Platform 객체로 구문 분석합니다.

parse(type, str; base)

문자열을 숫자로 파싱합니다. Integer 유형의 경우, 진수를 지정할 수 있습니다(기본값은 10입니다). 부동 소수점 유형의 경우, 문자열은 10진 부동 소수점 숫자로 파싱됩니다. Complex 유형은 "R±Iim" 형식의 10진 문자열에서 Complex(R,I)로 요청된 유형으로 파싱됩니다; "i" 또는 "j"를 "im" 대신 사용할 수 있으며, "R" 또는 "Iim"도 허용됩니다. 문자열에 유효한 숫자가 포함되어 있지 않으면 오류가 발생합니다.

예제

julia> parse(Int, "1234")
1234

julia> parse(Int, "1234", base = 5)
194

julia> parse(Int, "afc", base = 16)
2812

julia> parse(Float64, "1.2e-3")
0.0012

julia> parse(Complex{Float64}, "3.2e-1 + 4.5im")
0.32 + 4.5im

tryparse(::Type{SimpleColor}, rgb::String)

rgb를 SimpleColor로 파싱하려고 시도합니다. rgb가 #로 시작하고 길이가 7인 경우, RGBTuple 기반의 SimpleColor로 변환됩니다. rgb가 a-z로 시작하는 경우, rgb는 색상 이름으로 해석되어 Symbol 기반의 SimpleColor로 변환됩니다.

그렇지 않으면 nothing이 반환됩니다.

예제

julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)

julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)

julia> tryparse(SimpleColor, "#nocolor")

tryparse(type, str; base)

parse와 유사하지만, 요청된 타입의 값을 반환하거나, 문자열에 유효한 숫자가 포함되어 있지 않으면 nothing을 반환합니다.

big(x)

숫자를 최대 정밀도 표현으로 변환합니다 (일반적으로 BigInt 또는 BigFloat). 부동 소수점 숫자와 관련된 몇 가지 함정에 대한 정보는 BigFloat를 참조하십시오.

signed(T::Integer)

정수 비트 유형을 동일한 크기의 부호 있는 유형으로 변환합니다.

예제

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64

signed(x)

숫자를 부호 있는 정수로 변환합니다. 인수가 부호가 없는 경우, 오버플로우를 확인하지 않고 부호 있는 것으로 재해석됩니다.

참고: unsigned, sign, signbit.

unsigned(T::Integer)

정수 비트 유형을 동일한 크기의 부호 없는 유형으로 변환합니다.

예제

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64

float(x)

숫자 또는 배열을 부동 소수점 데이터 유형으로 변환합니다.

참고: complex, oftype, convert.

예제

julia> float(1:1000)
1.0:1.0:1000.0

julia> float(typemax(Int32))
2.147483647e9

significand(x)

부동 소수점 수의 유효 숫자(즉, 맨티사)를 추출합니다. 만약 x가 0이 아닌 유한한 수라면, 결과는 x와 같은 유형과 부호를 가지며 절대값이 $[1,2)$ 구간에 있는 수가 됩니다. 그렇지 않으면 x가 반환됩니다.

또한 frexp, exponent를 참조하세요.

예제

julia> significand(15.2)
1.9

julia> significand(-15.2)
-1.9

julia> significand(-15.2) * 2^3
-15.2

julia> significand(-Inf), significand(Inf), significand(NaN)
(-Inf, Inf, NaN)

exponent(x::Real) -> Int

절대값 abs(x)에 대해 2^y ≤ abs(x)를 만족하는 가장 큰 정수 y를 반환합니다.

x가 0, 무한대 또는 NaN일 때 DomainError를 발생시킵니다. 다른 비정상 부동 소수점 숫자 x에 대해서는, 이는 x의 지수 비트에 해당합니다.

또한 signbit, significand, frexp, issubnormal, log2, ldexp도 참조하세요.

예제

julia> exponent(8)
3

julia> exponent(6.5)
2

julia> exponent(-1//4)
-2

julia> exponent(3.142e-4)
-12

julia> exponent(floatmin(Float32)), exponent(nextfloat(0.0f0))
(-126, -149)

julia> exponent(0.0)
ERROR: DomainError with 0.0:
Cannot be ±0.0.
[...]

complex(r, [i])

실수 또는 배열을 복소수로 변환합니다. i는 기본값이 0입니다.

예제

julia> complex(7)
7 + 0im

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

bswap(n)

n의 바이트 순서를 반전시킵니다.

(현재 네이티브 바이트 순서와 빅 엔디안 순서 간의 변환을 위해 ntoh 및 hton를 참조하십시오.)

예제

julia> a = bswap(0x10203040)
0x40302010

julia> bswap(a)
0x10203040

julia> string(1, base = 2)
"1"

julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"

hex2bytes(itr)

주어진 ASCII 코드의 iterable itr는 16진수 숫자의 시퀀스를 나타내며, 이진 표현에 해당하는 Vector{UInt8}의 바이트를 반환합니다: itr의 각 연속적인 16진수 숫자 쌍은 반환 벡터의 하나의 바이트 값을 제공합니다.

itr의 길이는 짝수여야 하며, 반환된 배열은 itr의 길이의 절반을 가집니다. 또한 hex2bytes! 인플레이스 버전과 bytes2hex 역함수도 참조하십시오.

예제

julia> s = string(12345, base = 16)
"3039"

julia> hex2bytes(s)
2-element Vector{UInt8}:
 0x30
 0x39

julia> a = b"01abEF"
6-element Base.CodeUnits{UInt8, String}:
 0x30
 0x31
 0x61
 0x62
 0x45
 0x46

julia> hex2bytes(a)
3-element Vector{UInt8}:
 0x01
 0xab
 0xef

hex2bytes!(dest::AbstractVector{UInt8}, itr)

16진수 문자열을 나타내는 바이트의 iterable itr을 이진 표현으로 변환합니다. hex2bytes와 유사하지만 출력이 dest에 제자리에서 작성됩니다. dest의 길이는 itr의 길이의 절반이어야 합니다.

bytes2hex(itr) -> String
bytes2hex(io::IO, itr)

바이트의 반복자 itr를 16진수 문자열 표현으로 변환합니다. bytes2hex(itr)를 통해 String을 반환하거나 bytes2hex(io, itr)를 통해 문자열을 io 스트림에 씁니다. 16진수 문자는 모두 소문자입니다.

예제

julia> a = string(12345, base = 16)
"3039"

julia> b = hex2bytes(a)
2-element Vector{UInt8}:
 0x30
 0x39

julia> bytes2hex(b)
"3039"

one(x)
one(T::type)

x에 대한 곱셈 항등원을 반환합니다: one(x)*x == x*one(x) == x가 성립하는 값입니다. 또는 one(T)는 타입 T를 받을 수 있으며, 이 경우 one은 타입 T의 모든 x에 대한 곱셈 항등원을 반환합니다.

가능한 경우, one(x)는 x와 동일한 타입의 값을 반환하고, one(T)는 타입 T의 값을 반환합니다. 그러나 이는 차원 있는 양을 나타내는 타입(예: 일 단위의 시간)에 대해서는 해당되지 않을 수 있습니다. 곱셈 항등원은 차원이 없는 값이어야 하기 때문입니다. 이 경우, one(x)는 x와 동일한 정밀도(및 행렬의 경우 형태)의 항등값을 반환해야 합니다.

x와 동일한 타입이거나 타입 T의 양을 원하더라도, x가 차원 있는 경우에는 대신 oneunit를 사용하세요.

또한 identity 함수와 I를 LinearAlgebra에서 항등 행렬로 참조하세요.

예제

julia> one(3.7)
1.0

julia> one(Int)
1

julia> import Dates; one(Dates.Day(1))
1

oneunit(x::T)
oneunit(T::Type)

T(one(x))를 반환합니다. 여기서 T는 인수의 유형이거나(유형이 전달된 경우) 인수입니다. 이는 차원 있는 양에 대한 one와 다릅니다: one은 차원이 없는(곱셈 항등원) 반면 oneunit은 차원 있는(x와 동일한 유형이거나 유형 T의) 것입니다.

예시

julia> oneunit(3.7)
1.0

julia> import Dates; oneunit(Dates.Day)
1 day

zero(x)
zero(::Type)

x의 타입에 대한 덧셈 항등원 요소를 가져옵니다 (x는 타입 자체를 지정할 수도 있습니다).

또한 iszero, one, oneunit, oftype를 참조하세요.

예제

julia> zero(1)
0

julia> zero(big"2.0")
0.0

julia> zero(rand(2,2))
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

im

허수 단위.

참고: imag, angle, complex.

예제

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im

π
pi

상수 pi.

유니코드 π는 Julia REPL에서 \pi를 입력한 후 탭을 눌러 입력할 수 있으며, 많은 편집기에서도 가능합니다.

참고: sinpi, sincospi, deg2rad.

예제

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

상수 ℯ.

유니코드 ℯ는 Julia REPL에서 \euler를 입력하고 탭을 눌러 입력할 수 있으며, 많은 편집기에서도 가능합니다.

참고: exp, cis, cispi.

예제

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true

카탈란 상수.

# 예제

jldoctest julia> Base.MathConstants.catalan catalan = 0.9159655941772...

julia> sum(log(x)/(1+x^2) for x in 1:0.01:10^6) * 0.01 0.9159466120554123 ```

γ
eulergamma

오일러 상수.

예제

julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...

julia> dx = 10^-6;

julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133

φ
황금비율

황금비율.

예시

julia> Base.MathConstants.golden
φ = 1.6180339887498...

julia> (2ans - 1)^2 ≈ 5
true

Inf, Inf64

타입 Float64의 양의 무한대입니다.

참고: isfinite, typemax, NaN, Inf32.

예제

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf, Inf64

타입 Float64의 양의 무한대입니다.

참고: isfinite, typemax, NaN, Inf32.

예제

julia> π/0
Inf

julia> +1.0 / -0.0
-Inf

julia> ℯ^-Inf
0.0

Inf32

타입 Float32의 양의 무한대입니다.

Inf16

Float16 유형의 양의 무한대입니다.

NaN, NaN64

Float64 유형의 not-a-number 값입니다.

참고: isnan, missing, NaN32, Inf.

예제

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN, NaN64

Float64 유형의 not-a-number 값입니다.

참고: isnan, missing, NaN32, Inf.

예제

julia> 0/0
NaN

julia> Inf - Inf
NaN

julia> NaN == NaN, isequal(NaN, NaN), isnan(NaN)
(false, true, true)

julia> reinterpret(UInt32, NaN32)
0x7fc00000

julia> NaN32p1 = reinterpret(Float32, 0x7fc00001)
NaN32

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)

NaN32

Float32 유형의 숫자가 아닌 값입니다.

참고: NaN.

NaN16

Float16 유형의 숫자가 아닌 값입니다.

참고: NaN.

issubnormal(f) -> Bool

부동 소수점 숫자가 비정상(subnormal)인지 테스트합니다.

IEEE 부동 소수점 숫자는 지수 비트가 0이고 유효 숫자가 0이 아닐 때 비정상입니다.

예제

julia> floatmin(Float32)
1.1754944f-38

julia> issubnormal(1.0f-37)
false

julia> issubnormal(1.0f-38)
true

isfinite(f) -> Bool

숫자가 유한한지 테스트합니다.

예제

julia> isfinite(5)
true

julia> isfinite(NaN32)
false

isinf(f) -> Bool

숫자가 무한한지 테스트합니다.

참고: Inf, iszero, isfinite, isnan.

isnan(f) -> Bool

숫자 값이 NaN인지 테스트합니다. NaN은 무한대도 아니고 유한한 숫자도 아닌 불확정 값입니다("숫자가 아님").

참고: iszero, isone, isinf, ismissing.

iszero(x)

x == zero(x)이면 true를 반환합니다. x가 배열인 경우, 이는 x의 모든 요소가 0인지 확인합니다.

참고: isone, isinteger, isfinite, isnan.

예제

julia> iszero(0.0)
true

julia> iszero([1, 9, 0])
false

julia> iszero([false, 0, 0])
true

isone(x)

x가 one(x)와 같으면 true를 반환합니다. x가 배열인 경우, 이는 x가 항등 행렬인지 확인합니다.

예시

julia> isone(1.0)
true

julia> isone([1 0; 0 2])
false

julia> isone([1 0; 0 true])
true

nextfloat(x::AbstractFloat, n::Integer)

n이 0 이상인 경우 x에 nextfloat을 n번 반복 적용한 결과, 또는 n이 0 미만인 경우 prevfloat을 -n번 적용한 결과입니다.

nextfloat(x::AbstractFloat)

같은 유형의 가장 작은 부동 소수점 숫자 y를 반환합니다. 단, x < y를 만족해야 합니다. 만약 그러한 y가 존재하지 않는 경우(예: x가 Inf 또는 NaN인 경우), x를 반환합니다.

또한 참조: prevfloat, eps, issubnormal.

prevfloat(x::AbstractFloat, n::Integer)

n이 0 이상인 경우 x에 prevfloat을 n번 반복 적용한 결과, 또는 n이 0 미만인 경우 nextfloat을 -n번 적용한 결과입니다.

prevfloat(x::AbstractFloat)

입력된 x와 같은 타입의 가장 큰 부동 소수점 숫자 y를 반환합니다. 단, y < x를 만족해야 합니다. 만약 그러한 y가 존재하지 않는 경우(예: x가 -Inf 또는 NaN인 경우), x를 반환합니다.

isinteger(x) -> Bool

x가 어떤 정수와 수치적으로 같은지 테스트합니다.

예시

julia> isinteger(4.0)
true

isreal(x) -> Bool

x 또는 x의 모든 요소가 무한대와 NaN을 포함하여 어떤 실수와 수치적으로 같은지 테스트합니다. isreal(x)는 isequal(x, real(x))가 true인 경우 true입니다.

예제

julia> isreal(5.)
true

julia> isreal(1 - 3im)
false

julia> isreal(Inf + 0im)
true

julia> isreal([4.; complex(0,1)])
false

Float32(x [, mode::RoundingMode])

x로부터 Float32를 생성합니다. x가 정확하게 표현될 수 없는 경우 mode가 x가 어떻게 반올림되는지를 결정합니다.

예제

julia> Float32(1/3, RoundDown)
0.3333333f0

julia> Float32(1/3, RoundUp)
0.33333334f0

사용 가능한 반올림 모드에 대해서는 RoundingMode를 참조하세요.

Float64(x [, mode::RoundingMode])

x로부터 Float64를 생성합니다. x가 정확하게 표현될 수 없는 경우 mode가 x가 어떻게 반올림되는지를 결정합니다.

예제

julia> Float64(pi, RoundDown)
3.141592653589793

julia> Float64(pi, RoundUp)
3.1415926535897936

사용 가능한 반올림 모드에 대한 내용은 RoundingMode를 참조하세요.

rounding(T)

타입 T에 대한 현재 부동 소수점 반올림 모드를 가져오며, 기본 산술 함수(+, -, *, / 및 sqrt)와 타입 변환의 반올림을 제어합니다.

사용 가능한 모드에 대한 내용은 RoundingMode를 참조하세요.

setrounding(T, mode)

부동 소수점 타입 T의 반올림 모드를 설정하여 기본 산술 함수(+, -, *, / 및 sqrt)와 타입 변환의 반올림을 제어합니다. 기본 RoundNearest 이외의 반올림 모드를 사용할 경우 다른 수치 함수가 잘못되거나 유효하지 않은 값을 반환할 수 있습니다.

현재 T == BigFloat에 대해서만 지원됩니다.

!!! 경고 이 함수는 스레드 안전하지 않습니다. 모든 스레드에서 실행되는 코드에 영향을 미치지만, 설정을 사용하는 계산과 동시에 호출될 경우 그 동작은 정의되지 않습니다.

setrounding(f::Function, T, mode)

함수 f의 실행 동안 부동 소수점 타입 T의 반올림 모드를 변경합니다. 이는 논리적으로 다음과 같습니다:

old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)

사용 가능한 반올림 모드는 RoundingMode를 참조하세요.

get_zero_subnormals() -> Bool

서브노말 부동 소수점 값("비정규화")에 대한 연산이 IEEE 산술 규칙을 준수하면 false를 반환하고, 0으로 변환될 수 있는 경우 true를 반환합니다.

!!! 경고 이 함수는 현재 스레드에만 영향을 미칩니다.

set_zero_subnormals(yes::Bool) -> Bool

yes가 false인 경우, 이후의 부동 소수점 연산은 비정상 값("denormals")에 대한 IEEE 산술 규칙을 따릅니다. 그렇지 않으면, 부동 소수점 연산은 비정상 입력 또는 출력을 0으로 변환하는 것이 허용되지만 필수는 아닙니다. true를 반환하지만 yes==true이고 하드웨어가 비정상 숫자의 0화를 지원하지 않는 경우는 제외입니다.

set_zero_subnormals(true)는 일부 하드웨어에서 일부 계산을 가속화할 수 있습니다. 그러나 (x-y==0) == (x==y)와 같은 항등식을 깨뜨릴 수 있습니다.

!!! 경고 이 함수는 현재 스레드에만 영향을 미칩니다.

count_ones(x::Integer) -> Integer

x의 이진 표현에서 1의 개수.

예시

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

x의 이진 표현에서 0의 개수.

예시

julia> count_zeros(Int32(2 ^ 16 - 1))
16

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

x의 이진 표현에서 앞에 오는 0의 개수입니다.

예시

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

x의 이진 표현에서 앞에 있는 1의 개수입니다.

예시

julia> leading_ones(UInt32(2 ^ 32 - 2))
31

trailing_zeros(x::Integer) -> Integer

x의 이진 표현에서 뒤따르는 0의 수입니다.

예제

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

x의 이진 표현에서 뒤따르는 1의 수입니다.

예제

julia> trailing_ones(3)
2

isodd(x::Number) -> Bool

x가 홀수 정수(즉, 2로 나누어 떨어지지 않는 정수)인 경우 true를 반환하고, 그렇지 않으면 false를 반환합니다.

예제

julia> isodd(9)
true

julia> isodd(10)
false

iseven(x::Number) -> Bool

x가 짝수 정수(즉, 2로 나누어 떨어지는 정수)인 경우 true를 반환하고, 그렇지 않으면 false를 반환합니다.

예제

julia> iseven(9)
false

julia> iseven(10)
true

@int128_str str

str를 Int128로 파싱합니다. 문자열이 유효한 정수가 아닐 경우 ArgumentError를 발생시킵니다.

예제

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]

@uint128_str str

str를 UInt128로 파싱합니다. 문자열이 유효한 정수가 아닐 경우 ArgumentError를 발생시킵니다.

예제

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

julia> uint128"-123456789123"
ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
[...]

BigFloat(x::Union{Real, AbstractString} [, rounding::RoundingMode=rounding(BigFloat)]; [precision::Integer=precision(BigFloat)])

x로부터 임의의 정밀도 부동 소수점 숫자를 생성하며, 정밀도는 precision입니다. rounding 인자는 변환이 정확하게 수행될 수 없는 경우 결과가 반올림되는 방향을 지정합니다. 제공되지 않으면, 현재 전역 값에 의해 설정됩니다.

BigFloat(x::Real)은 convert(BigFloat,x)와 동일하지만, x가 이미 BigFloat인 경우 현재 전역 정밀도로 설정된 값을 반환합니다; convert는 항상 x를 반환합니다.

BigFloat(x::AbstractString)은 parse와 동일합니다. 이는 소수 리터럴이 파싱될 때 Float64로 변환되기 때문에 제공됩니다. 따라서 BigFloat(2.1)은 예상한 결과를 제공하지 않을 수 있습니다.

참고:

• @big_str
• rounding 및 setrounding
• precision 및 setprecision

예제

julia> BigFloat(2.1) # 여기서 2.1은 Float64입니다.
2.100000000000000088817841970012523233890533447265625

julia> BigFloat("2.1") # 2.1에 가장 가까운 BigFloat
2.099999999999999999999999999999999999999999999999999999999999999999999999999986

julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021

julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007

precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

부동 소수점 숫자의 정밀도를 가져옵니다. 이는 유효 숫자의 비트 수로 정의되며, 부동 소수점 타입 T의 정밀도(만약 T가 BigFloat와 같은 가변 정밀도 타입이라면 현재 기본값)입니다.

base가 지정되면 해당 진수에서 최대 해당하는 유효 숫자 자릿수를 반환합니다.

setprecision([T=BigFloat,] precision::Int; base=2)

T 산술에 사용될 정밀도(기본적으로 비트 단위)를 설정합니다. base가 지정되면, 정밀도는 주어진 base에서 최소한 precision 자릿수를 제공하는 데 필요한 최소값입니다.

!!! 경고 이 함수는 스레드 안전하지 않습니다. 모든 스레드에서 실행 중인 코드에 영향을 미치지만, 설정을 사용하는 계산과 동시에 호출되면 그 동작은 정의되지 않습니다.

!!! 호환성 "Julia 1.8" base 키워드는 최소한 Julia 1.8이 필요합니다.

setprecision(f::Function, [T=BigFloat,] precision::Integer; base=2)

주어진 f의 기간 동안 T 산술 정밀도(주어진 base)를 변경합니다. 이는 논리적으로 다음과 같습니다:

old = precision(BigFloat)
setprecision(BigFloat, precision)
f()
setprecision(BigFloat, old)

종종 setprecision(T, precision) do ... end와 같이 사용됩니다.

참고: nextfloat(), prevfloat()는 setprecision에서 언급한 정밀도를 사용하지 않습니다.

BigInt(x)

임의 정밀 정수를 생성합니다. x는 Int(또는 Int로 변환할 수 있는 모든 것)일 수 있습니다. 이 유형에 대해 일반적인 수학 연산자가 정의되어 있으며, 결과는 BigInt로 승격됩니다.

인스턴스는 parse를 통해 문자열에서 구성하거나 big 문자열 리터럴을 사용하여 구성할 수 있습니다.

예제

julia> parse(BigInt, "42")
42

julia> big"313"
313

julia> BigInt(10)^19
10000000000000000000

@big_str str

문자열을 BigInt 또는 BigFloat로 파싱하고, 문자열이 유효한 숫자가 아닐 경우 ArgumentError를 발생시킵니다. 정수의 경우 _는 문자열에서 구분자로 허용됩니다.

예제

julia> big"123_456"
123456

julia> big"7891.5"
7891.5

julia> big"_"
ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
[...]

!!! 경고 BigFloat 값을 구성하기 위해 @big_str를 사용하는 것은 순수하게 예상되는 동작을 초래하지 않을 수 있습니다: 매크로인 @big_str는 로드 시점에 설정된 전역 정밀도 (setprecision) 및 반올림 모드 (setrounding) 설정을 따릅니다. 따라서 () -> precision(big"0.3")와 같은 함수는 함수가 정의될 때의 정밀도 값에 따라 달라지는 상수를 반환하며, 함수가 호출될 때의 정밀도에 따라 달라지지 않습니다.