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)
      └─ Irrational

Abstract number types

Core.Number — Type
Number

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

source
Core.Real — Type
Real <: Number

すべての実数の抽象スーパータイプ。

source
Core.Integer — Type
Integer <: Real

すべての整数(例:Signed、Unsigned、Bool)の抽象スーパータイプです。

関連項目:isinteger、trunc、div。

Examples

julia> 42 isa Integer
true

julia> 1.0 isa Integer
false

julia> isinteger(1.0)
true
source
Core.Signed — Type
Signed <: Integer

すべての符号付き整数の抽象スーパータイプ。

source
Core.Unsigned — Type
Unsigned <: Integer

すべての符号なし整数の抽象スーパータイプです。

組み込みの符号なし整数は、接頭辞 0x を付けた16進数で表示され、同じ形式で入力できます。

Examples

julia> typemax(UInt8)
0xff

julia> Int(0x00d)
13

julia> unsigned(true)
0x0000000000000001
source
Base.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 と同じ値になるよう定義する必要があります。

source

Concrete number types

Core.Float16 — Type
Float16 <: AbstractFloat <: Real

16 ビット浮動小数点数型(IEEE 754 規格)。バイナリ形式は、符号 1 ビット、指数部 5 ビット、仮数部 10 ビットです。

source
Core.Float32 — Type
Float32 <: AbstractFloat <: Real

IEEE 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]

Inf32、NaN32、Float16、exponent、frexpも参照してください。

source
Core.Float64 — Type
Float64 <: AbstractFloat <: Real

64ビット浮動小数点数型(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です。

関連項目:Inf、NaN、floatmax、Float32、Complex。

source
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  1

trues、falses、ifelse も参照してください。

source
Core.Int8 — Type
Int8 <: Signed <: Integer

8ビット符号付き整数型。

n ∈ -128:127の数値を表します。このような整数は警告なしにオーバーフローするため、typemax(Int8) + Int8(1) < 0に注意してください。

関連項目: Int、widen、BigInt。

source
Core.UInt8 — Type
UInt8 <: Unsigned <: Integer

8ビット符号なし整数型。

16進数で表示されるため、0x07 == 7。

source
Core.Int16 — Type
Int16 <: Signed <: Integer

16ビット符号付き整数型。

n ∈ -32768:32767 の数値を表します。このような整数は警告なしにオーバーフローするため、typemax(Int16) + Int16(1) < 0 であることに注意してください。

関連項目: Int、widen、BigInt。

source
Core.UInt16 — Type
UInt16 <: Unsigned <: Integer

16ビット符号なし整数型。

16進数で表示されるため、0x000f == 15 です。

source
Core.Int32 — Type
Int32 <: Signed <: Integer

32ビット符号付き整数型。

この型の整数は警告なしにオーバーフローするため、typemax(Int32) + Int32(1) < 0 に注意してください。

Int、widen、BigInt も参照してください。

source
Core.UInt32 — Type
UInt32 <: Unsigned <: Integer

32ビット符号なし整数型。

16進数で表示されるため、0x0000001f == 31 となります。

source
Core.Int64 — Type
Int64 <: Signed <: Integer

64ビット符号付き整数型。

この型の整数は警告なしにオーバーフローするため、typemax(Int64) + Int64(1) < 0に注意してください。

Int、widen、BigIntも参照してください。

source
Core.UInt64 — Type
UInt64 <: Unsigned <: Integer

64ビット符号なし整数型。

16進数で表示されるため、0x000000000000003f == 63 です。

source
Core.Int128 — Type
Int128 <: Signed <: Integer

128ビット符号付き整数型。

この型の整数は警告なしにオーバーフローするため、typemax(Int128) + Int128(1) < 0。

関連項目: Int、widen、BigInt。

source
Core.UInt128 — Type
UInt128 <: Unsigned <: Integer

128ビット符号なし整数型。

16進数で表示されるため、0x0000000000000000000000000000007f == 127 となります。

source
Core.Int — Type
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 も参照してください。

source
Core.UInt — Type
UInt

Sys.WORD_SIZE ビットの符号なし整数型、UInt <: Unsigned <: Integer。

Int と同様に、エイリアス UInt は、コンピューターごとの Sys.WORD_SIZE の値に応じて、UInt32 または UInt64 を指すことがあります。

16 進数で表示・解析されます: UInt(15) === 0x000000000000000f。

source
Base.Complex — Type
Complex{T<:Real} <: Number

実部と虚部の型が T である複素数型です。

ComplexF16、ComplexF32、ComplexF64 は、それぞれ Complex{Float16}、Complex{Float32}、Complex{Float64} の別名です。

関連項目: Real、complex、real。

source
Base.Rational — Type
Rational{T<:Integer} <: Real

分子と分母の型がTである有理数型です。有理数のオーバーフローはチェックされます。

source
Base.Irrational — Type
Irrational{sym} <: AbstractIrrational

sym で表される、厳密な無理数値を表す数値型です。例として、π、ℯ、γ があります。

AbstractIrrational も参照してください。

source

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))
true
source
Base.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
 0
