Numbers
Standard Numeric Types
Base における Number のすべてのサブタイプの型ツリーを以下に示します。抽象型にはその旨を示してあり、それ以外は具象型です。
Number (Abstract Type)
├─ Complex
└─ Real (Abstract Type)
├─ AbstractFloat (Abstract Type)
│ ├─ Float16
│ ├─ Float32
│ ├─ Float64
│ └─ BigFloat
├─ Integer (Abstract Type)
│ ├─ Bool
│ ├─ Signed (Abstract Type)
│ │ ├─ Int8
│ │ ├─ Int16
│ │ ├─ Int32
│ │ ├─ Int64
│ │ ├─ Int128
│ │ └─ BigInt
│ └─ Unsigned (Abstract Type)
│ ├─ UInt8
│ ├─ UInt16
│ ├─ UInt32
│ ├─ UInt64
│ └─ UInt128
├─ Rational
└─ AbstractIrrational (Abstract Type)
└─ IrrationalAbstract number types
Core.Number — Type
Numberすべての数値型の抽象スーパータイプ。
Core.AbstractFloat — Type
AbstractFloat <: Realすべての浮動小数点数の抽象スーパータイプ。
Core.Signed — Type
Signed <: Integerすべての符号付き整数の抽象スーパータイプ。
Core.Unsigned — Type
Unsigned <: Integerすべての符号なし整数の抽象スーパータイプです。
組み込みの符号なし整数は、接頭辞 0x を付けた16進数で表示され、同じ形式で入力できます。
Examples
julia> typemax(UInt8)
0xff
julia> Int(0x00d)
13
julia> unsigned(true)
0x0000000000000001Base.AbstractIrrational — Type
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 と同じ値になるよう定義する必要があります。
Concrete number types
Core.Float16 — Type
Float16 <: AbstractFloat <: Real16 ビット浮動小数点数型(IEEE 754 規格)。バイナリ形式は、符号 1 ビット、指数部 5 ビット、仮数部 10 ビットです。
Core.Float32 — Type
Float32 <: AbstractFloat <: RealIEEE 754規格に準拠した32ビット浮動小数点数型です。バイナリ形式は、符号部が1ビット、指数部が8ビット、仮数部が23ビットです。
科学表記法の指数には、小文字のfを入力します。たとえば、2f3 === 2.0f0 * 10^3 === Float32(2_000)です。配列リテラルや内包表記では、角括弧の前に要素型を指定できます。Float32[1,4,9] == Float32[i^2 for i in 1:3]
Core.Float64 — Type
Float64 <: AbstractFloat <: Real64ビット浮動小数点数型(IEEE 754規格)。2進形式は、符号部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です。
Base.MPFR.BigFloat — Type
BigFloat <: AbstractFloat任意精度の浮動小数点数型。
Core.Bool — Type
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 に「truthy」な値はありません。
比較演算は通常 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 1Core.UInt8 — Type
UInt8 <: Unsigned <: Integer8ビット符号なし整数型。
16進数で表示されるため、0x07 == 7。
Core.Int16 — Type
Int16 <: Signed <: Integer16ビット符号付き整数型。
n ∈ -32768:32767 の数値を表します。このような整数は警告なしにオーバーフローするため、typemax(Int16) + Int16(1) < 0 であることに注意してください。
Core.UInt16 — Type
UInt16 <: Unsigned <: Integer16ビット符号なし整数型。
16進数で表示されるため、0x000f == 15 です。
Core.Int32 — Type
Int32 <: Signed <: Integer32ビット符号付き整数型。
この型の整数は警告なしにオーバーフローするため、typemax(Int32) + Int32(1) < 0 に注意してください。
Core.UInt32 — Type
UInt32 <: Unsigned <: Integer32ビット符号なし整数型。
16進数で表示されるため、0x0000001f == 31 となります。
Core.Int64 — Type
Int64 <: Signed <: Integer64ビット符号付き整数型。
この型の整数は警告なしにオーバーフローするため、typemax(Int64) + Int64(1) < 0に注意してください。
Core.UInt64 — Type
UInt64 <: Unsigned <: Integer64ビット符号なし整数型。
16進数で表示されるため、0x000000000000003f == 63 です。
Core.Int128 — Type
Int128 <: Signed <: Integer128ビット符号付き整数型。
この型の整数は警告なしにオーバーフローするため、typemax(Int128) + Int128(1) < 0。
Core.UInt128 — Type
UInt128 <: Unsigned <: Integer128ビット符号なし整数型。
16進数で表示されるため、0x0000000000000000000000000000007f == 127 となります。
Core.Int — Type
IntSys.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 のように、より幅の広い型が使われます。
Base.GMP.BigInt — Type
BigInt <: Signed任意精度整数型。
Base.Complex — Type
Complex{T<:Real} <: Number実部と虚部の型が T である複素数型です。
ComplexF16、ComplexF32、ComplexF64 は、それぞれ Complex{Float16}、Complex{Float32}、Complex{Float64} の別名です。
Base.Rational — Type
Rational{T<:Integer} <: Real分子と分母の型がTである有理数型です。有理数のオーバーフローはチェックされます。
Base.Irrational — Type
Irrational{sym} <: AbstractIrrationalsym で表される、厳密な無理数値を表す数値型です。例として、π、ℯ、γ があります。
AbstractIrrational も参照してください。
Data Formats
Base.digits — Function
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。
Examples
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))
trueBase.digits! — Function
digits!(array, n::Integer; base::Integer = 10)指定された基数で、nの各桁を配列に格納します。上位の桁ほど大きなインデックスに格納されます。配列の長さが足りない場合は、最下位の桁から配列の長さ分だけ格納します。配列の長さが余る場合は、余った部分をゼロで埋めます。
Examples
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
0Base.bitstring — Function
bitstring(n)プリミティブ型のビット表現を文字列で示します(ビッグエンディアン、つまり最上位ビットが先頭)。
関連項目:count_ones、count_zeros、digits。
Examples
julia> bitstring(Int32(4))
"00000000000000000000000000000100"
julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"Base.parse — Function
parse(::Type{SimpleColor}, rgb::String)tryparse(SimpleColor, rgb::String)(そちらを参照)に相当する関数ですが、nothingを返す代わりにエラーを発生させます。
parse(type, str; base)文字列を数値として解析します。Integer 型では基数を指定できます(既定値は 10 です)。浮動小数点型の場合、文字列は 10 進浮動小数点数として解析されます。Complex 型では、"R±Iim" 形式の 10 進文字列を、要求された型の Complex(R,I) として解析します。"im" の代わりに "i" または "j" を使用することもでき、"R" または "Iim" も使用できます。文字列に有効な数値が含まれていない場合は、エラーが発生します。
Examples
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.5imparse(::Type{Platform}, triplet::AbstractString)文字列のプラットフォームトリプレットを解析し、Platform オブジェクトに戻します。
Base.tryparse — Function
tryparse(::Type{SimpleColor}, rgb::String)rgbをSimpleColorとして解析します。rgbが#で始まり、長さが7の場合、RGBTupleを基盤とするSimpleColorに変換されます。rgbがa-zで始まる場合、rgbは色名として解釈され、Symbolを基盤とするSimpleColorに変換されます。
それ以外の場合は、nothingが返されます。
Examples
julia> tryparse(SimpleColor, "blue")
SimpleColor(blue)
julia> tryparse(SimpleColor, "#9558b2")
SimpleColor(#9558b2)
julia> tryparse(SimpleColor, "#nocolor")Base.unsigned — Function
unsigned(T::Integer)整数ビット型を、同じサイズの符号なし型に変換します。
Examples
julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64Base.float — Method
float(x)数値または配列を浮動小数点型に変換します。
Examples
julia> float(typemax(Int32))
2.147483647e9Base.Math.significand — Function
significand(x)浮動小数点数の仮数(マンティッサ)を取り出します。x がゼロ以外の有限数の場合、戻り値は x と同じ型および符号を持ち、絶対値が $[1,2)$ の区間内にある数値です。それ以外の場合は x を返します。
Examples
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)Base.Math.exponent — Function
exponent(x::Real)::Inty が 2^y ≤ abs(x) を満たす最大の整数を返します。正規化された浮動小数点数 x の場合、これは x の指数に相当します。
x がゼロ、無限大、または NaN の場合、DomainError をスローします。その他の非サブノーマル浮動小数点数 x では、これは x の指数ビットに相当します。
関連項目: signbit、significand、frexp、issubnormal、log2、ldexp。
Examples
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.
[...]Base.complex — Method
complex(r, [i])実数または配列を複素数に変換します。i の既定値はゼロです。
Examples
julia> complex(7)
7 + 0imBase.bswap — Function
bswap(n)nのバイト順を逆にします。
(現在のネイティブバイト順とビッグエンディアンの間で変換するには、ntohおよびhtonも参照してください。)
Examples
julia> a = bswap(0x10203040)
0x40302010
julia> bswap(a)
0x10203040
julia> string(1, base = 2)
"1"
julia> string(bswap(1), base = 2)
"100000000000000000000000000000000000000000000000000000000"Base.hex2bytes — Function
hex2bytes(itr)16進数の各桁に対応するASCIIコードの反復可能オブジェクトitrを受け取り、その2進表現に対応するバイト列Vector{UInt8}を返します。itrに含まれる16進数の各桁を順に2つずつ組み合わせ、その値を戻り値のベクトル内の1バイトとして表します。
itrの長さは偶数でなければなりません。返される配列の長さはitrの半分です。インプレース版についてはhex2bytes!を、逆変換についてはbytes2hexを参照してください。
UInt8の値を生成するイテレータを指定してhex2bytesを呼び出すには、Julia 1.7以降が必要です。それ以前のバージョンでは、hex2bytesを呼び出す前にイテレータをcollectできます。
Examples
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
0xefBase.hex2bytes! — Function
hex2bytes!(dest::AbstractVector{UInt8}, itr)16進数文字列を表すバイトのイテラブルitrを、バイナリ表現に変換します。hex2bytesと同様ですが、出力はdestにインプレースで書き込まれます。destの長さは、itrの長さの半分でなければなりません。
Base.bytes2hex — Function
bytes2hex(itr)::String
bytes2hex(io::IO, itr)::Nothingバイトのイテレータitrを16進文字列に変換します。bytes2hex(itr)を介してStringを返すか、bytes2hex(io, itr)を介してioストリームに文字列を書き込みます。16進文字はすべて小文字です。
任意のイテレータからUInt8値を生成してbytes2hexを呼び出すには、Julia 1.7以降が必要です。それ以前のバージョンでは、bytes2hexを呼び出す前に、イテレータをcollectできます。
Examples
julia> a = string(12345, base = 16)
"3039"
julia> b = hex2bytes(a)
2-element Vector{UInt8}:
0x30
0x39
julia> bytes2hex(b)
"3039"General Number Functions and Constants
Base.one — Function
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型の量が必要で、xが次元を持つ場合は、代わりにoneunitを使用してください。
identity関数、および単位行列についてはLinearAlgebraのIも参照してください。
Examples
julia> one(3.7)
1.0
julia> one(Int)
1
julia> import Dates; one(Dates.Day(1))
1Base.oneunit — Function
oneunit(x::T)
oneunit(T::Type)T(one(x))を返します。ここで、Tは引数の型です。ただし、型だけからoneunitを推定できる場合は、引数そのものを返します。これは、次元を持つ量の場合のoneとは異なります。oneは無次元(乗法単位元)ですが、oneunitは次元を持ちます(xと同じ型、またはT型です)。
Examples
julia> oneunit(3.7)
1.0
julia> import Dates; oneunit(Dates.Day)
1 dayBase.zero — Function
zero(x)
zero(::Type)xの加法単位元を取得します。加法単位元が型だけから推論できる場合は、zeroの引数に型を指定できます。
たとえば、zero(Int)は、Intのすべてのインスタンスで加法単位元が同じなので動作します。一方、長さの異なるベクトルでは加法単位元も異なるため、zero(Vector{Int})は定義されていません。
関連項目: iszero、one、oneunit、oftype。
Examples
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.0Base.MathConstants.pi — Constant
π
pi定数 pi。
Unicode π は、Julia REPL や多くのエディタで \pi と入力してから Tab キーを押すと入力できます。
Examples
julia> pi
π = 3.1415926535897...
julia> 1/2pi
0.15915494309189535Base.MathConstants.ℯ — Constant
ℯ
e定数 ℯ。
Unicode ℯ は、Julia REPL や多くのエディターで \euler と入力して Tab キーを押すと入力できます。
Examples
julia> ℯ
ℯ = 2.7182818284590...
julia> log(ℯ)
1
julia> ℯ^(im)π ≈ -1
trueBase.MathConstants.catalan — Constant
catalanカタラン定数。
Examples
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.9159466120554123Base.MathConstants.eulergamma — Constant
γ
eulergammaオイラー定数。
Examples
julia> Base.MathConstants.eulergamma
γ = 0.5772156649015...
julia> dx = 10^-6;
julia> sum(-exp(-x) * log(x) for x in dx:dx:100) * dx
0.5772078382499133Base.MathConstants.golden — Constant
φ
golden黄金比。
Examples
julia> Base.MathConstants.golden
φ = 1.6180339887498...
julia> (2ans - 1)^2 ≈ 5
trueBase.Inf32 — Constant
Inf32型 Float32 の正の無限大。
Base.Inf16 — Constant
Inf16型 Float16 の正の無限大。
Base.NaN32 — Constant
Base.NaN16 — Constant
Base.issubnormal — Function
issubnormal(f)::Bool浮動小数点数が非正規数かどうかを判定します。
IEEE 浮動小数点数は、指数部のビットがすべて 0 で、仮数部が 0 でない場合、subnormalです。
Examples
julia> floatmin(Float32)
1.1754944f-38
julia> issubnormal(1.0f-37)
false
julia> issubnormal(1.0f-38)
trueBase.isfinite — Function
isfinite(f)::Bool数値が有限かどうかを判定します。
Examples
julia> isfinite(5)
true
julia> isfinite(NaN32)
falseBase.isone — Function
isone(x)trueを返します。x == one(x)の場合、xが配列なら、xが単位行列かどうかを判定します。
Examples
julia> isone(1.0)
true
julia> isone([1 0; 0 2])
false
julia> isone([1 0; 0 true])
trueBase.nextfloat — Function
nextfloat(x::AbstractFloat)xと同じ型で、x < yを満たす最小の浮動小数点数yを返します。そのようなyが存在しない場合(たとえば、xがInfまたはNaNの場合)は、xを返します。
関連項目:prevfloat、eps、issubnormal。
nextfloat(x::AbstractFloat, n::Integer)n >= 0 の場合、x に nextfloat を n 回繰り返し適用した結果、または n < 0 の場合、prevfloat を -n 回適用した結果。
Base.prevfloat — Function
prevfloat(x::AbstractFloat)xと同じ型で、y < xを満たす最大の浮動小数点数yを返します。そのようなyが存在しない場合(たとえば、xが-InfまたはNaNの場合)、xを返します。
prevfloat(x::AbstractFloat, n::Integer)x に prevfloat を n 回反復適用した結果(n >= 0 の場合)、または nextfloat を -n 回適用した結果(n < 0 の場合)。
Base.isinteger — Function
isinteger(x)::Boolxが、ある整数と数値的に等しいかどうかを判定します。
Examples
julia> isinteger(4.0)
trueBase.isreal — Function
isreal(x)::Boolx またはそのすべての要素が、無限大や NaN を含む何らかの実数と数値的に等しいかどうかを判定します。isreal(x) は、isequal(x, real(x)) が true の場合に true になります。
Examples
julia> isreal(5.)
true
julia> isreal(1 - 3im)
false
julia> isreal(Inf + 0im)
true
julia> isreal([4.; complex(0,1)])
falseCore.Float32 — Method
Float32(x [, mode::RoundingMode])xからFloat32を作成します。xを正確に表現できない場合は、modeによってxの丸め方が決まります。
Examples
julia> Float32(1/3, RoundDown)
0.3333333f0
julia> Float32(1/3, RoundUp)
0.33333334f0利用可能な丸めモードについては、RoundingModeを参照してください。
Core.Float64 — Method
Float64(x [, mode::RoundingMode])xからFloat64を作成します。xを正確に表現できない場合は、modeによってxの丸め方が決まります。
Examples
julia> Float64(pi, RoundDown)
3.141592653589793
julia> Float64(pi, RoundUp)
3.1415926535897936利用可能な丸めモードについては、RoundingModeを参照してください。
Base.Rounding.rounding — Function
rounding(T)型 T の現在の浮動小数点丸めモードを取得します。このモードは、基本的な算術関数(+、-、*、/、sqrt)および型変換における丸めを制御します。
利用可能なモードについては、RoundingMode を参照してください。
Base.Rounding.setrounding — Method
setrounding(T, mode)浮動小数点型 T の丸めモードを設定します。これにより、基本的な算術関数(+、-、*、/、sqrt)および型変換での丸め方が決まります。デフォルトの RoundNearest 以外の丸めモードを使用すると、ほかの数値関数が誤った値や無効な値を返すことがあります。
現在、この機能がサポートされているのは T == BigFloat のみです。
Base.Rounding.setrounding — Method
setrounding(f::Function, T, mode)浮動小数点型 T の丸めモードを、f の実行中に変更します。これは論理的には次と同等です。
old = rounding(T)
setrounding(T, mode)
f()
setrounding(T, old)使用可能な丸めモードについては、RoundingMode を参照してください。
Base.Rounding.get_zero_subnormals — Function
get_zero_subnormals()::Bool非正規化浮動小数点数(「デノーマル」)に対する演算が IEEE 算術の規則に従う場合は false を返し、ゼロに変換される可能性がある場合は true を返します。
Base.Rounding.set_zero_subnormals — Function
set_zero_subnormals(yes::Bool)::Boolyes が false の場合、その後の浮動小数点演算では、サブノーマル値(「デノーマル」)に対する IEEE 算術の規則に従います。それ以外の場合、浮動小数点演算では、サブノーマルな入力値または出力値をゼロに変換することが許可されます(必須ではありません)。yes==true であり、かつハードウェアがサブノーマル数のゼロ化をサポートしていない場合を除き、true を返します。
set_zero_subnormals(true) によって、一部のハードウェアでは一部の計算が高速化されることがあります。ただし、(x-y==0) == (x==y) のような恒等式が成り立たなくなる場合があります。
Integers
Base.count_ones — Function
count_ones(x::Integer)::Integerxの2進表現に含まれる1の個数。
Examples
julia> count_ones(7)
3
julia> count_ones(Int32(-1))
32Base.count_zeros — Function
count_zeros(x::Integer)::Integerxの2進表現に含まれる0の個数。
Examples
julia> count_zeros(Int32(2 ^ 16 - 1))
16
julia> count_zeros(-1)
0Base.leading_zeros — Function
leading_zeros(x::Integer)::Integerxの2進表現における先行ゼロの数。
Examples
julia> leading_zeros(Int32(1))
31Base.leading_ones — Function
leading_ones(x::Integer)::Integerx の2進表現の先頭に連続する1の個数。
Examples
julia> leading_ones(UInt32(2 ^ 32 - 2))
31Base.trailing_zeros — Function
trailing_zeros(x::Integer)::Integerx の2進表現における末尾のゼロの個数。
Examples
julia> trailing_zeros(2)
1Base.trailing_ones — Function
trailing_ones(x::Integer)::Integer2進表現の末尾に連続する 1 の個数(x)。
Examples
julia> trailing_ones(3)
2Base.isodd — Function
isodd(x::Number)::Boolx が奇数(つまり、2 で割り切れない整数)の場合は true を返し、それ以外の場合は false を返します。
Examples
julia> isodd(9)
true
julia> isodd(10)
falseBase.iseven — Function
iseven(x::Number)::Booltrue を返します。ただし、x が偶数(つまり、2で割り切れる整数)の場合に限ります。それ以外の場合は false を返します。
Examples
julia> iseven(9)
false
julia> iseven(10)
trueCore.@int128_str — Macro
@int128_str strstr を Int128 として解析します。文字列が有効な整数でない場合は、ArgumentError をスローします。
Examples
julia> int128"123456789123"
123456789123
julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]Core.@uint128_str — Macro
@uint128_str strstr を UInt128 として解析します。文字列が有効な整数でない場合は、ArgumentError をスローします。
Examples
julia> uint128"123456789123"
0x00000000000000000000001cbe991a83
julia> uint128"-123456789123"
ERROR: LoadError: ArgumentError: invalid base 10 digit '-' in "-123456789123"
[...]BigFloats and BigInts
BigFloat 型と BigInt 型は、それぞれ任意精度の浮動小数点演算と整数演算を実装しています。BigFloat には GNU MPFR library が使用され、BigInt には [GNU Multiple Precision Arithmetic Library (GMP)] (https://gmplib.org) が使用されます。
Base.MPFR.BigFloat — Method
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)が期待どおりの結果にならないことがあります。このため、利便性を考慮して用意されています。
関連項目:
キーワード引数としてprecisionを使うには、Julia 1.1以降が必要です。Julia 1.0では、precisionは2番目の位置引数です(BigFloat(x, precision))。
Examples
julia> BigFloat(2.1) # 2.1 here is a Float64
2.100000000000000088817841970012523233890533447265625
julia> BigFloat("2.1") # the closest BigFloat to 2.1
2.099999999999999999999999999999999999999999999999999999999999999999999999999986
julia> BigFloat("2.1", RoundUp)
2.100000000000000000000000000000000000000000000000000000000000000000000000000021
julia> BigFloat("2.1", RoundUp, precision=128)
2.100000000000000000000000000000000000007Base.precision — Function
precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)浮動小数点数の精度(仮数部の有効ビット数で定義)を取得します。または、浮動小数点型 T の精度を取得します(T が BigFloat のような可変精度型の場合は、現在のデフォルト精度)。
base を指定すると、その基数での仮数部の桁数に対応する最大値を返します。
Base.MPFR.setprecision — Function
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で指定された精度を使用しません。
setprecision([T=BigFloat,] precision::Int; base=2)T 演算で使用する精度をビット単位で設定します(デフォルト)。base を指定した場合、指定された base で少なくとも precision 桁を得るために必要な最小精度が設定されます。
Base.GMP.BigInt — Method
BigInt(x)任意精度整数を作成します。xは、Int(またはIntに変換可能な任意の値)である場合があります。この型では通常の数学演算子が定義されており、演算結果はBigIntに昇格されます。
文字列からはparseを使ってインスタンスを作成できます。また、big文字列リテラルを使うこともできます。
Examples
julia> parse(BigInt, "42")
42
julia> big"313"
313
julia> BigInt(10)^19
10000000000000000000Core.@big_str — Macro
@big_str str文字列をBigIntまたはBigFloatに変換します。文字列が有効な数値でない場合は、ArgumentErrorをスローします。整数の場合、区切り文字として_を文字列に含めることができます。
Examples
julia> big"123_456"
123456
julia> big"7891.5"
7891.5
julia> big"_"
ERROR: ArgumentError: invalid number format _ for BigInt or BigFloat
[...]@big_strを使ってBigFloatの値を構築しても、直感的に期待される動作にならない場合があります。マクロである@big_strは、グローバルな精度(setprecision)と丸めモード(setrounding)の設定を、読み込み時の値に従って適用します。そのため、() -> precision(big"0.3")のような関数は、関数の呼び出し時の精度ではなく、関数の定義時点での精度に依存する値を定数として返します。