Numbers

Number

すべての数値型の抽象スーパタイプです。

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 1:length(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(x)

数値を符号付き整数に変換します。引数が符号なしの場合、オーバーフローをチェックせずに符号付きとして再解釈されます。

関連項目: unsigned, sign, signbit.

signed(T::Integer)

整数のビットタイプを同じサイズの符号付きタイプに変換します。

例

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

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 に対して、これは x の指数に対応します。

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)

与えられたASCIIコードの反復可能なitrは、16進数の数字のシーケンスに対応し、バイナリ表現に対応する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に型を引数として渡すことができます（例えば、one(Int)はすべてのIntのインスタンスに対して乗法単位元が同じであるため機能しますが、異なる形状の行列は異なる乗法単位元を持つため、one(Matrix{Int})は定義されていません）。

可能であれば、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 である場合、または oneunit が型からのみ推測できる場合には、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の加法単位元を取得します。加法単位元が型からのみ推測できる場合、型を引数としてzeroに渡すことができます。

例えば、zero(Int)は動作します。なぜなら、加法単位元はすべてのIntのインスタンスで同じだからですが、zero(Vector{Int})は異なる長さのベクトルが異なる加法単位元を持つため、定義されていません。

他にも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

catalan

カタラン定数。

例

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 型の非数値（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)

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

関連情報: prevfloat, eps, issubnormal.

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

n が 0 以上の場合は x に nextfloat を n 回適用した結果、n が 0 未満の場合は prevfloat を -n 回適用した結果。

prevfloat(x::AbstractFloat)

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

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

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

isinteger(x) -> Bool

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

例

julia> isinteger(4.0)
true

isreal(x) -> Bool

x またはそのすべての要素が無限大やNaNを含む実数に数値的に等しいかどうかをテストします。 isreal(x) は isequal(x, real(x)) が真である場合に真です。

例

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(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 で言及された精度を使用しません。

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

T の算術に使用される精度（デフォルトではビット単位）を設定します。base が指定されている場合、精度は指定された base で少なくとも precision 桁を提供するために必要な最小値です。

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