source
Base.bitstring — Function
bitstring(n)

プリミティブ型のビット表現を文字列で示します(ビッグエンディアン、つまり最上位ビットが先頭)。

関連項目:count_ones、count_zeros、digits。

Examples

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

julia> bitstring(2.2)
"0100000000000001100110011001100110011001100110011001100110011010"
source
Base.parse — Function
parse(::Type{SimpleColor}, rgb::String)

tryparse(SimpleColor, rgb::String)(そちらを参照)に相当する関数ですが、nothingを返す代わりにエラーを発生させます。

source
parse(type, str; base)

文字列を数値として解析します。Integer 型では基数を指定できます(既定値は 10 です)。浮動小数点型の場合、文字列は 10 進浮動小数点数として解析されます。Complex 型では、"R±Iim" 形式の 10 進文字列を、要求された型の Complex(R,I) として解析します。"im" の代わりに "i" または "j" を使用することもでき、"R" または "Iim" も使用できます。文字列に有効な数値が含まれていない場合は、エラーが発生します。

Julia 1.1

parse(Bool, str) を使用するには、Julia 1.1 以降が必要です。

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.5im
source
parse(::Type{Platform}, triplet::AbstractString)

文字列のプラットフォームトリプレットを解析し、Platform オブジェクトに戻します。

source
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")
source
tryparse(type, str; base)

parseと似ていますが、要求された型の値を返すか、文字列に有効な数値が含まれていない場合はnothingを返します。

source
Base.big — Function
big(x)

数値を最大精度の表現(通常はBigIntまたはBigFloat)に変換します。浮動小数点数に関する注意点については、BigFloatを参照してください。

source
Base.signed — Function
signed(x)

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

関連項目: unsigned、sign、signbit。

source
signed(T::Integer)

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

Examples

julia> signed(UInt16)
Int16
julia> signed(UInt64)
Int64
source
Base.unsigned — Function
unsigned(T::Integer)

整数ビット型を、同じサイズの符号なし型に変換します。

Examples

julia> unsigned(Int16)
UInt16
julia> unsigned(UInt64)
UInt64
source
Base.float — Method
float(x)

数値または配列を浮動小数点型に変換します。

関連項目: complex、oftype、convert。

Examples

julia> float(typemax(Int32))
2.147483647e9
source
Base.Math.significand — Function
significand(x)

浮動小数点数の仮数(マンティッサ)を取り出します。x がゼロ以外の有限数の場合、戻り値は x と同じ型および符号を持ち、絶対値が $[1,2)$ の区間内にある数値です。それ以外の場合は x を返します。

frexp、exponent も参照してください。

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)
source
Base.Math.exponent — Function
exponent(x::Real)::Int

y が 2^y ≤ abs(x) を満たす最大の整数を返します。正規化された浮動小数点数 x の場合、これは x の指数に相当します。

