Documentation
¶
Overview ¶
bigパッケージは任意精度算術（大きな数）を実装します。 以下の数値型がサポートされています:
Int 符号付き整数 Rat 有理数 Float 浮動小数点数
Int、Rat、またはFloatのゼロ値は0に対応します。したがって、新しい 値は通常の方法で宣言でき、さらなる初期化なしで0を示します：
var x Int // &xは値0の*Intです
var r = &Rat{} // rは値0の*Ratです
y := new(Float) // yは値0の*Floatです
あるいは、新しい値は以下の形式のファクトリ関数で割り当てて初期化することができます：
func NewT(v V) *T
例えば、NewInt(x)はint64引数xの値に設定された*Intを返し、 NewRat(a, b)はaとbがint64値である分数a/bに設定された*Ratを返し、 NewFloat(f)はfloat64引数fに初期化された*Floatを返します。 より柔軟性を提供するために、明示的なセッターが提供されています。例えば：
var z1 Int z1.SetUint64(123) // z1 := 123 z2 := new(Rat).SetFloat64(1.25) // z2 := 5/4 z3 := new(Float).SetInt(z1) // z3 := 123.0
セッター、数値演算、および述語は、以下の形式のメソッドとして表現されます：
func (z *T) SetV(v V) *T // z = v func (z *T) Unary(x *T) *T // z = unary x func (z *T) Binary(x, y *T) *T // z = x binary y func (x *T) Pred() P // p = pred(x)
TはInt、Rat、またはFloatのいずれかです。単項および二項演算の場合、 結果はレシーバ（通常その場合はzと名付けられます。以下参照）であり、 それがオペランドxまたはyのいずれかであれば、安全に上書き（およびそのメモリの再利用）が可能です。
算術式は通常、個々のメソッド呼び出しのシーケンスとして書かれ、 各呼び出しが操作に対応します。レシーバは結果を示し、 メソッドの引数は操作のオペランドです。 例えば、*Int値a、b、cが与えられた場合、次の呼び出し
c.Add(a, b)
これは、a + bの和を計算し、結果をcに格納します。これにより、 以前にcに格納されていた値は上書きされます。特に指定がない限り、 操作はパラメータのエイリアシングを許可するため、次のように書いても問題ありません。
sum.Add(sum, x)
これにより、値xがsumに累積されます。
(常にレシーバ経由で結果値を渡すことにより、メモリの使用を はるかによく制御できます。各結果に新たにメモリを割り当てる代わりに、 操作は結果値に割り当てられたスペースを再利用し、 そのプロセスで新しい結果でその値を上書きすることができます。)
表記法の規則：APIで一貫して名前が付けられている入力メソッドパラメータ（レシーバを含む） は、その使用法を明確にするためです。入力オペランドは通常、x、y、a、bなどと名付けられますが、 zとは名付けられません。結果を指定するパラメータはzと名付けられます（通常はレシーバ）。
例えば、(*Int).Addの引数はxとyと名付けられています。 そして、レシーバが結果の格納先を指定するため、それはzと呼ばれます：
func (z *Int) Add(x, y *Int) *Int
この形式のメソッドは、単純な呼び出しチェーンを可能にするため、通常、受け取ったレシーバも返します。
結果値を渡す必要がないメソッド（例えば、Int.Sign）は、単に結果を返します。 この場合、レシーバは通常、最初のオペランドで、xと名付けられます：
func (x *Int) Sign() int
さまざまなメソッドが文字列と対応する数値との間の変換をサポートしており、その逆も可能です： *Int、*Rat、および*Floatの値は、値の（デフォルトの）文字列表現のためのStringerインターフェースを実装しますが、 また、さまざまなサポートされている形式で文字列から値を初期化するためのSetStringメソッドも提供します （それぞれのSetStringのドキュメンテーションを参照してください）。
最後に、*Int、*Rat、および*Floatは、スキャンのための[fmt.Scanner]を満たし、 （*Ratを除いて）フォーマットされた印刷のためのFormatterインターフェースを満たします。
Example (EConvergents) ¶
この例では、big.Ratを使用して、自然対数の基数である定数eの 有理数収束のシーケンスの最初の15項を計算する方法を示します。
for i := 1; i <= 15; i++ {
r := recur(0, int64(i))
// rを分数と浮動小数点数の両方として印刷します。
// big.Ratはfmt.Formatterを実装しているので、%-13sを使用して
// 分数の左揃えの文字列表現を取得することができます。
fmt.Printf("%-13s = %s\n", r, r.FloatString(8))
}
Output: 2/1 = 2.00000000 3/1 = 3.00000000 8/3 = 2.66666667 11/4 = 2.75000000 19/7 = 2.71428571 87/32 = 2.71875000 106/39 = 2.71794872 193/71 = 2.71830986 1264/465 = 2.71827957 1457/536 = 2.71828358 2721/1001 = 2.71828172 23225/8544 = 2.71828184 25946/9545 = 2.71828182 49171/18089 = 2.71828183 517656/190435 = 2.71828183
Example (Fibonacci) ¶
この例では、big.Intを使用して100桁の最小のフィボナッチ数を計算し、 それが素数であるかどうかをテストする方法を示しています。
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
// シーケンスの最初の2つの数で2つのbig intを初期化します。
a := big.NewInt(0)
b := big.NewInt(1)
// limitを10^99（100桁の最小の整数）として初期化します。
var limit big.Int
limit.Exp(big.NewInt(10), big.NewInt(99), nil)
// aが1e100より小さい間ループします。
for a.Cmp(&limit) < 0 {
// 次のフィボナッチ数を計算し、それをaに格納します。
a.Add(a, b)
// aとbを交換して、bがシーケンスの次の数になるようにします。
a, b = b, a
}
fmt.Println(a) // 100桁のフィボナッチ数
// aが素数であるかどうかをテストします。
// (ProbablyPrimesの引数は、実行するミラー-ラビン
// ラウンドの数を設定します。20は良い値です。)
fmt.Println(a.ProbablyPrime(20))
}
Output: 1344719667586153181419716641724567886890850696275767987106294472017884974410332069524504824747437757 false
Example (Sqrt2) ¶
この例では、big.Floatを使用して精度200ビットで2の平方根を計算し、 結果を10進数として印刷する方法を示します。
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math"
"github.com/shogo82148/std/math/big"
)
func main() {
// 我々は、仮数部に200ビットの精度で計算を行います。
const prec = 200
// ニュートンの方法を使用して2の平方根を計算します。我々は
// sqrt(2)の初期推定値から始め、次に反復します：
// x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )
// ニュートンの方法は各反復で正確な桁数を2倍にするため、
// 我々は少なくともlog_2(prec)ステップが必要です。
steps := int(math.Log2(prec))
// 計算に必要な値を初期化します。
two := new(big.Float).SetPrec(prec).SetInt64(2)
half := new(big.Float).SetPrec(prec).SetFloat64(0.5)
// 初期推定値として1を使用します。
x := new(big.Float).SetPrec(prec).SetInt64(1)
// tを一時的な変数として使用します。big.Floatの値は、精度が設定されていない（== 0）場合、
// big.Floatの操作の結果（レシーバ）として使用されるときに自動的に引数の最大精度を引き継ぐため、
// tの精度を設定する必要はありません。
t := new(big.Float)
// Iterate.
for i := 0; i <= steps; i++ {
t.Quo(two, x) // t = 2.0 / x_n
t.Add(x, t) // t = x_n + (2.0 / x_n)
x.Mul(half, t) // x_{n+1} = 0.5 * t
}
// big.Floatはfmt.Formatterを実装しているので、通常のfmt.Printfの動詞を使用できます
fmt.Printf("sqrt(2) = %.50f\n", x)
// 2とx*xの間の誤差を印刷します。
t.Mul(x, x) // t = x*x
fmt.Printf("error = %e\n", t.Sub(two, t))
}
Output: sqrt(2) = 1.41421356237309504880168872420969807856967187537695 error = 0.000000e+00
Index ¶
- Constants
- func Jacobi(x, y *Int) int
- type Accuracy
- type ErrNaN
- type Float
- func (z *Float) Abs(x *Float) *Float
- func (x *Float) Acc() Accuracy
- func (z *Float) Add(x, y *Float) *Float
- func (x *Float) Append(buf []byte, fmt byte, prec int) []byte
- func (x *Float) Cmp(y *Float) int
- func (z *Float) Copy(x *Float) *Float
- func (x *Float) Float32() (float32, Accuracy)
- func (x *Float) Float64() (float64, Accuracy)
- func (x *Float) Format(s fmt.State, format rune)
- func (z *Float) GobDecode(buf []byte) error
- func (x *Float) GobEncode() ([]byte, error)
- func (x *Float) Int(z *Int) (*Int, Accuracy)
- func (x *Float) Int64() (int64, Accuracy)
- func (x *Float) IsInf() bool
- func (x *Float) IsInt() bool
- func (x *Float) MantExp(mant *Float) (exp int)
- func (x *Float) MarshalText() (text []byte, err error)
- func (x *Float) MinPrec() uint
- func (x *Float) Mode() RoundingMode
- func (z *Float) Mul(x, y *Float) *Float
- func (z *Float) Neg(x *Float) *Float
- func (z *Float) Parse(s string, base int) (f *Float, b int, err error)
- func (x *Float) Prec() uint
- func (z *Float) Quo(x, y *Float) *Float
- func (x *Float) Rat(z *Rat) (*Rat, Accuracy)
- func (z *Float) Scan(s fmt.ScanState, ch rune) error
- func (z *Float) Set(x *Float) *Float
- func (z *Float) SetFloat64(x float64) *Float
- func (z *Float) SetInf(signbit bool) *Float
- func (z *Float) SetInt(x *Int) *Float
- func (z *Float) SetInt64(x int64) *Float
- func (z *Float) SetMantExp(mant *Float, exp int) *Float
- func (z *Float) SetMode(mode RoundingMode) *Float
- func (z *Float) SetPrec(prec uint) *Float
- func (z *Float) SetRat(x *Rat) *Float
- func (z *Float) SetString(s string) (*Float, bool)
- func (z *Float) SetUint64(x uint64) *Float
- func (x *Float) Sign() int
- func (x *Float) Signbit() bool
- func (z *Float) Sqrt(x *Float) *Float
- func (x *Float) String() string
- func (z *Float) Sub(x, y *Float) *Float
- func (x *Float) Text(format byte, prec int) string
- func (x *Float) Uint64() (uint64, Accuracy)
- func (z *Float) UnmarshalText(text []byte) error
- type Int
- func (z *Int) Abs(x *Int) *Int
- func (z *Int) Add(x, y *Int) *Int
- func (z *Int) And(x, y *Int) *Int
- func (z *Int) AndNot(x, y *Int) *Int
- func (x *Int) Append(buf []byte, base int) []byte
- func (z *Int) Binomial(n, k int64) *Int
- func (x *Int) Bit(i int) uint
- func (x *Int) BitLen() int
- func (x *Int) Bits() []Word
- func (x *Int) Bytes() []byte
- func (x *Int) Cmp(y *Int) (r int)
- func (x *Int) CmpAbs(y *Int) int
- func (z *Int) Div(x, y *Int) *Int
- func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)
- func (z *Int) Exp(x, y, m *Int) *Int
- func (x *Int) FillBytes(buf []byte) []byte
- func (x *Int) Float64() (float64, Accuracy)
- func (x *Int) Format(s fmt.State, ch rune)
- func (z *Int) GCD(x, y, a, b *Int) *Int
- func (z *Int) GobDecode(buf []byte) error
- func (x *Int) GobEncode() ([]byte, error)
- func (x *Int) Int64() int64
- func (x *Int) IsInt64() bool
- func (x *Int) IsUint64() bool
- func (z *Int) Lsh(x *Int, n uint) *Int
- func (x *Int) MarshalJSON() ([]byte, error)
- func (x *Int) MarshalText() (text []byte, err error)
- func (z *Int) Mod(x, y *Int) *Int
- func (z *Int) ModInverse(g, n *Int) *Int
- func (z *Int) ModSqrt(x, p *Int) *Int
- func (z *Int) Mul(x, y *Int) *Int
- func (z *Int) MulRange(a, b int64) *Int
- func (z *Int) Neg(x *Int) *Int
- func (z *Int) Not(x *Int) *Int
- func (z *Int) Or(x, y *Int) *Int
- func (x *Int) ProbablyPrime(n int) bool
- func (z *Int) Quo(x, y *Int) *Int
- func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)
- func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int
- func (z *Int) Rem(x, y *Int) *Int
- func (z *Int) Rsh(x *Int, n uint) *Int
- func (z *Int) Scan(s fmt.ScanState, ch rune) error
- func (z *Int) Set(x *Int) *Int
- func (z *Int) SetBit(x *Int, i int, b uint) *Int
- func (z *Int) SetBits(abs []Word) *Int
- func (z *Int) SetBytes(buf []byte) *Int
- func (z *Int) SetInt64(x int64) *Int
- func (z *Int) SetString(s string, base int) (*Int, bool)
- func (z *Int) SetUint64(x uint64) *Int
- func (x *Int) Sign() int
- func (z *Int) Sqrt(x *Int) *Int
- func (x *Int) String() string
- func (z *Int) Sub(x, y *Int) *Int
- func (x *Int) Text(base int) string
- func (x *Int) TrailingZeroBits() uint
- func (x *Int) Uint64() uint64
- func (z *Int) UnmarshalJSON(text []byte) error
- func (z *Int) UnmarshalText(text []byte) error
- func (z *Int) Xor(x, y *Int) *Int
- type Rat
- func (z *Rat) Abs(x *Rat) *Rat
- func (z *Rat) Add(x, y *Rat) *Rat
- func (x *Rat) Cmp(y *Rat) int
- func (x *Rat) Denom() *Int
- func (x *Rat) Float32() (f float32, exact bool)
- func (x *Rat) Float64() (f float64, exact bool)
- func (x *Rat) FloatString(prec int) string
- func (z *Rat) GobDecode(buf []byte) error
- func (x *Rat) GobEncode() ([]byte, error)
- func (z *Rat) Inv(x *Rat) *Rat
- func (x *Rat) IsInt() bool
- func (x *Rat) MarshalText() (text []byte, err error)
- func (z *Rat) Mul(x, y *Rat) *Rat
- func (z *Rat) Neg(x *Rat) *Rat
- func (x *Rat) Num() *Int
- func (z *Rat) Quo(x, y *Rat) *Rat
- func (x *Rat) RatString() string
- func (z *Rat) Scan(s fmt.ScanState, ch rune) error
- func (z *Rat) Set(x *Rat) *Rat
- func (z *Rat) SetFloat64(f float64) *Rat
- func (z *Rat) SetFrac(a, b *Int) *Rat
- func (z *Rat) SetFrac64(a, b int64) *Rat
- func (z *Rat) SetInt(x *Int) *Rat
- func (z *Rat) SetInt64(x int64) *Rat
- func (z *Rat) SetString(s string) (*Rat, bool)
- func (z *Rat) SetUint64(x uint64) *Rat
- func (x *Rat) Sign() int
- func (x *Rat) String() string
- func (z *Rat) Sub(x, y *Rat) *Rat
- func (z *Rat) UnmarshalText(text []byte) error
- type RoundingMode
- type Word
Examples ¶
Constants ¶
指数と精度の制限。
const MaxBase = 10 + ('z' - 'a' + 1) + ('Z' - 'A' + 1)
MaxBaseは、文字列変換に受け入れられる最大の数値基数です。
Variables ¶
This section is empty.
Functions ¶
Types ¶
type Accuracy ¶ added in v1.5.0
type Accuracy int8
Accuracyは、Float値を生成した最新の操作によって生じた丸め誤差を、 正確な値に対して説明します。
type ErrNaN ¶ added in v1.5.0
type ErrNaN struct {
// contains filtered or unexported fields
}
ErrNaNパニックは、IEEE-754のルールに従ってNaNになるFloat操作によって引き起こされます。 ErrNaNはエラーインターフェースを実装します。
type Float ¶ added in v1.5.0
type Float struct {
// contains filtered or unexported fields
}
非ゼロ有限Floatは、多精度浮動小数点数を表しますr
符号 × 仮数部 × 2**指数
0.5 <= 仮数部 < 1.0、および MinExp <= 指数 <= MaxExpとなります。 Floatはゼロ（+0、-0）または無限（+Inf、-Inf）でもあり得ます。 すべてのFloatは順序付けられており、二つのFloat xとyの順序付けは x.Cmp(y)によって定義されます。
各Float値には、精度、丸めモード、および精度もあります。 精度は、値を表現するために利用可能な仮数部ビットの最大数です。 丸めモードは、結果が仮数部ビットに収まるようにどのように丸められるべきかを指定します、 精度は、正確な結果に対する丸め誤差を説明します。
特に指定がない限り、結果として*Float変数を指定するすべての操作（セッターを含む）は、 通常レシーバを介して（MantExpの例外を除く）、結果変数の精度と丸めモードに従って数値結果を丸めます。
提供された結果の精度が0（以下参照）の場合、それは丸めが行われる前に 最大の精度値を持つ引数の精度に設定され、丸めモードは変更されません。したがって、 結果の引数として提供される未初期化のFloatは、その精度がオペランドによって 決定される合理的な値に設定され、そのモードはRoundingModeのゼロ値（ToNearestEven）です。
望ましい精度を24または53に設定し、対応する丸めモード（通常はToNearestEven）を使用すると、 Float操作は、正常（つまり、非正規化ではない）float32またはfloat64数に対応するオペランドに対して、 対応するfloat32またはfloat64 IEEE-754算術と同じ結果を生成します。 指数のアンダーフローとオーバーフローは、Floatの指数がはるかに大きな範囲を持つため、 IEEE-754とは異なる値に対して0またはInfinityを導きます。
Floatのゼロ（未初期化）値は使用準備が整っており、 精度0と丸めモードToNearestEvenで数値+0.0を正確に表します。
操作は常にポインタ引数（*Float）を取るのではなく、 Float値を取り、各一意のFloat値は自身の一意の*Floatポインタを必要とします。 Float値を「コピー」するには、既存の（または新しく割り当てられた）Floatを Float.Setメソッドを使用して新しい値に設定する必要があります。 Floatの浅いコピーはサポートされておらず、エラーを引き起こす可能性があります。
Example (Shift) ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
// (二進数の)指数を直接修正することでFloat "shift"を実装します。
for s := -5; s <= 5; s++ {
x := big.NewFloat(0.5)
x.SetMantExp(x, x.MantExp(nil)+s) // xをsだけシフトします
fmt.Println(x)
}
}
Output: 0.015625 0.03125 0.0625 0.125 0.25 0.5 1 2 4 8 16
func NewFloat ¶ added in v1.5.0
NewFloatは、精度53と丸めモードToNearestEvenでxに設定された新しいFloatを割り当てて返します。 xがNaNの場合、NewFloatはErrNaNでパニックを起こします。
func ParseFloat ¶ added in v1.5.0
ParseFloatは、指定された精度と丸めモードでfを設定した状態のf.Parse(s, base)と同じです。
func (*Float) Add ¶ added in v1.5.0
Addは、zを丸められた和x+yに設定し、zを返します。zの精度が0の場合、 操作前にxの精度またはyの精度の大きい方に変更されます。 丸めはzの精度と丸めモードに従って行われ、 zの精度は正確な（丸められていない）結果に対する結果のエラーを報告します。 xとyが逆の符号の無限大である場合、AddはErrNaNでパニックを起こします。 その場合、zの値は未定義です。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
// 異なる精度の数値で操作します。
var x, y, z big.Float
x.SetInt64(1000) // xは自動的に64ビット精度に設定されます
y.SetFloat64(2.718281828) // yは自動的に53ビット精度に設定されます
z.SetPrec(32)
z.Add(&x, &y)
fmt.Printf("x = %.10g (%s, prec = %d, acc = %s)\n", &x, x.Text('p', 0), x.Prec(), x.Acc())
fmt.Printf("y = %.10g (%s, prec = %d, acc = %s)\n", &y, y.Text('p', 0), y.Prec(), y.Acc())
fmt.Printf("z = %.10g (%s, prec = %d, acc = %s)\n", &z, z.Text('p', 0), z.Prec(), z.Acc())
}
Output: x = 1000 (0x.fap+10, prec = 64, acc = Exact) y = 2.718281828 (0x.adf85458248cd8p+2, prec = 53, acc = Exact) z = 1002.718282 (0x.faadf854p+10, prec = 32, acc = Below)
func (*Float) Append ¶ added in v1.5.0
Appendは、x.Textによって生成された浮動小数点数xの文字列形式をbufに追加し、 拡張されたバッファを返します。
func (*Float) Cmp ¶ added in v1.5.0
Cmpはxとyを比較し、次の値を返します:
-1 は x < y 0 は x == y (これには -0 == 0, -Inf == -Inf, そして +Inf == +Inf も含まれます) +1 は x > y
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math"
"github.com/shogo82148/std/math/big"
)
func main() {
inf := math.Inf(1)
zero := 0.0
operands := []float64{-inf, -1.2, -zero, 0, +1.2, +inf}
fmt.Println(" x y cmp")
fmt.Println("---------------")
for _, x64 := range operands {
x := big.NewFloat(x64)
for _, y64 := range operands {
y := big.NewFloat(y64)
fmt.Printf("%4g %4g %3d\n", x, y, x.Cmp(y))
}
fmt.Println()
}
}
Output: x y cmp --------------- -Inf -Inf 0 -Inf -1.2 -1 -Inf -0 -1 -Inf 0 -1 -Inf 1.2 -1 -Inf +Inf -1 -1.2 -Inf 1 -1.2 -1.2 0 -1.2 -0 -1 -1.2 0 -1 -1.2 1.2 -1 -1.2 +Inf -1 -0 -Inf 1 -0 -1.2 1 -0 -0 0 -0 0 0 -0 1.2 -1 -0 +Inf -1 0 -Inf 1 0 -1.2 1 0 -0 0 0 0 0 0 1.2 -1 0 +Inf -1 1.2 -Inf 1 1.2 -1.2 1 1.2 -0 1 1.2 0 1 1.2 1.2 0 1.2 +Inf -1 +Inf -Inf 1 +Inf -1.2 1 +Inf -0 1 +Inf 0 1 +Inf 1.2 1 +Inf +Inf 0
func (*Float) Float32 ¶ added in v1.5.0
Float32は、xに最も近いfloat32の値を返します。xが小さすぎて float32で表現できない場合（|x| < math.SmallestNonzeroFloat32）、結果は （0, Below）または（-0, Above）となります。これはxの符号によります。 xが大きすぎてfloat32で表現できない場合（|x| > math.MaxFloat32）、 結果は（+Inf, Above）または（-Inf, Below）となります。これもxの符号によります。
func (*Float) Float64 ¶ added in v1.5.0
Float64は、xに最も近いfloat64の値を返します。xが小さすぎて float64で表現できない場合（|x| < math.SmallestNonzeroFloat64）、結果は （0, Below）または（-0, Above）となります。これはxの符号によります。 xが大きすぎてfloat64で表現できない場合（|x| > math.MaxFloat64）、 結果は（+Inf, Above）または（-Inf, Below）となります。これもxの符号によります。
func (*Float) Format ¶ added in v1.5.0
Formatはfmt.Formatterを実装します。通常の浮動小数点数のフォーマット('b', 'e', 'E', 'f', 'F', 'g', 'G', 'x')と同様に'p'と'v'も受け入れます。'p'の解釈については(*Float).Textを参照してください。 'v'フォーマットは'g'のように扱われます。 Formatはまた、最小精度の指定、出力フィールドの幅、および符号制御のための'+'と' 'フラグ、 スペースまたはゼロパディングのための'0'、左または右の正当化のための'-'フラグもサポートしています。 詳細はfmtパッケージを参照してください。
func (*Float) GobDecode ¶ added in v1.7.0
GobDecodeは、gob.GobDecoderインターフェースを実装します。 結果は、zの精度と丸めモードに従って丸められます。 ただし、zの精度が0の場合、zは正確にデコードされた値に設定されます。
func (*Float) GobEncode ¶ added in v1.7.0
GobEncodeは、gob.GobEncoderインターフェースを実装します。 Floatの値とそのすべての属性（精度、丸めモード、精度）がマーシャルされます。
func (*Float) Int ¶ added in v1.5.0
Intは、xをゼロに向かって切り捨てた結果を返します。 または、xが無限大の場合はnilを返します。 結果はx.IsInt()の場合はExact、それ以外の場合はx > 0の場合はBelow、 x < 0の場合はAboveです。 非nilの*Int引数zが提供された場合、Intは結果をzに格納します。 新しいIntを割り当てる代わりに。
func (*Float) Int64 ¶ added in v1.5.0
Int64は、xをゼロに向かって切り捨てることによって得られる整数を返します。 math.MinInt64 <= x <= math.MaxInt64の場合、結果はxが整数の場合はExact、それ以外の場合はAbove（x < 0）またはBelow（x > 0）です。 結果はx < math.MinInt64の場合は（math.MinInt64, Above）、x > math.MaxInt64の場合は（math.MaxInt64, Below）です。
func (*Float) MantExp ¶ added in v1.5.0
MantExpはxをその仮数部と指数部に分解し、指数を返します。 非nilのmant引数が提供された場合、その値はxの仮数部に設定され、 xと同じ精度と丸めモードを持ちます。コンポーネントは x == mant × 2**exp、0.5 <= |mant| < 1.0を満たします。 nil引数でMantExpを呼び出すことは、レシーバの指数を効率的に取得する方法です。
特殊なケースは以下の通りです:
( ±0).MantExp(mant) = 0、mantは ±0に設定されます (±Inf).MantExp(mant) = 0、mantは ±Infに設定されます
xとmantは同じものである可能性があり、その場合、xはその 仮数部の値に設定されます。
func (*Float) MarshalText ¶ added in v1.6.0
MarshalTextは、encoding.TextMarshalerインターフェースを実装します。 Floatの値のみが（全精度で）マーシャルされ、精度や精度などの他の属性は無視されます。
func (*Float) MinPrec ¶ added in v1.5.0
MinPrecは、xを正確に表現するために必要な最小精度を返します （つまり、x.SetPrec(prec)がxを丸め始める最小のprec）。 結果は、|x| == 0 および |x| == Inf の場合、0になります。
func (*Float) Mul ¶ added in v1.5.0
Mulは、zを丸められた積x*yに設定し、zを返します。 精度、丸め、および精度報告はAddと同様です。 一方のオペランドがゼロで、他方のオペランドが無限大である場合、MulはErrNaNでパニックを起こします。 その場合、zの値は未定義です。
func (*Float) Parse ¶ added in v1.5.0
Parseは、指定された変換基数で仮数を持つ浮動小数点数のテキスト表現、 または無限大を表す文字列を含むsを解析します（指数は常に10進数です）。
基数が0の場合、アンダースコア文字 "_" は基数のプレフィックスと隣接する数字の間、 または連続する数字の間に現れることがあります。そのようなアンダースコアは、 数値の値や返される数字の数に変化を与えません。アンダースコアの配置が間違っている場合、 他にエラーがない場合に限り、エラーとして報告されます。基数が0でない場合、 アンダースコアは認識されず、したがって、有効な基数点または数字でない他の任意の文字と同様に、 スキャンを終了します。
zを対応する浮動小数点値の（可能性のある丸められた）値に設定し、 z、実際の基数b、およびエラーerr（ある場合）を返します。 成功するためには、文字列全体（プレフィックスだけでなく）が消費されなければなりません。 zの精度が0の場合、丸めが効く前に64に変更されます。 数字は次の形式でなければなりません:
number = [ sign ] ( float | "inf" | "Inf" ) .
sign = "+" | "-" .
float = ( mantissa | prefix pmantissa ) [ exponent ] .
prefix = "0" [ "b" | "B" | "o" | "O" | "x" | "X" ] .
mantissa = digits "." [ digits ] | digits | "." digits .
pmantissa = [ "_" ] digits "." [ digits ] | [ "_" ] digits | "." digits .
exponent = ( "e" | "E" | "p" | "P" ) [ sign ] digits .
digits = digit { [ "_" ] digit } .
digit = "0" ... "9" | "a" ... "z" | "A" ... "Z" .
基数引数は0、2、8、10、または16でなければなりません。無効な基数引数を提供すると、 実行時にパニックが発生します。
基数が0の場合、数値のプレフィックスが実際の基数を決定します：プレフィックスが "0b"または"0B"は基数2を選択し、"0o"または"0O"は基数8を選択し、 "0x"または"0X"は基数16を選択します。それ以外の場合、実際の基数は10であり、 プレフィックスは受け入れられません。8進数のプレフィックス"0"はサポートされていません（先頭の "0"は単に"0"と見なされます）。
"p"または"P"の指数は、基数10ではなく基数2の指数を示します。 例えば、"0x1.fffffffffffffp1023"（基数0を使用）は、最大のfloat64値を表します。 16進数の仮数については、指数文字が存在する場合、'p'または'P'のいずれかでなければなりません （"e"または"E"の指数指示子は、仮数の数字と区別できません）。
エラーが報告された場合、返される*Float fはnilで、zの値は有効ですが定義されていません。
func (*Float) Prec ¶ added in v1.5.0
Precは、xの仮数部の精度をビット単位で返します。 結果は、|x| == 0 および |x| == Inf の場合、0になる可能性があります。
func (*Float) Quo ¶ added in v1.5.0
Quoは、zを丸められた商x/yに設定し、zを返します。 精度、丸め、および精度報告はAddと同様です。 両方のオペランドがゼロまたは無限大である場合、QuoはErrNaNでパニックを起こします。 その場合、zの値は未定義です。
func (*Float) Rat ¶ added in v1.5.0
Ratは、xに対応する有理数を返します。 または、xが無限大の場合はnilを返します。 結果はxがInfでない場合はExactです。 非nilの*Rat引数zが提供された場合、Ratは結果をzに格納します。 新しいRatを割り当てる代わりに。
func (*Float) Scan ¶ added in v1.8.0
Scanは、fmt.Scannerのサポートルーチンで、zをスキャンされた数値に設定します。 これは、浮動小数点値に対してfmt.Scanがサポートする動詞を持つ形式を受け入れます。それらは次のとおりです: 'b'（バイナリ）、'e'、'E'、'f'、'F'、'g'、'G'。 Scanは±Infを処理しません。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/log"
"github.com/shogo82148/std/math/big"
)
func main() {
// Scan関数は直接使用されることはほとんどありません。
// fmtパッケージは、fmt.Scannerの実装としてこれを認識します。
f := new(big.Float)
_, err := fmt.Sscan("1.19282e99", f)
if err != nil {
log.Println("error scanning value:", err)
} else {
fmt.Println(f)
}
}
Output: 1.19282e+99
func (*Float) Set ¶ added in v1.5.0
Setは、zをxの（可能性のある丸められた）値に設定し、zを返します。 zの精度が0の場合、zを設定する前にxの精度に変更されます （そして丸めは影響を及ぼしません）。 丸めはzの精度と丸めモードに従って実行され、 zの精度は正確な（丸められていない）結果に対する結果のエラーを報告します。
func (*Float) SetFloat64 ¶ added in v1.5.0
SetFloat64は、zをxの（可能性のある丸められた）値に設定し、zを返します。 zの精度が0の場合、それは53に変更されます（そして丸めは影響を及ぼしません）。 xがNaNの場合、SetFloat64はErrNaNでパニックを起こします。
func (*Float) SetInf ¶ added in v1.5.0
SetInfは、signbitが設定されている場合はzを無限のFloat -Infに、 設定されていない場合は+Infに設定し、zを返します。 zの精度は変わらず、結果は常にExactです。
func (*Float) SetInt ¶ added in v1.5.0
SetIntは、zをxの（可能性のある丸められた）値に設定し、zを返します。 zの精度が0の場合、それはx.BitLen()または64の大きい方に変更されます （そして丸めは影響を及ぼしません）。
func (*Float) SetInt64 ¶ added in v1.5.0
SetInt64は、zをxの（可能性のある丸められた）値に設定し、zを返します。 zの精度が0の場合、それは64に変更されます（そして丸めは影響を及ぼしません）。
func (*Float) SetMantExp ¶ added in v1.5.0
SetMantExpはzをmant × 2**expに設定し、zを返します。 結果のzは、mantと同じ精度と丸めモードを持ちます。 SetMantExpはMantExpの逆ですが、0.5 <= |mant| < 1.0を必要としません。 特に、*Float型の指定されたxに対して、SetMantExpはMantExpと次のように関連しています:
mant := new(Float) new(Float).SetMantExp(mant, x.MantExp(mant)).Cmp(x) == 0
特殊なケースは以下の通りです:
z.SetMantExp( ±0, exp) = ±0 z.SetMantExp(±Inf, exp) = ±Inf
zとmantは同じものである可能性があり、その場合、zの指数はexpに設定されます。
func (*Float) SetMode ¶ added in v1.5.0
func (z *Float) SetMode(mode RoundingMode) *Float
SetModeはzの丸めモードをmodeに設定し、正確なzを返します。 それ以外の場合、zは変更されません。 z.SetMode(z.Mode())は、zの精度をExactに設定するための安価な方法です。
func (*Float) SetPrec ¶ added in v1.5.0
SetPrecはzの精度をprecに設定し、（可能な場合）zの丸められた 値を返します。仮数部が精度の損失なしにprecビットで表現できない場合、 zの丸めモードに従って丸めが行われます。 SetPrec(0)はすべての有限値を±0にマップします；無限値は変更されません。 prec > MaxPrecの場合、precはMaxPrecに設定されます。
func (*Float) SetRat ¶ added in v1.5.0
SetRatは、zをxの（可能性のある丸められた）値に設定し、zを返します。 zの精度が0の場合、それはa.BitLen()、b.BitLen()、または64の最大のものに変更されます； x = a/bとします。
func (*Float) SetString ¶ added in v1.5.0
SetStringは、zをsの値に設定し、zと成功を示すブール値を返します。 sは、基数引数0でParseによって受け入れられるのと同じ形式の浮動小数点数でなければなりません。 成功するためには、文字列全体（プレフィックスだけでなく）が有効でなければなりません。 操作が失敗した場合、zの値は未定義ですが、返される値はnilです。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
f := new(big.Float)
f.SetString("3.14159")
fmt.Println(f)
}
Output: 3.14159
func (*Float) SetUint64 ¶ added in v1.5.0
SetUint64は、zをxの（可能性のある丸められた）値に設定し、zを返します。 zの精度が0の場合、それは64に変更されます（そして丸めは影響を及ぼしません）。
func (*Float) Sqrt ¶ added in v1.10.0
Sqrtは、zをxの四捨五入した平方根に設定し、それを返します。
もしzの精度が0なら、操作前にxの精度に変更されます。丸めはzの精度と 丸めモードに従って行われますが、zの精度は計算されません。具体的には、 z.Acc()の結果は未定義です。
もしz < 0なら、関数はパニックを引き起こします。その場合、zの値は未定義です。
func (*Float) String ¶ added in v1.5.0
Stringはxをx.Text('g', 10)のようにフォーマットします。 (Stringは明示的に呼び出す必要があります、Float.Formatは%s動詞をサポートしていません。)
func (*Float) Sub ¶ added in v1.5.0
Subは、zを丸められた差分x-yに設定し、zを返します。 精度、丸め、および精度報告はAddと同様です。 xとyが同じ符号の無限大である場合、SubはErrNaNでパニックを起こします。 その場合、zの値は未定義です。
func (*Float) Text ¶ added in v1.5.0
Textは、与えられたフォーマットと精度precに従って、浮動小数点数xを文字列に変換します。 フォーマットは次のいずれかです:
'e' -d.dddde±dd, 10進数の指数、少なくとも2つ（可能性のある0）の指数の桁 'E' -d.ddddE±dd, 10進数の指数、少なくとも2つ（可能性のある0）の指数の桁 'f' -ddddd.dddd, 指数なし 'g' 大きな指数の場合は'e'のように、それ以外の場合は'f'のように 'G' 大きな指数の場合は'E'のように、それ以外の場合は'f'のように 'x' -0xd.dddddp±dd, 16進数の仮数、2の力の10進数の指数 'p' -0x.dddp±dd, 16進数の仮数、2の力の10進数の指数（非標準） 'b' -ddddddp±dd, 10進数の仮数、2の力の10進数の指数（非標準）
2の力の指数形式の場合、仮数は正規化された形式で印刷されます:
'x' 16進数の仮数は[1, 2)、または0 'p' 16進数の仮数は[½, 1)、または0 'b' x.Prec()ビットを使用した10進数の整数仮数、または0
'x'形式は、他のほとんどの言語やライブラリで使用されている形式であることに注意してください。
フォーマットが異なる文字の場合、Textは"%"と認識されないフォーマット文字を続けて返します。
精度precは、'e'、'E'、'f'、'g'、'G'、および'x'の形式で印刷される桁数（指数を除く）を制御します。 'e'、'E'、'f'、および'x'の場合、それは小数点の後の桁数です。 'g'と'G'の場合、それは全体の桁数です。負の精度は、x.Prec()マンティッサビットを使用して 値xを一意に識別するために必要な最小の10進数の桁数を選択します。 'b'と'p'の形式では、prec値は無視されます。
func (*Float) Uint64 ¶ added in v1.5.0
Uint64は、xをゼロに向かって切り捨てることによって得られる符号なし整数を返します。 0 <= x <= math.MaxUint64の場合、結果はxが整数の場合はExact、それ以外の場合はBelowです。 x < 0の場合、結果は(0, Above)で、x > math.MaxUint64の場合は(math.MaxUint64, Below)です。
func (*Float) UnmarshalText ¶ added in v1.6.0
UnmarshalTextは、encoding.TextUnmarshalerインターフェースを実装します。 結果は、zの精度と丸めモードに従って丸められます。 ただし、zの精度が0の場合、丸めが効く前に64に変更されます。
type Int ¶
type Int struct {
// contains filtered or unexported fields
}
Intは、符号付きの多倍長整数を表します。 Intのゼロ値は値0を表します。
操作は常にポインタ引数（*Int）を取り、 各ユニークなInt値は自身のユニークな*Intポインタを必要とします。 Int値を「コピー」するには、既存の（または新しく割り当てられた）Intを Int.Setメソッドを使用して新しい値に設定する必要があります。 Intの浅いコピーはサポートされておらず、エラーを引き起こす可能性があります。
メソッドは、タイミングのサイドチャネルを通じてIntの値を漏らす可能性があることに注意してください。 このため、そして実装の範囲と複雑さのため、Intは暗号化操作を実装するのに適していません。 標準ライブラリは、攻撃者が制御する入力に対して非自明なIntメソッドを公開することを避け、 math/bigのバグがセキュリティ脆弱性と見なされるかどうかは、標準ライブラリへの影響によって決まる可能性があります。
func (*Int) Bits ¶
Bitsは、xの絶対値をリトルエンディアンのWordスライスとして返すことで、 xへの生の（チェックされていないが高速な）アクセスを提供します。結果とxは 同じ基本配列を共有します。 Bitsは、このパッケージ外部で欠けている低レベルのInt機能の実装をサポートすることを目的としています。 それ以外の場合は避けるべきです。
func (*Int) Bytes ¶
Bytesは、xの絶対値をビッグエンディアンのバイトスライスとして返します。
固定長のスライスや、事前に割り当てられたものを使用するには、FillBytesを使用します。
func (*Int) CmpAbs ¶ added in v1.10.0
CmpAbsはxとyの絶対値を比較し、次の値を返します:
-1 は |x| < |y| の場合 0 は |x| == |y| の場合 +1 は |x| > |y| の場合
func (*Int) Div ¶
Divは、y != 0の場合、zを商x/yに設定し、zを返します。 y == 0の場合、ゼロ除算のランタイムパニックが発生します。 Divはユークリッド除算を実装します（Goとは異なります）；詳細はDivModを参照してください。
func (*Int) DivMod ¶
DivModは、y != 0の場合、zを商x div yに、mを余りx mod yに設定し、 ペア(z, m)を返します。 y == 0の場合、ゼロ除算のランタイムパニックが発生します。
DivModはユークリッドの除算とモジュラスを実装します（Goとは異なります）：
q = x div y となるような m = x - y*q で 0 <= m < |y|
（Raymond T. Boute, "The Euclidean definition of the functions div and mod". ACM Transactions on Programming Languages and Systems (TOPLAS), 14(2):127-144, New York, NY, USA, 4/1992. ACM press.を参照） T-除算とモジュラス（Goと同様）についてはQuoRemを参照してください。
func (*Int) Exp ¶
Expは、z = x**y mod |m|（つまり、mの符号は無視されます）を設定し、zを返します。 もしm == nilまたはm == 0なら、y <= 0ならz = 1、それ以外の場合はz = x**yです。 もしm != 0、y < 0、そしてxとmが相互に素ではない場合、zは変更されず、nilが返されます。
特定のサイズの入力のモジュラ指数は、暗号学的に一定時間の操作ではありません。
func (*Int) FillBytes ¶ added in v1.15.0
FillBytesは、bufをxの絶対値に設定し、それをゼロ拡張のビッグエンディアンのバイトスライスとして格納し、 bufを返します。
もしxの絶対値がbufに収まらない場合、FillBytesはパニックを起こします。
func (*Int) Format ¶
Formatは、fmt.Formatterを実装します。次の形式を受け入れます 'b'（二進数）、'o'（0接頭辞付きの8進数）、'O'（0o接頭辞付きの8進数）、 'd'（10進数）、'x'（小文字の16進数）、そして 'X'（大文字の16進数）。 また、符号制御のための'+'と' '、8進数の先頭ゼロと16進数のための'#'、 "%#x"と"%#X"に対する先頭の"0x"または"0X"、最小桁数の精度の指定、出力フィールド 幅、スペースまたはゼロパディング、そして左または右 寄せのための'-'を含む、パッケージfmtの整数型のための完全な形式 フラグもサポートされています。
func (*Int) GCD ¶
GCDは、zをaとbの最大公約数に設定し、zを返します。 もしxまたはyがnilでなければ、GCDはz = a*x + b*yとなるようにそれらの値を設定します。
aとbは正、ゼロ、または負のいずれかである可能性があります。（Go 1.14以前は両方とも > 0である必要がありました。）aとbの符号に関係なく、zは常に>= 0です。
もしa == b == 0なら、GCDはz = x = y = 0に設定します。
もしa == 0でb != 0なら、GCDはz = |b|、x = 0、y = sign(b) * 1に設定します。
もしa != 0でb == 0なら、GCDはz = |a|、x = sign(a) * 1、y = 0に設定します。
func (*Int) MarshalJSON ¶ added in v1.1.0
MarshalJSONは、json.Marshalerインターフェースを実装します。
func (*Int) MarshalText ¶ added in v1.3.0
MarshalTextは、encoding.TextMarshalerインターフェースを実装します。
func (*Int) Mod ¶
Modは、y != 0の場合、zを余りx%yに設定し、zを返します。 y == 0の場合、ゼロ除算のランタイムパニックが発生します。 Modはユークリッドのモジュラスを実装します（Goとは異なります）；詳細はDivModを参照してください。
func (*Int) ModInverse ¶
ModInverseは、zを環ℤ/nℤにおけるgの乗法的逆数に設定し、zを返します。 もしgとnが互いに素でない場合、gは環ℤ/nℤに乗法的逆数を持ちません。 この場合、zは変更されず、戻り値はnilです。もしn == 0なら、ゼロ除算のランタイムパニックが発生します。
func (*Int) ModSqrt ¶ added in v1.5.0
ModSqrtは、存在する場合、zをx mod pの平方根に設定し、zを返します。 剰余pは奇数の素数でなければなりません。もしxがp modの平方でない場合、 ModSqrtはzを変更せず、nilを返します。この関数は、pが奇数でない場合にパニックを起こします。 pが奇数だが素数でない場合の動作は未定義です。
func (*Int) ProbablyPrime ¶
ProbablyPrimeは、xがおそらく素数であるかどうかを報告します。 これは、n個の擬似ランダムに選ばれた基底とともにミラー-ラビンテストを適用し、 ベイリー-PSWテストも行います。
xが素数の場合、ProbablyPrimeはtrueを返します。 xがランダムに選ばれ、素数でない場合、ProbablyPrimeはおそらくfalseを返します。 ランダムに選ばれた非素数に対してtrueを返す確率は最大で¼ⁿです。
ProbablyPrimeは、2⁶⁴未満の入力に対しては100%正確です。 エラー確率の詳細な議論については、Menezesらの「Handbook of Applied Cryptography」、1997年、pp. 145-149、 およびFIPS 186-4 Appendix Fを参照してください。
ProbablyPrimeは、敵がテストを欺くために作成した可能性のある素数を判断するのに適していません。
Go 1.8以降、ProbablyPrime(0)が許可され、Baillie-PSWテストのみが適用されます。 Go 1.8以前では、ProbablyPrimeはMiller-Rabinテストのみを適用し、ProbablyPrime(0)はパニックを引き起こしました。
func (*Int) Quo ¶
Quoは、y != 0の場合、zを商x/yに設定し、zを返します。 y == 0の場合、ゼロ除算のランタイムパニックが発生します。 Quoは切り捨て除算（Goと同様）を実装します。詳細はQuoRemを参照してください。
func (*Int) QuoRem ¶
QuoRemは、y != 0の場合、zを商x/yに、rを余りx%yに設定し、 ペア(z, r)を返します。 y == 0の場合、ゼロ除算のランタイムパニックが発生します。
QuoRemはT-除算とモジュラス（Goと同様）を実装します：
q = x/y 結果はゼロに切り捨てられます r = x - y*q
（Daan Leijenの「コンピュータサイエンティストのための除算とモジュラス」を参照） ユークリッド除算とモジュラス（Goとは異なる）についてはDivModを参照してください。
func (*Int) Rand ¶
Randは、zを[0, n)の範囲の擬似乱数に設定し、zを返します。
これはmath/randパッケージを使用しているため、 セキュリティに敏感な作業には使用してはなりません。代わりにcrypto/rand.Intを使用してください。
func (*Int) Rem ¶
Remは、y != 0の場合、zを余りx%yに設定し、zを返します。 y == 0の場合、ゼロ除算のランタイムパニックが発生します。 Remは切り捨てモジュラス（Goと同様）を実装します。詳細はQuoRemを参照してください。
func (*Int) Scan ¶
Scanは、fmt.Scannerのサポートルーチンであり、zをスキャンされた数値に設定します。 形式 'b'（二進数）、'o'（8進数）、'd'（10進数）、'x'（小文字の16進数）、'X'（大文字の16進数）を受け入れます。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/log"
"github.com/shogo82148/std/math/big"
)
func main() {
// Scan関数は直接使用されることはほとんどありません。
// fmtパッケージは、fmt.Scannerの実装としてこれを認識します。
i := new(big.Int)
_, err := fmt.Sscan("18446744073709551617", i)
if err != nil {
log.Println("error scanning value:", err)
} else {
fmt.Println(i)
}
}
Output: 18446744073709551617
func (*Int) SetBit ¶
SetBitは、xのi番目のビットをb（0または1）に設定したxをzに設定します。 つまり、もしbが1なら、SetBitはz = x | (1 << i)を設定します。 もしbが0なら、SetBitはz = x &^ (1 << i)を設定します。もしbが0または1でない場合、 SetBitはパニックを起こします。
func (*Int) SetBits ¶
SetBitsは、zの値をリトルエンディアンのWordスライスとして解釈されるabsに設定し、 zを返すことで、zへの生の（チェックされていないが高速な）アクセスを提供します。 結果とabsは同じ基本配列を共有します。 SetBitsは、このパッケージ外部で欠けている低レベルのInt機能の実装をサポートすることを目的としています。 それ以外の場合は避けるべきです。
func (*Int) SetString ¶
SetStringは、zを指定された基数で解釈されたsの値に設定し、 zと成功を示すブール値を返します。成功するためには、文字列全体（プレフィックスだけでなく） が有効である必要があります。SetStringが失敗した場合、zの値は未定義ですが、 返される値はnilです。
基数引数は0または2からMaxBaseの間の値でなければなりません。 基数が0の場合、数値のプレフィックスが実際の基数を決定します：プレフィックスが "0b"または"0B"は基数2を選択し、"0"、"0o"または"0O"は基数8を選択し、 "0x"または"0X"は基数16を選択します。それ以外の場合、選択された基数は10であり、 プレフィックスは受け付けられません。
基数が36以下の場合、小文字と大文字は同じとみなされます： 文字 'a' から 'z' と 'A' から 'Z' は、数字の値 10 から 35 を表します。 基数が36より大きい場合、大文字の 'A' から 'Z' は、数字の値 36 から 61 を表します。
基数が0の場合、アンダースコア文字 "_" は基数のプレフィックスと隣接する数字の間、 または連続する数字の間に現れることがあります。このようなアンダースコアは数値の値に影響しません。 アンダースコアの配置が不適切な場合、他にエラーがない場合にエラーとして報告されます。 基数が0でない場合、アンダースコアは認識されず、有効な数字でない他の任意の文字と同様に動作します。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
i := new(big.Int)
i.SetString("644", 8) // 8進数
fmt.Println(i)
}
Output: 420
func (*Int) Text ¶ added in v1.6.0
Textは、指定された基数でのxの文字列表現を返します。 基数は2から62までの間でなければなりません。結果は、 数字の値10から35に対して小文字の'a'から'z'を、 数字の値36から61に対して大文字の'A'から'Z'を使用します。 文字列にはプレフィックス（例えば"0x"）は追加されません。xがnilポインタの場合、 "<nil>"を返します。
func (*Int) TrailingZeroBits ¶ added in v1.13.0
TrailingZeroBitsは、|x|の連続する最下位ゼロビットの数を返します。
func (*Int) UnmarshalJSON ¶ added in v1.1.0
UnmarshalJSONは、json.Unmarshalerインターフェースを実装します。
func (*Int) UnmarshalText ¶ added in v1.3.0
UnmarshalTextは、encoding.TextUnmarshalerインターフェースを実装します。
type Rat ¶
type Rat struct {
// contains filtered or unexported fields
}
Ratは、任意の精度の商a/bを表します。 Ratのゼロ値は値0を表します。
操作は常にポインタ引数（*Rat）を取る 代わりにRat値、そして各ユニークなRat値は 自身のユニークな*Ratポインタが必要です。Rat値を「コピー」するには、 既存の（または新しく割り当てられた）Ratを Rat.Setメソッドを使用して新しい値に設定する必要があります。Ratsの浅いコピーは サポートされておらず、エラーを引き起こす可能性があります。
func (*Rat) Denom ¶
Denomはxの分母を返します。これは常に> 0です。 結果はxの分母への参照であり、 xが初期化されていない（ゼロ値の）Ratの場合、 結果は値1の新しいIntになります。（xを初期化するには、 xを設定する任意の操作が適用できます、x.Set(x)を含む。） 結果がxの分母への参照である場合、 新しい値がxに割り当てられると変更される可能性があります。逆も同様です。
func (*Rat) Float32 ¶ added in v1.4.0
Float32は、xに最も近いfloat32値と、 fがxを正確に表現しているかどうかを示すbool値を返します。 もしxの絶対値がfloat32で表現できる範囲を超えている場合、 fは無限大となり、exactはfalseとなります。 fの符号は、fが0であっても、常にxの符号と一致します。
func (*Rat) Float64 ¶ added in v1.1.0
Float64は、xに最も近いfloat64値と、 fがxを正確に表現しているかどうかを示すbool値を返します。 もしxの絶対値がfloat64で表現できる範囲を超えている場合、 fは無限大となり、exactはfalseとなります。 fの符号は、fが0であっても、常にxの符号と一致します。
func (*Rat) FloatString ¶
FloatStringは、基数点の後にprec桁の精度で10進形式でxの文字列表現を返します。 最後の桁は最も近いものに丸められ、半分はゼロから丸められます。
func (*Rat) MarshalText ¶ added in v1.3.0
MarshalTextは、encoding.TextMarshalerインターフェースを実装します。
func (*Rat) Num ¶
Numはxの分子を返します。これは0以下になる可能性があります。 結果はxの分子への参照であり、xに新しい値が割り当てられると変更される可能性があります。逆も同様です。 分子の符号はxの符号に対応します。
func (*Rat) Scan ¶
Scanは、fmt.Scannerのサポートルーチンです。これはフォーマット 'e', 'E', 'f', 'F', 'g', 'G', 'v'を受け入れます。すべてのフォーマットは同等です。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/log"
"github.com/shogo82148/std/math/big"
)
func main() {
// Scan関数は直接使用されることはほとんどありません。
// fmtパッケージは、fmt.Scannerの実装としてこれを認識します。
r := new(big.Rat)
_, err := fmt.Sscan("1.5000", r)
if err != nil {
log.Println("error scanning value:", err)
} else {
fmt.Println(r)
}
}
Output: 3/2
func (*Rat) SetFloat64 ¶ added in v1.1.0
SetFloat64は、zを正確にfに設定し、zを返します。 もしfが有限でない場合、SetFloatはnilを返します。
func (*Rat) SetString ¶
SetStringは、zをsの値に設定し、zと成功を示すブール値を返します。 sは（符号付きの可能性のある）分数 "a/b"、または指数をオプションで追加した浮動小数点数として与えることができます。 分数が提供された場合、被除数と除数はともに10進整数であるか、またはそれぞれが独立して“0b”、“0”、“0o”、 “0x”（またはそれらの大文字のバリエーション）のプレフィックスを使用して2進数、8進数、または16進数の整数を示すことができます。 除数は符号を持つことはできません。 浮動小数点数が提供された場合、それは10進数の形式であるか、または上記と同じプレフィックスのいずれかを使用して 10進数以外の仮数を示すことができます。先頭の“0”は10進数の先頭0と見なされます。この場合、8進数表現を示すものではありません。 オプションの10進数の“e”または2進数の“p”（またはそれらの大文字のバリエーション）の指数も提供できます。 ただし、16進数の浮動小数点数は（オプションの）“p”指数のみを受け入れます（“e”または“E”は仮数の桁と区別できないため）。 指数の絶対値が大きすぎる場合、操作は失敗する可能性があります。 文字列全体、つまりプレフィックスだけでなく、有効でなければならない。操作が失敗した場合、zの値は未定義ですが、返される値はnilです。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
r := new(big.Rat)
r.SetString("355/113")
fmt.Println(r.FloatString(3))
}
Output: 3.142
func (*Rat) UnmarshalText ¶ added in v1.3.0
UnmarshalTextは、encoding.TextUnmarshalerインターフェースを実装します。
type RoundingMode ¶ added in v1.5.0
type RoundingMode byte
RoundingModeは、Float値が望ましい精度に丸められる方法を決定します。 丸めはFloat値を変更する可能性があり、丸め誤差はFloatのAccuracyによって説明されます。
Example ¶
package main
import (
"github.com/shogo82148/std/fmt"
"github.com/shogo82148/std/math/big"
)
func main() {
operands := []float64{2.6, 2.5, 2.1, -2.1, -2.5, -2.6}
fmt.Print(" x")
for mode := big.ToNearestEven; mode <= big.ToPositiveInf; mode++ {
fmt.Printf(" %s", mode)
}
fmt.Println()
for _, f64 := range operands {
fmt.Printf("%4g", f64)
for mode := big.ToNearestEven; mode <= big.ToPositiveInf; mode++ {
// 上記のサンプルオペランドは、仮数を表現するために2ビットを必要とします
// それらを整数値に丸めるために、二進数の精度を2に設定します
f := new(big.Float).SetPrec(2).SetMode(mode).SetFloat64(f64)
fmt.Printf(" %*g", len(mode.String()), f)
}
fmt.Println()
}
}
Output: x ToNearestEven ToNearestAway ToZero AwayFromZero ToNegativeInf ToPositiveInf 2.6 3 3 2 3 2 3 2.5 2 3 2 3 2 3 2.1 2 2 2 3 2 3 -2.1 -2 -2 -2 -3 -3 -2 -2.5 -2 -3 -2 -3 -3 -2 -2.6 -3 -3 -2 -3 -3 -2
const ( ToNearestEven RoundingMode = iota ToNearestAway ToZero AwayFromZero ToNegativeInf ToPositiveInf )
これらの定数は、サポートされている丸めモードを定義します。
func (RoundingMode) String ¶ added in v1.5.0
func (i RoundingMode) String() string
Source Files