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）の配列を返します。オプションで、指定されたサイズにゼロでパディングすることができます。より重要な桁は高いインデックスにあり、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 の桁を配列に埋めます。より重要な桁は高いインデックスにあります。配列の長さが不十分な場合、最も重要でない桁が配列の長さまで埋められます。配列の長さが過剰な場合、余分な部分はゼロで埋められます。

例

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)

浮動小数点数の仮数（別名：マントissa）を抽出します。x がゼロでない有限数であれば、結果は 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

2^y ≤ abs(x) を満たす最大の整数 y を返します。

x がゼロ、無限大、または 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はデフォルトでゼロです。

例

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)

与えられたイテラブル itr は、16進数の数字のシーケンスに対するASCIIコードの列であり、バイナリ表現に対応する Vector{UInt8} のバイトを返します：itr の各連続する2桁の16進数が、返されるベクターの1バイトの値を与えます。

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)

イテラブル itr のバイトを16進数文字列としてバイナリ表現に変換します。これは 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の量が必要な場合は、代わりにoneunitを使用してください。

また、単位行列についてはidentity関数や、LinearAlgebraのIも参照してください。

例

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 であるか、型が渡された場合は引数である T(one(x)) を返します。これは次元を持つ量に対する 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。

Unicode π は、Julia REPL で \pi と書いてからタブを押すことで入力でき、多くのエディタでも同様です。

関連項目: sinpi, sincospi, deg2rad。

例

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535

ℯ
e

定数 ℯ。

Unicode ℯ は、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)

!!! 注 NaN をチェックする際は、必ず isnan または isequal を使用してください。x === NaN を使用すると予期しない結果が得られることがあります：

```julia-repl
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)

!!! 注 NaN をチェックする際は、必ず isnan または isequal を使用してください。x === NaN を使用すると予期しない結果が得られることがあります：

```julia-repl
julia> reinterpret(UInt32, NaN32)
0x7fc00000

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

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

NaN32

型 Float32 の非数値（not-a-number）値です。

参照: NaN.

NaN16

型 Float16 の非数値（not-a-number）値です。

参照: NaN.

issubnormal(f) -> Bool

浮動小数点数が非正規化であるかどうかをテストします。

IEEE浮動小数点数は、指数ビットがゼロであり、有効数字がゼロでない場合に非正規化と呼ばれます。

例

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（無限大でも有限数でもない不確定値）であるかどうかをテストします。

関連情報: iszero, isone, isinf, ismissing.

iszero(x)

x == zero(x) の場合は true を返します。x が配列の場合、これは x のすべての要素がゼロであるかどうかをチェックします。

関連項目: 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 回の nextfloat を x に適用した結果（n >= 0 の場合）または -n 回の prevfloat の適用結果（n < 0 の場合）。

nextfloat(x::AbstractFloat)

同じ型の最小の浮動小数点数 y を返します。条件は x < y です。もしそのような y が存在しない場合（例えば x が Inf または NaN の場合）、x を返します。

関連情報: prevfloat, eps, issubnormal.

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

n 回の prevfloat を x に適用した結果（n >= 0 の場合）、または -n 回の nextfloat の適用結果（n < 0 の場合）。

prevfloat(x::AbstractFloat)

同じ型の最大の浮動小数点数 y を返します。条件は y < x です。もしそのような y が存在しない場合（例えば x が -Inf または NaN の場合）、x を返します。

isinteger(x) -> Bool

xが数値的に整数と等しいかどうかをテストします。

例

julia> isinteger(4.0)
true

isreal(x) -> Bool

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)

浮動小数点型 T の丸めモードを f の実行中に変更します。これは論理的に次のように等価です：

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

利用可能な丸めモードについては RoundingMode を参照してください。

get_zero_subnormals() -> Bool

サブノーマル浮動小数点値（「デノーマル」）に対する操作がIEEE算術のルールに従う場合はfalseを返し、ゼロに変換される可能性がある場合はtrueを返します。

set_zero_subnormals(yes::Bool) -> Bool

yes が false の場合、以降の浮動小数点演算は非正規値（「デノーマル」）に関する IEEE 演算のルールに従います。それ以外の場合、浮動小数点演算は非正規の入力または出力をゼロに変換することが許可されます（ただし、必須ではありません）。true を返しますが、yes==true でハードウェアが非正規数のゼロ化をサポートしていない場合は除きます。

set_zero_subnormals(true) は、一部のハードウェアでいくつかの計算を高速化することができます。ただし、(x-y==0) == (x==y) のような同一性を壊す可能性があります。

count_ones(x::Integer) -> Integer

xの2進数表現における1の数。

例

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32

count_zeros(x::Integer) -> Integer

xの2進数表現におけるゼロの数。

例

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

julia> count_zeros(-1)
0

leading_zeros(x::Integer) -> Integer

xの2進数表現の先頭にあるゼロの数。

例

julia> leading_zeros(Int32(1))
31

leading_ones(x::Integer) -> Integer

xの2進数表現の先頭にある1の数。

例

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

trailing_zeros(x::Integer) -> Integer

xの2進数表現の末尾にあるゼロの数。

例

julia> trailing_zeros(2)
1

trailing_ones(x::Integer) -> Integer

xの2進数表現の末尾にある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と同じです。これは、10進数リテラルが解析時に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 桁を提供するために必要な最小値です。

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

指定された base の間、f のために T の算術精度を変更します。これは論理的に次のように等価です：

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