x がゼロ、無限大、または NaN の場合、DomainError をスローします。その他の非サブノーマル浮動小数点数 x では、これは x の指数ビットに相当します。

Julia 1.14

Bool に対して exponent を呼び出すには、Julia 1.14 以降が必要です。

関連項目: 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.
[...]
source
Base.complex — Method
complex(r, [i])

実数または配列を複素数に変換します。i の既定値はゼロです。

Examples

julia> complex(7)
7 + 0im
source
Base.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"
source
Base.hex2bytes — Function
hex2bytes(itr)

16進数の各桁に対応するASCIIコードの反復可能オブジェクトitrを受け取り、その2進表現に対応するバイト列Vector{UInt8}を返します。itrに含まれる16進数の各桁を順に2つずつ組み合わせ、その値を戻り値のベクトル内の1バイトとして表します。

itrの長さは偶数でなければなりません。返される配列の長さはitrの半分です。インプレース版についてはhex2bytes!を、逆変換についてはbytes2hexを参照してください。

Julia 1.7

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
 0xef
source
Base.hex2bytes! — Function
hex2bytes!(dest::AbstractVector{UInt8}, itr)

16進数文字列を表すバイトのイテラブルitrを、バイナリ表現に変換します。hex2bytesと同様ですが、出力はdestにインプレースで書き込まれます。destの長さは、itrの長さの半分でなければなりません。

Julia 1.7

UInt8を生成するイテレータを使ってhex2bytes!を呼び出すには、バージョン1.7が必要です。それ以前のバージョンでは、呼び出す前にイテラブルをcollectしてください。

source
Base.bytes2hex — Function
bytes2hex(itr)::String
bytes2hex(io::IO, itr)::Nothing

バイトのイテレータitrを16進文字列に変換します。bytes2hex(itr)を介してStringを返すか、bytes2hex(io, itr)を介してioストリームに文字列を書き込みます。16進文字はすべて小文字です。

Julia 1.7

任意のイテレータから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"
source

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))
1
source
Base.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 day
source
Base.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.0
source
Base.im — Constant
im

虚数単位。

関連項目:imag、angle、complex。

Examples

julia> im * im
-1 + 0im

julia> (2.0 + 3im)^2
-5.0 + 12.0im
source
Base.MathConstants.pi — Constant
π
pi

定数 pi。

Unicode π は、Julia REPL や多くのエディタで \pi と入力してから Tab キーを押すと入力できます。

関連項目: sinpi、sincospi、deg2rad。

Examples

julia> pi
π = 3.1415926535897...

julia> 1/2pi
0.15915494309189535
source
Base.MathConstants.ℯ — Constant
ℯ
e

定数 ℯ。

Unicode ℯ は、Julia REPL や多くのエディターで \euler と入力して Tab キーを押すと入力できます。

関連項目: exp、cis、cispi。

Examples

julia> ℯ
ℯ = 2.7182818284590...

julia> log(ℯ)
1

julia> ℯ^(im)π ≈ -1
true
source
Base.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.9159466120554123
source
Base.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.5772078382499133
source
Base.MathConstants.golden — Constant
φ
golden

黄金比。

Examples

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

julia> (2ans - 1)^2 ≈ 5
true
source
Base.NaN — Constant
NaN, NaN64

Float64 型の非数値。

関連項目: isnan、missing、NaN32、Inf。

Examples

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

NaN の確認には、必ず isnan または isequal を使用してください。x === NaN を使用すると、予期しない結果になることがあります。

julia> reinterpret(UInt32, NaN32)
0x7fc00000

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

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)
source
Base.NaN64 — Constant
NaN, NaN64

Float64 型の非数値。

関連項目: isnan、missing、NaN32、Inf。

Examples

julia> 0/0
NaN

julia> Inf - Inf
NaN

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

NaN の確認には、必ず isnan または isequal を使用してください。x === NaN を使用すると、予期しない結果になることがあります。

julia> reinterpret(UInt32, NaN32)
0x7fc00000

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

julia> NaN32p1 === NaN32, isequal(NaN32p1, NaN32), isnan(NaN32p1)
(false, true, true)
source
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)
true
source
Base.isfinite — Function
isfinite(f)::Bool

数値が有限かどうかを判定します。

Examples

julia> isfinite(5)
true

julia> isfinite(NaN32)
false
source
Base.isnan — Function
isnan(f)::Bool

数値が NaN、つまり無限大でも有限数でもない不定値(「数ではない」値)かどうかを判定します。

関連項目: iszero、isone、isinf、ismissing。

source
Base.iszero — Function
iszero(x)

true を返します。x == zero(x) の場合、x が配列であれば、x のすべての要素がゼロかどうかを判定します。

関連項目: isone、isinteger、isfinite、isnan。

Examples

julia> iszero(0.0)
true

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

julia> iszero([false, 0, 0])
true
source
Base.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])
true
source
Base.nextfloat — Function
nextfloat(x::AbstractFloat)

xと同じ型で、x < yを満たす最小の浮動小数点数yを返します。そのようなyが存在しない場合(たとえば、xがInfまたはNaNの場合)は、xを返します。

関連項目:prevfloat、eps、issubnormal。

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

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

source
Base.prevfloat — Function
prevfloat(x::AbstractFloat)

xと同じ型で、y < xを満たす最大の浮動小数点数yを返します。そのようなyが存在しない場合(たとえば、xが-InfまたはNaNの場合)、xを返します。

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

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

source
Base.isinteger — Function
isinteger(x)::Bool

xが、ある整数と数値的に等しいかどうかを判定します。

Examples

julia> isinteger(4.0)
true
source
Base.isreal — Function
isreal(x)::Bool

x またはそのすべての要素が、無限大や 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)])
false
source
Core.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を参照してください。

source
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を参照してください。

source
Base.Rounding.rounding — Function
rounding(T)

型 T の現在の浮動小数点丸めモードを取得します。このモードは、基本的な算術関数(+、-、*、/、sqrt)および型変換における丸めを制御します。

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

source
Base.Rounding.setrounding — Method
setrounding(T, mode)

浮動小数点型 T の丸めモードを設定します。これにより、基本的な算術関数(+、-、*、/、sqrt)および型変換での丸め方が決まります。デフォルトの RoundNearest 以外の丸めモードを使用すると、ほかの数値関数が誤った値や無効な値を返すことがあります。

現在、この機能がサポートされているのは T == BigFloat のみです。

Warning

この関数はスレッドセーフではありません。すべてのスレッドで実行中のコードに影響しますが、この設定を使用する計算と同時に呼び出した場合の動作は未定義です。

source
Base.Rounding.setrounding — Method
setrounding(f::Function, T, mode)

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

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

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

source
Base.Rounding.get_zero_subnormals — Function
get_zero_subnormals()::Bool

非正規化浮動小数点数(「デノーマル」)に対する演算が IEEE 算術の規則に従う場合は false を返し、ゼロに変換される可能性がある場合は true を返します。

Warning

この関数の影響を受けるのは、現在のスレッドのみです。

source
Base.Rounding.set_zero_subnormals — Function
set_zero_subnormals(yes::Bool)::Bool

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

set_zero_subnormals(true) によって、一部のハードウェアでは一部の計算が高速化されることがあります。ただし、(x-y==0) == (x==y) のような恒等式が成り立たなくなる場合があります。

Warning

この関数の影響を受けるのは、現在のスレッドのみです。

source

Integers

Base.count_ones — Function
count_ones(x::Integer)::Integer

xの2進表現に含まれる1の個数。

Examples

julia> count_ones(7)
3

julia> count_ones(Int32(-1))
32
source
Base.count_zeros — Function
count_zeros(x::Integer)::Integer

xの2進表現に含まれる0の個数。

Examples

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

julia> count_zeros(-1)
0
source
Base.leading_zeros — Function
leading_zeros(x::Integer)::Integer

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

Examples

julia> leading_zeros(Int32(1))
31
source
Base.leading_ones — Function
leading_ones(x::Integer)::Integer

x の2進表現の先頭に連続する1の個数。

Examples

julia> leading_ones(UInt32(2 ^ 32 - 2))
31
source
Base.trailing_zeros — Function
trailing_zeros(x::Integer)::Integer

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

Examples

julia> trailing_zeros(2)
1
source
Base.trailing_ones — Function
trailing_ones(x::Integer)::Integer

2進表現の末尾に連続する 1 の個数(x)。

Examples

julia> trailing_ones(3)
2
source
Base.isodd — Function
isodd(x::Number)::Bool

x が奇数(つまり、2 で割り切れない整数)の場合は true を返し、それ以外の場合は false を返します。

Julia 1.7

Integer 以外の引数には、Julia 1.7 以降が必要です。

Examples

julia> isodd(9)
true

julia> isodd(10)
false
source
Base.iseven — Function
iseven(x::Number)::Bool

true を返します。ただし、x が偶数(つまり、2で割り切れる整数)の場合に限ります。それ以外の場合は false を返します。

Julia 1.7

Integer 以外の引数には、Julia 1.7 以降が必要です。

Examples

julia> iseven(9)
false

julia> iseven(10)
true
source
Core.@int128_str — Macro
@int128_str str

str を Int128 として解析します。文字列が有効な整数でない場合は、ArgumentError をスローします。

Examples

julia> int128"123456789123"
123456789123

julia> int128"123456789123.4"
ERROR: LoadError: ArgumentError: invalid base 10 digit '.' in "123456789123.4"
[...]
source
Core.@uint128_str — Macro
@uint128_str str

str を UInt128 として解析します。文字列が有効な整数でない場合は、ArgumentError をスローします。

Examples

julia> uint128"123456789123"
0x00000000000000000000001cbe991a83

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

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)が期待どおりの結果にならないことがあります。このため、利便性を考慮して用意されています。

関連項目:

Julia 1.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.100000000000000000000000000000000000007
source
Base.precision — Function
precision(num::AbstractFloat; base::Integer=2)
precision(T::Type; base::Integer=2)

浮動小数点数の精度(仮数部の有効ビット数で定義)を取得します。または、浮動小数点型 T の精度を取得します(T が BigFloat のような可変精度型の場合は、現在のデフォルト精度)。

base を指定すると、その基数での仮数部の桁数に対応する最大値を返します。

Julia 1.8

base キーワードを使用するには、Julia 1.8 以降が必要です。

source
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で指定された精度を使用しません。

Warning

このメソッドには、precisionとsetprecisionを呼び出すフォールバック実装がありますが、今後はこれに依存しないでください。代わりに、ScopedValueを使用する形で3引数版を直接定義するか、呼び出し側でScopedValueと@withを使うよう推奨してください。

Julia 1.8

baseキーワードを使用するには、Julia 1.8以降が必要です。

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

T 演算で使用する精度をビット単位で設定します(デフォルト)。base を指定した場合、指定された base で少なくとも precision 桁を得るために必要な最小精度が設定されます。

Warning

この関数はスレッドセーフではありません。すべてのスレッドで実行中のコードに影響しますが、この設定を使用する計算と同時に呼び出した場合の動作は未定義です。

Julia 1.8

base キーワードを使用するには、Julia 1.8 以降が必要です。

source
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
10000000000000000000
source
Core.@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
[...]
Warning

@big_strを使ってBigFloatの値を構築しても、直感的に期待される動作にならない場合があります。マクロである@big_strは、グローバルな精度(setprecision)と丸めモード(setrounding)の設定を、読み込み時の値に従って適用します。そのため、() -> precision(big"0.3")のような関数は、関数の呼び出し時の精度ではなく、関数の定義時点での精度に依存する値を定数として返します。

source