...

パッケージ big

import "math/big"
概要
目次

概要 ▾

big パッケージは任意精度の計算 (big numbers) を実装します。 以下の数値型がサポートされています。

整数の符号付き整数ラット有理数浮動小数点数

Int, Rat ,または Float のゼロ値は 0 に対応します。 したがって,新しい値は通常の方法で宣言でき,それ以上の初期化なしで 0 を表します。

var x Int // &x は,値 0 の *Int です。 var r = &Rat{} // r は,値 0 の *Rat です。 ==(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 の 1 つであるなら,それは安全に上書きされるかもしれません (そしてそのメモリは再利用されます) 。

算術式は通常,個々のメソッド呼び出しのシーケンスとして記述され,各呼び出しは操作に対応します。 レシーバは結果を表し,メソッドの引数は操作のオペランドです。 例えば, 3 つの *Int 値 a, b ,および c を指定すると,呼び出しは次のようになります。

c.Add(a, b)

a + b の合計を計算し,その結果を c に格納し,それまで c に保持されていた値を上書きします。 他に指定されない限り,操作はパラメータのエイリアシングを許します,従って書くことは全く問題ありません

sum.Add(sum, x)

値 x を合計する。

(レシーバを介して結果値を常に渡すことで,メモリ使用量をより適切に制御できます。 結果ごとに新しいメモリを割り当てる代わりに,操作で結果値に割り当てられた領域を再利用し,新しい値で上書きできます。 プロセスになります。)

表記規則 : 着信メソッドのパラメータ (受信側を含む) は,その使用を明確にするために 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 のドキュメントを参照) 。

最後に, *Int, *Rat, および *Float は,スキャン用の fmt パッケージのスキャナーインターフェースと, (*Rat を除く) フォーマット済み表示用のフォーマッターインターフェースを満たします。

例 (EConvergents)

この例では, big.Rat を使用して,定数 e (自然対数の底) に対する有理数収束式のシーケンスの最初の 15 項を計算する方法を示します。

コード:

package big_test

import (
    "fmt"
    "math/big"
)

// ee=[1; に対して古典的な連続分数を使います。
// 0, 1, 1, 2, 1, 1, ... 2n, 1, 1, ...] つまり, n 番目の項に対して, nmod3!=1(n-1)/3*2 の場合, 1 を使用します。
// n mod 3 == 1 の場合
func recur(n, lim int64) *big.Rat {
    term := new(big.Rat)
    if n%3 != 1 {
        term.SetInt64(1)
    } else {
        term.SetInt64((n - 1) / 3 * 2)
    }

    if n > lim {
        return term
    }

    // recur の結果の分数の逆数として frac を直接初期化します。
    frac := new(big.Rat).Inv(recur(n+1, lim))

    return term.Add(term, frac)
}

// この例では, big.Rat を使用して,定数 e (自然対数の底) に対する有理数収束式のシーケンスの最初の 15 項を計算する方法を示します。
func Example_eConvergents() {
    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
}

例 (Fibonacci)

この例では, big.Int を使用して, 10 進数 100 桁の最小のフィボナッチ数を計算し,それが素数であるかどうかをテストする方法を示します。

コード:

// シーケンス内の最初の 2 つの数字で 2 つの大きな整数を初期化します。
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.Add(a, b)
    // b がシーケンスの次の番号になるように, a と b を入れ替えます。
    a, b = b, a
}
fmt.Println(a) // 100 桁のフィボナッチ数

// 素数をテストします。
// (ProbablyPrimes の引数は,実行されるミラーラビンラウンドの数を設定します。
// 20 が良い値です。)
fmt.Println(a.ProbablyPrime(20))

出力:

1344719667586153181419716641724567886890850696275767987106294472017884974410332069524504824747437757
false

例 (Sqrt2)

この例では, big.Float を使用して 200 ビットの精度で 2 の平方根を計算する方法と,結果を 10 進数として出力する方法を示します。

コード:

// 仮数部で 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 を使用します。
// unset (== 0) の精度を持つ big.Float 値は, big.Float 操作の結果 (受信側) として使用された場合,自動的に引数の最大精度を想定するため,精度を設定する必要はありません。
t := new(big.Float)

// 繰り返します。
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))

出力:

sqrt(2) = 1.41421356237309504880168872420969807856967187537695
error = 0.000000e+00

目次 ▾

定数
func Jacobi(x, y *Int) int
type Accuracy
    func (i Accuracy) String() string
type ErrNaN
    func (err ErrNaN) Error() string
type Float
    func NewFloat(x float64) *Float
    func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)
    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 NewInt(x int64) *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) 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 NewRat(a, b int64) *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
    func (i RoundingMode) String() string
type Word

パッケージファイル

accuracy_string.go arith.go arith_amd64.go arith_decl.go decimal.go doc.go float.go floatconv.go floatmarsh.go ftoa.go int.go intconv.go intmarsh.go nat.go natconv.go prime.go rat.go ratconv.go ratmarsh.go roundingmode_string.go sqrt.go

定数

指数と精度の限界

const (
    MaxExp  = math.MaxInt32  // サポートされている最大の指数
    MinExp  = math.MinInt32  // サポートされている最小の指数
    MaxPrec = math.MaxUint32 // 最大 (理論的に) サポートされている精度。 おそらくメモリ制限
)

MaxBase は,文字列変換に使用できる最大の基数です。

const MaxBase = 10 + ('z' - 'a' + 1) + ('Z' - 'A' + 1)

func Jacobi 1.5

func Jacobi(x, y *Int) int

Jacobi は, +1, -1 ,または 0 のいずれかの Jacobi シンボル (x/y) を返します。 y 引数は奇数の整数でなければなりません。

type Accuracy 1.5

Accuracy (正確度) は,正確な値を基準とした,浮動小数点値を生成した最新の操作によって発生する丸め誤差を表します。

type Accuracy int8

フロートの正確さを記述する定数。

const (
    Below Accuracy = -1
    Exact Accuracy = 0
    Above Accuracy = +1
)

func (Accuracy) String 1.5

func (i Accuracy) String() string

type ErrNaN 1.5

ErrNaN パニックは, IEEE-754 規則の下で NaN につながる Float 操作によって引き起こされます。 ErrNaN はエラーインターフェースを実装します。

type ErrNaN struct {
    // エクスポートされていないフィールドがあります
}

func (ErrNaN) Error 1.5

func (err ErrNaN) Error() string

type Float 1.5

ゼロ以外の有限浮動小数点数は,多倍精度浮動小数点数を表します。

sign × mantissa × 2**exponent

0.5 <= 仮数 < 1.0 , MinExp <= 指数 <= MaxExp 。 float は,ゼロ (+0, -0) または無限 (+Inf, -Inf) でもかまいません。 すべての浮動小数点数は順序付けられており, 2 つの浮動小数点数 x と y の順序は x.Cmp(y) によって定義されます。

各浮動小数点値には,精度,丸めモード,および精度もあります。 精度は,値を表すために使用可能な仮数ビットの最大数です。 丸めモードでは,仮数ビットに収まるように結果を丸める方法を指定します。 精度は,正確な結果に対する丸め誤差を表します。

特に指定しない限り,結果に *Float 変数を指定するすべての操作 (セッターを含む)(通常は MantExp を除く受信側を介して) は,結果変数の精度と丸めモードに従って数値結果を丸めます。

渡された結果の精度が 0 の場合 (下記参照) ,丸めが行われる前に最大の精度値を持つ引数の精度に設定され,丸めモードは変更されません。 したがって,結果引数として渡される初期化されていない Floats は,精度がオペランドによって決定される妥当な値に設定され,そのモードは RoundingMode (ToNearestEven) のゼロ値になります。

希望する精度を 24 または 53 に設定し,一致する丸めモード (通常は ToNearestEven) を使用することにより,浮動小数点演算は,通常 (非正規ではない) に対応するオペランドに対して,対応する float32 または float64 IEEE-754 演算と同じ結果を生成します。 数字です。 Float 指数ははるかに広い範囲を持つため,指数アンダーフローおよびオーバーフローは IEEE-754 とは異なる値に対して 0 または Infinity になります。

Float のゼロ (初期化されていない) 値はすぐに使用でき,精度 0 と丸めモード ToNearestEven で +0.0 を正確に表します。

操作は常に Float 値ではなくポインター引数 (*Float) を取り,それぞれの固有の Float 値にはそれぞれ固有の *Float ポインターが必要です。 Float 値を " コピー " するには, Float.Set メソッドを使用して既存の (または新しく割り当てられた) Float を新しい値に設定する必要があります。 フロートの浅いコピーはサポートされておらず,エラーにつながる可能性があります。

type Float struct {
    // エクスポートされていないフィールドがあります
}

例 (Shift)

コード:

// Implement Float "shift" by modifying the (binary) exponents directly.
for s := -5; s <= 5; s++ {
    x := big.NewFloat(0.5)
    x.SetMantExp(x, x.MantExp(nil)+s) // shift x by s
    fmt.Println(x)
}

出力:

0.015625
0.03125
0.0625
0.125
0.25
0.5
1
2
4
8
16

func NewFloat 1.5

func NewFloat(x float64) *Float

NewFloat は,精度 53 ,丸めモード ToNearestEven で, x に設定された新しい Float を割り当てて返します。 x が NaN の場合, NewFloat は ErrNaN でパニックを起こします。

func ParseFloat 1.5

func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)

ParseFloat は f.Parse(s, base) に似ており, f は指定された精度と丸めモードに設定されています。

func (*Float) Abs 1.5

func (z *Float) Abs(x *Float) *Float

Abs は z を (丸められているかもしれない) 値 |x| に設定します。 (x の絶対値) そして z を返します。

func (*Float) Acc 1.5

func (x *Float) Acc() Accuracy

Acc は,最近の演算によって生成された x の精度を返します。

func (*Float) Add 1.5

func (z *Float) Add(x, y *Float) *Float

集合 z を丸めた合計 x+y に加算し, z を返します。 z の精度が 0 の場合,演算の前に x の精度または y の精度のうち大きい方に変更されます。 丸めは, z の精度と丸めモードに従って実行されます。 z の精度は,正確な (四捨五入されていない) 結果に対する結果の誤差を報告します。 x と y が逆符号の無限大の場合は, ErrNaN でパニックを追加してください。 その場合, z の値は未定義です。

コード:

// Operate on numbers of different precision.
var x, y, z big.Float
x.SetInt64(1000)          // x is automatically set to 64bit precision
y.SetFloat64(2.718281828) // y is automatically set to 53bit precision
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())

出力:

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 1.5

func (x *Float) Append(buf []byte, fmt byte, prec int) []byte

Append は, x.Text で生成された文字列形式の浮動小数点数 x を buf に追加し,拡張バッファを返します。

func (*Float) Cmp 1.5

func (x *Float) Cmp(y *Float) int

Cmp は x と y を比較して返します。

-1, x <  y の場合
 0, x == y (-0 == 0, -Inf == -Inf, and +Inf == +Inf を含む) 場合
+1, x >  y の場合

コード:

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()
}

出力:

   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) Copy 1.5

func (z *Float) Copy(x *Float) *Float

Copy は, x と同じ精度,丸めモード,および精度で z を x に設定し, z を返します。 z と x が同じでも x は変更されません。

func (*Float) Float32 1.5

func (x *Float) Float32() (float32, Accuracy)

Float32 は, x に最も近い float32 値を返します。 x が float32 で表すには小さすぎる場合 (|x| < math.SmallestNonzeroFloat32) , x の符号に応じて,結果はそれぞれ (0, Below) または (-0, Above) になります。 x が float32 で表現するには大きすぎる場合 (|x| > math.MaxFloat32),結果は x の符号に応じて (+Inf, Above) または (-Inf, Below) になります。

func (*Float) Float64 1.5

func (x *Float) Float64() (float64, Accuracy)

Float64 は, x に最も近い float64 値を返します。 x が float64 で表すには小さすぎる場合 (|x| < math.SmallestNonzeroFloat64) , x の符号に応じて,結果はそれぞれ (0, Below) または (-0, Above) になります。 x が float64 (|x| > math.MaxFloat64) で表現するには大きすぎる場合,結果は x の符号に応じて (+Inf, Above) または (-Inf, Below) になります。

func (*Float) Format 1.5

func (x *Float) Format(s fmt.State, format rune)

Format は fmt.Formatter を実装します。 浮動小数点数のすべての通常のフォーマット ('b', 'e', 'E', 'f', 'F', 'g', 'G', 'x') および 'p' と 'v' を受け入れます。 'p' の解釈については (*Float).Text を参照してください。 'v' フォーマットは 'g' のように扱われます。 フォーマットは,桁数の最小精度,出力フィールド幅,符号制御用のフォーマットフラグ '+' および ' ' ,スペースまたはゼロパディング用の '0' ,および左揃えまたは右揃え用の '-' の指定もサポートします。 詳細は fmt パッケージを見てください。

func (*Float) GobDecode 1.7

func (z *Float) GobDecode(buf []byte) error

GobDecode は gob.GobDecoder インターフェースを実装します。 z の精度が 0 でない場合,結果は z の精度と丸めモードに従って丸められます。 その場合, z はデコードされた値に正確に設定されます。

func (*Float) GobEncode 1.7

func (x *Float) GobEncode() ([]byte, error)

GobEncode は gob.GobEncoder インターフェースを実装します。 Float 値とそのすべての属性 (精度,丸めモード,精度) は整列化されます。

func (*Float) Int 1.5

func (x *Float) Int(z *Int) (*Int, Accuracy)

Int は x をゼロに切り捨てた結果を返します。 x が無限大の場合は nil 。 x.IsInt() の場合,結果は正確です。 それ以外の場合は, x > 0 の場合は Below , x < 0 の場合は Above です。 nil *Int 以外の引数 z が指定された場合, Int は新しい Int を割り当てる代わりに z に結果を格納します。

func (*Float) Int64 1.5

func (x *Float) Int64() (int64, Accuracy)

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) IsInf 1.5

func (x *Float) IsInf() bool

IsInf は, x が +Inf か -Inf かを報告します。

func (*Float) IsInt 1.5

func (x *Float) IsInt() bool

IsInt は, x が整数かどうかを報告します。 ±Inf 値は整数ではありません。

func (*Float) MantExp 1.5

func (x *Float) MantExp(mant *Float) (exp int)

MantExp は, x をその仮数と指数部に分解し,指数部を返します。 nil 以外の仮引数が与えられた場合,その値は 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 1.6

func (x *Float) MarshalText() (text []byte, err error)

MarshalText は encoding.TextMarshaler インターフェースを実装します。 Float 値のみが (フル精度で) マーシャリングされ,精度や精度などの他の属性は無視されます。

func (*Float) MinPrec 1.5

func (x *Float) MinPrec() uint

MinPrec は, x を正確に表すのに必要な最小精度 (つまり, x.SetPrec(prec) が x の丸めを開始する前の最小の prec) を返します。 |x| == 0 および |x| == Inf の場合,結果は 0 になります。

func (*Float) Mode 1.5

func (x *Float) Mode() RoundingMode

Mode は x の丸めモードを返します。

func (*Float) Mul 1.5

func (z *Float) Mul(x, y *Float) *Float

Mul は z を丸められた積 x*y に設定し, z を返します。 精度,四捨五入,および精度の報告は Add と同じです。 一方のオペランドがゼロで,もう一方のオペランドが無限大の場合, Mul は ErrNaN でパニックを起こします。 その場合, z の値は未定義です。

func (*Float) Neg 1.5

func (z *Float) Neg(x *Float) *Float

Neg は,符号を無効にして z を (丸められているかもしれない) x の値に設定し, z を返します。

func (*Float) Parse 1.5

func (z *Float) Parse(s string, base int) (f *Float, b int, err error)

Parse は,指定された変換基数の仮数を持つ浮動小数点数のテキスト表現 (指数は常に 10 進数) ,または無限値を表すストリングを含む必要があります。

ベース 0 の場合,アンダースコア文字 "_" がベースプレフィックスと隣接する数字の間,および連続する数字の間に現れることがあります。 このようなアンダースコアは,数値の値,または返される桁数を変更しません。 他にエラーがない場合,アンダースコアの不適切な配置はエラーとして報告されます。 base != 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" .

base 引数は, 0, 2, 8, 10, または 16 でなければなりません。 無効な base 引数を指定すると,ランタイムパニックが発生します。

基数 0 の場合,数値の接頭辞が実際の基数を決定します。 接頭辞 "0b" または "0B" は基数 2 を, "0o" または "0O" 接頭辞は基数 8 を, 接頭辞 "0x" または "0X" は基数 16 を選択します。 それ以外の場合,実際の基数は 10 で,プレフィックスは受け入れられません。 8 進数の接頭辞 "0" はサポートされていません (先頭の "0" は単に "0" と見なされます) 。

"p" あるいは "P" 指数は, 2 進数 (10 進数ではなく) 指数を示します。 例えば, "0x1.fffffffffffffp1023" (基数 0 を使用) は float64 の最大値を表します。 16 進仮数の場合,指数は,存在する場合は 2 進数でなければなりません ("e" または "E" 指数標識は仮数と区別できません) 。

返される *Float f は nil で, z の値は有効ですが,エラーが報告された場合には定義されません。

func (*Float) Prec 1.5

func (x *Float) Prec() uint

Prec は, x の仮数精度をビット単位で返します。 |x| == 0 および |x| == Inf の場合,結果は 0 になります。

func (*Float) Quo 1.5

func (z *Float) Quo(x, y *Float) *Float

Quo は,丸められた商 x/y に z を設定し, z を返します。 精度,四捨五入,および精度の報告は Add と同じです。 両方のオペランドがゼロまたは無限大の場合, ErrNaN でパニックが発生します。 その場合, z の値は未定義です。

func (*Float) Rat 1.5

func (x *Float) Rat(z *Rat) (*Rat, Accuracy)

Rat は x に対応する有理数を返します。 x が無限大の場合は nil 。 x が Inf でない場合,結果は正確です。 nil 以外の *Rat 引数 z が与えられた場合, Rat は新しい Rat を割り当てる代わりに結果を z に格納します。

func (*Float) Scan 1.8

func (z *Float) Scan(s fmt.ScanState, ch rune) error

Scan は fmt.Scanner のためのルーチンです。 それは z をスキャンされた数の値に設定します。 fmt.Scan で動詞がサポートされている浮動小数点値のフォーマットを受け入れます。 'b' (バイナリー), 'e', 'E', 'f', 'F', 'g' ,および 'G' 。 Scan は ±Inf を処理しません。

コード:

// 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)
}

出力:

1.19282e+99

func (*Float) Set 1.5

func (z *Float) Set(x *Float) *Float

Set は z を (丸められているかもしれない) x の値に設定し, z を返します。 z の精度が 0 の場合, z を設定する前に x の精度に変更されます (丸めは効果がありません) 。 丸めは, z の精度と丸めモードに従って実行されます。 z の精度は,正確な (四捨五入されていない) 結果に対する結果の誤差を報告します。

func (*Float) SetFloat64 1.5

func (z *Float) SetFloat64(x float64) *Float

SetFloat64 は, z を (丸められているかもしれない) x の値に設定し, z を返します。 z の精度が 0 の場合,精度は 53 に変更されます (丸めによる影響はありません) 。 x が NaN の場合, SetFloat64 は ErrNaN でパニックします。

func (*Float) SetInf 1.5

func (z *Float) SetInf(signbit bool) *Float

SetInf は, signbit が設定されている場合は z を無限浮動小数点数 -Inf に設定し, signbit が設定されていない場合は +Inf を設定して z を返します。 z の精度は変わらず,結果は常に Exact です。

func (*Float) SetInt 1.5

func (z *Float) SetInt(x *Int) *Float

SetInt は, z を (丸められているかもしれない) x の値に設定し, z を返します。 z の精度が 0 の場合は, x.BitLen() または 64 の大きい方に変更されます (丸めは効果がありません) 。

func (*Float) SetInt64 1.5

func (z *Float) SetInt64(x int64) *Float

SetInt64 は z を (おそらく四捨五入した)x の値に設定し, z を返します。 z の精度が 0 の場合,精度は 64 に変更されます (丸めによる影響はありません) 。

func (*Float) SetMantExp 1.5

func (z *Float) SetMantExp(mant *Float, exp int) *Float

SetMantExp は z を mant × 2**exp に設定し, z を返します。 結果 z は, mant と同じ精度と丸めモードを持ちます。 SetMantExp は MantExp の逆ですが, 0.5 <= |mant| < 1.0 を必要としません。 具体的には :

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 1.5

func (z *Float) SetMode(mode RoundingMode) *Float

SetMode は z の丸めモードを mode に設定し,正確な z を返します。 それ以外の場合, z は変更されません。 z.SetMode(z.Mode()) は, z の精度を Exact に設定する簡単な方法です。

func (*Float) SetPrec 1.5

func (z *Float) SetPrec(prec uint) *Float

SetPrec は z の精度を prec に設定し, (おそらく) 丸められた z の値を返します。 仮数を精度の損失なしに prec ビットで表すことができない場合,丸めは z の丸めモードに従って行われます。 SetPrec(0) は,すべての有限値を ±0 にマッピングします。 無限値は変更されません。 prec > MaxPrec の場合, MaxPrec に設定されます。

func (*Float) SetRat 1.5

func (z *Float) SetRat(x *Rat) *Float

SetRat は, z を (おそらく四捨五入した) x の値に設定し, z を返します。 z の精度が 0 の場合,精度は a.BitLen() , b.BitLen() ,または 64 のうち最大のものに変更されます。ここで,x = a/b です。

func (*Float) SetString 1.5

func (z *Float) SetString(s string) (*Float, bool)

SetString は, z に s の値を設定し, z と成功を示すブール値を返します。 s は, Parse で受け入れられるものと同じ形式の浮動小数点数で,基本引数は 0 です。 文字列全体 (単なる接頭辞ではない) は,成功のために有効でなければなりません。 操作が失敗した場合, z の値は未定義ですが戻り値は nil です。

func (*Float) SetUint64 1.5

func (z *Float) SetUint64(x uint64) *Float

SetUint64 は, z を (丸められているかもしれない) x の値に設定し, z を返します。 z の精度が 0 の場合,精度は 64 に変更されます (丸めによる影響はありません) 。

func (*Float) Sign 1.5

func (x *Float) Sign() int

Sign は以下を返します。

-1 , x <   0 の場合
 0 , x は  ±0 の場合
+1 , x >   0 の場合

func (*Float) Signbit 1.5

func (x *Float) Signbit() bool

Signbit は, x が負であるか負であるかを報告します。

func (*Float) Sqrt 1.10

func (z *Float) Sqrt(x *Float) *Float

Sqrt は, z を x の丸められた平方根に設定して返します。

z の精度が 0 の場合,演算の前に x の精度に変更されます。 丸めは, z の精度と丸めモードに従って実行されます。

z < 0 の場合,関数はパニックします。 その場合, z の値は未定義です。

func (*Float) String 1.5

func (x *Float) String() string

String は x.Text('g', 10) のように x をフォーマットします。 (String は明示的に呼び出す必要があります。 Float.Format は %s 動詞をサポートしません。)

func (*Float) Sub 1.5

func (z *Float) Sub(x, y *Float) *Float

Sub は z を丸められた差 x-y に設定し, z を返します。 精度,四捨五入,および精度の報告は Add と同じです。 x と y が同じ符号の無限大の場合, ErrNaN でパニックが発生します。 その場合, z の値は未定義です。

func (*Float) Text 1.5

func (x *Float) Text(format byte, prec int) string

Text は与えられたフォーマットと精度 prec に従って浮動小数点数 x を文字列に変換します。 形式は次のいずれかです。

'e' -d.dddde±dd , 10 進指数,少なくとも 2 つ (0 かもしれない) の指数桁
'E'	-d.ddddE±dd, decimal exponent, at least two (possibly 0) exponent digits
'f'	-ddddd.dddd, no exponent
'g'	like 'e' for large exponents, like 'f' otherwise
'G'	like 'E' for large exponents, like 'f' otherwise
'x'	-0xd.dddddp±dd, hexadecimal mantissa, decimal power of two exponent
'p'	-0x.dddp±dd, hexadecimal mantissa, decimal power of two exponent (non-standard)
'b'	-ddddddp±dd, decimal mantissa, decimal power of two exponent (non-standard)

2 のべき乗の指数形式の場合,仮数は正規化された形式で出力されます。

'x'	hexadecimal mantissa in [1, 2), or 0
'p'	hexadecimal mantissa in [½, 1), or 0
'b'	decimal integer mantissa using x.Prec() bits, or 0

'x' 形式は,他のほとんどの言語およびライブラリで使用される形式であることに注意してください。

format が別の文字の場合, Text は "%" に続けて認識されないフォーマット文字を返します。

精度 prec は, 'e', 'E', 'f', 'g', 'G', および 'x' 形式で表示される桁数 (指数を除く) を制御します。 'e', 'E', 'f', および 'x' の場合は,小数点以下の桁数です。 'g' と 'G' の場合,これは合計桁数です。 負の精度は, x.Prec() 仮数ビットを使用して値 x を一意的に識別するのに必要な最小桁数を選択します。 'b' または 'p' 形式の場合, prec 値は無視されます。

func (*Float) Uint64 1.5

func (x *Float) Uint64() (uint64, Accuracy)

Uint64 は, x をゼロに切り捨てた結果の符号なし整数を返します。 0 <= x <= math.MaxUint64 の場合, x が整数の場合は結果は Exact となり,それ以外の場合は結果は Below です。 結果は, x < 0 の場合は (0, Above) , x > math.MaxUint64 の場合は (math.MaxUint64, Below) です。

func (*Float) UnmarshalText 1.6

func (z *Float) UnmarshalText(text []byte) error

UnmarshalText は encoding.TextUnmarshaler インターフェースを実装します。 結果は, z の精度および丸めモードに従って丸められます。 z の精度が 0 の場合,丸めが有効になる前に 64 に変更されます。

type Int

Int は符号付き多倍長整数を表します。 Int のゼロ値は値 0 を表します。

操作は常に Int 値ではなくポインター引数 (*Int) を取ります。 それぞれの固有の Int 値には,固有の *Int ポインターが必要です。 Int 値を " コピー " するには, Int.Set メソッドを使用して,既存の (または新しく割り当てられた) Int を新しい値に設定する必要があります。 Ints の浅いコピーはサポートされておらず,エラーにつながる可能性があります。

type Int struct {
    // エクスポートされていないフィールドがあります
}

func NewInt

func NewInt(x int64) *Int

NewInt は,新しい Int セットを x に割り当てて返します。

func (*Int) Abs

func (z *Int) Abs(x *Int) *Int

Abs は z を |x| に設定します。 (x の絶対値) そして z を返します。

func (*Int) Add

func (z *Int) Add(x, y *Int) *Int

Add は, z を x+y の和に設定し, z を返します。

func (*Int) And

func (z *Int) And(x, y *Int) *Int

And は z = x & y を設定して z を返します。

func (*Int) AndNot

func (z *Int) AndNot(x, y *Int) *Int

AndNot は z = x &^ y を設定し, z を返します。

func (*Int) Append 1.6

func (x *Int) Append(buf []byte, base int) []byte

Append は, x.Text(base) で生成された x の文字列表現を buf に追加して拡張バッファを返します。

func (*Int) Binomial

func (z *Int) Binomial(n, k int64) *Int

二項式は, z を (n, k) の二項係数に設定し, z を返します。

func (*Int) Bit

func (x *Int) Bit(i int) uint

Bit は x の i 番目のビットの値を返します。 つまり, (x>>i)&1 を返します。 ビットインデックス i は 0 以上でなければなりません。

func (*Int) BitLen

func (x *Int) BitLen() int

BitLen は, x の絶対値の長さをビット数で返します。 ビット長 0 は 0 です。

func (*Int) Bits

func (x *Int) Bits() []Word

Bits は,その絶対値をリトルエンディアンの Word スライスとして返すことによって, x への生の (未チェックだが速い) アクセスを提供します。 結果と x は同じ基底配列を共有します。 Bits は,このパッケージ外で欠けている低レベルの Int 機能の実装をサポートすることを目的としています。 そうでなければこれを使うことは避けるべきです。

func (*Int) Bytes

func (x *Int) Bytes() []byte

Bytes は, x の絶対値をビッグエンディアンのバイトスライスとして返します。

func (*Int) Cmp

func (x *Int) Cmp(y *Int) (r int)

Cmp は x と y を比較して返します。

-1, x <  y の場合
 0, x == y の場合
+1, x >  y の場合

func (*Int) CmpAbs 1.10

func (x *Int) CmpAbs(y *Int) int

CmpAbs は x と y の絶対値を比較して,

-1, |x| <  |y| の場合
 0, |x| == |y| の場合
+1, |x| >  |y| の場合

func (*Int) Div

func (z *Int) Div(x, y *Int) *Int

Div は, y != 0 の場合に z を商 x/y に設定し, z を返します。 y == 0 の場合,ゼロ除算実行時パニックが発生します。 Div は (Go とは異なり) ユークリッド除算を実装します。 詳細は DivMod を見てください。

func (*Int) DivMod

func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)

DivMod は, z を商 x div y に, m を法 x mod y に設定し, y != 0 の場合 (z, m) のペアを返します。 y == 0 の場合,ゼロ除算の実行時パニックが発生します。

DivMod は (Go とは異なり) ユークリッド除法とモジュラスを実装します。

q = x div y  , ただし,以下を満たす
m = x - y*q  , 0 <= m < |y|

(RaymondT.Boute 著, "The Euclidean definition of the functions div and mod (関数 div および mod のユークリッド定義)" を参照。 プログラミング言語とシステムに関する ACM トランザクション (TOPLAS) , 14(2):127-144 , New York , NY , USA , 4/1992.ACM press)。 T 分割と係数については, QuoRem を参照してください (Go のように) 。

func (*Int) Exp

func (z *Int) Exp(x, y, m *Int) *Int

Exp は z = x**y mod |m| を設定し (つまり, m の符号は無視されます) , z を返します。 m == nil または m == 0 の場合, y <= 0 でない限り z = x**y の場合, z = 1 。 m > 0, y < 0 ,および x と n が互いに素でない場合, z は変化せず nil 返されます。

特定のサイズの入力のモジュラ指数化は,暗号的に一定時間の演算ではありません。

func (*Int) Format

func (x *Int) Format(s fmt.State, ch rune)

Format は fmt.Formatter を実装します。 フォーマットは 'b' (2 進数), 'o' (0 プレフィックス付きの 8 進数), 'O' (0o プレフィックス付きの 8 進数), 'd' (10 進数), 'x' (小文字の 16 進数), および 'X' (大文字の 16 進数) です。 符号制御のための '+' と ' ' , 8 進数の先頭のゼロのための '#',および "0x" または "0X" を先頭につける "%#x" または "%#X" を含む整数型のパッケージ fmt のフォーマットフラグ全般もサポートされます。

func (*Int) GCD

func (z *Int) GCD(x, y, a, b *Int) *Int

GCD は z を a と b の最大公約数に設定します。 どちらも > 0 でなければならず, z を返します。 x または y が nil でない場合, GCD は z = a*x + b*y となるようにそれらの値を設定します。 a または b のいずれかが <= 0 の場合, GCD は z = x = y = 0 に設定します。

func (*Int) GobDecode

func (z *Int) GobDecode(buf []byte) error

GobDecode は gob.GobDecoder インターフェースを実装します。

func (*Int) GobEncode

func (x *Int) GobEncode() ([]byte, error)

GobEncode は gob.GobEncoder インターフェースを実装します。

func (*Int) Int64

func (x *Int) Int64() int64

Int64 は x の int64 表現を返します。 x が int64 で表現できない場合,結果は未定義です。

func (*Int) IsInt64 1.9

func (x *Int) IsInt64() bool

IsInt64 は, x が int64 として表現できるかどうかを報告します。

func (*Int) IsUint64 1.9

func (x *Int) IsUint64() bool

IsUint64 は, x が uint64 として表現できるかどうかを報告します。

func (*Int) Lsh

func (z *Int) Lsh(x *Int, n uint) *Int

Lsh は z = x << n を設定して z を返します。

func (*Int) MarshalJSON 1.1

func (x *Int) MarshalJSON() ([]byte, error)

MarshalJSON は json.Marshaler インターフェースを実装します。

func (*Int) MarshalText 1.3

func (x *Int) MarshalText() (text []byte, err error)

MarshalText は encoding.TextMarshaler インターフェースを実装します。

func (*Int) Mod

func (z *Int) Mod(x, y *Int) *Int

Mod は, y != 0 の場合, z を係数 x%y に設定し, z を返します。 y == 0 の場合,ゼロ除算実行時パニックが発生します。 Mod は (Go とは異なり) ユークリッド係数を実装します。 詳細は DivMod を見てください。

func (*Int) ModInverse

func (z *Int) ModInverse(g, n *Int) *Int

ModInverse は z を環 ℤ/nℤ の g の乗法的逆数に設定し, z を返します。 g と n が互いに素でない場合, g は環 ℤ/nℤ に乗法的な逆行列を持ちません。 この場合, z は変更されず,戻り値は nil です。

func (*Int) ModSqrt 1.5

func (z *Int) ModSqrt(x, p *Int) *Int

そのような平方根が存在する場合, ModSqrt は z を x mod p の平方根に設定し, z を返します。 モジュラス p は,奇数の素数でなければなりません。 x が正方 mod p でない場合, ModSqrt は z を変更せずに nil を返します。 p が奇数でない場合,この関数はパニックします。

func (*Int) Mul

func (z *Int) Mul(x, y *Int) *Int

Mul は z を積 x*y に設定し, z を返します。

func (*Int) MulRange

func (z *Int) MulRange(a, b int64) *Int

MulRange は z を [a, b] の範囲内のすべての整数の積に包括的に設定し, z を返します。 a > b (空の範囲) の場合,結果は 1 です。

func (*Int) Neg

func (z *Int) Neg(x *Int) *Int

Neg は z を -x に設定し, z を返します。

func (*Int) Not

func (z *Int) Not(x *Int) *Int

Not は,z = ^x とし, z を返します。

func (*Int) Or

func (z *Int) Or(x, y *Int) *Int

Or は z = x | y に設定し, z を返します。

func (*Int) ProbablyPrime

func (x *Int) ProbablyPrime(n int) bool

ProbablyPrime は, x がおそらく素数であるかどうかを報告し, n 個の擬似ランダムに選択された基底を使った Miller-Rabin 検定と Baillie-PSW 検定を適用します。

x が素数の場合, ProbablyPrime は true を返します。 x が素数ではなくランダムに選ばれた場合, ProbablyPrime はおそらく false を返します。 無作為に選択された非素数に対して真を返す確率は最大で 1/4 です。

ProbablyPrime は, 2⁶⁴ 未満の入力に対して 100% 正確です。 誤りの確率のさらなる議論については, Menezes ら, Handbook of Applied Cryptography, 1997 年, 145 ~ 149 ページ,および FIPS 186-4 付録 F を参照のこと。

ProbablyPrime は,敵対者がテストをだますために作られた可能性があるという素数を判断するのには適していません。

Go 1.8 以降, ProbablyPrime(0) は許可されており, Baillie-PSW テストのみを適用します。 Go 1.8 以前は, ProbablyPrime は Miller-Rabin テストのみを適用し, ProbablyPrime(0) はパニック状態でした。

func (*Int) Quo

func (z *Int) Quo(x, y *Int) *Int

Quo は, y != 0 の場合に z を商 x/y に設定し, z を返します。 y == 0 の場合,ゼロ除算実行時パニックが発生します。 Quo は (Go のように) 切り捨てられた除算を実装します。 詳しくは QuoRem をご覧ください。

func (*Int) QuoRem

func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)

QuoRem は, z を商 x/y に, r を余り x%y に設定し, y != 0 の場合 (z, r) のペアを返します。 y == 0 の場合,ゼロ除算の実行時パニックが発生します。

QuoRem は T 分割と係数 (Go のように) を実装します。

q = x/y ,結果はゼロに切り捨てられます。
r = x - y*q

(DaanLeijen の "Division and Modulus for Computer Scientists (コンピュータ科学者のための除算と係数)" を参照してください。) ユークリッドの除算と係数の DivMod を参照してください (Go とは異なります) 。

func (*Int) Rand

func (z *Int) Rand(rnd *rand.Rand, n *Int) *Int

Rand は z を [0, n) の疑似乱数に設定し, z を返します。

これは math/rand パッケージを使用しているので,セキュリティを重視する作業には使用しないでください。 代わりに crypto/rand.Int を使用してください。

func (*Int) Rem

func (z *Int) Rem(x, y *Int) *Int

Rem は, y != 0 の場合, z を余り x%y に設定し, z を返します。 y == 0 の場合,ゼロ除算実行時パニックが発生します。 Rem は (Go のように) 切り捨てモジュラスを実装します。 詳しくは QuoRem をご覧ください。

func (*Int) Rsh

func (z *Int) Rsh(x *Int, n uint) *Int

Rsh は z = x >> n を設定し, z を返します。

func (*Int) Scan

func (z *Int) Scan(s fmt.ScanState, ch rune) error

Scan は fmt.Scanner のためのサポートルーチンです。 z をスキャンされた数の値に設定します。 フォーマットは 'b'(2進数), 'o'(8進数), 'd'(10進数), 'x'(小文字の16進数),および 'X'(大文字の16進数)です。

コード:

// 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)
}

出力:

18446744073709551617

func (*Int) Set

func (z *Int) Set(x *Int) *Int

Set は z を x に設定し, z を返します。

func (*Int) SetBit

func (z *Int) SetBit(x *Int, i int, b uint) *Int

SetBit は z を x に設定し, x の i 番目のビットは b (0 または 1) に設定されます。 つまり, b が 1 の場合, SetBit は z = x を設定します。 (1 << i) 。 b が 0 の場合, SetBit は z = x & ^(1 << i) を設定します。 b が 0 でも 1 でもない場合, SetBit はパニックします。

func (*Int) SetBits

func (z *Int) SetBits(abs []Word) *Int

SetBits は,その値を abs に設定し,リトルエンディアンの Word スライスとして解釈し, z を返すことによって, z への生の (未チェックだが高速な) アクセスを提供します。 結果と abs は同じ基底配列を共有します。 SetBits は,このパッケージ外で欠けている低レベルの Int 機能の実装をサポートすることを目的としています。 そうでなければこれを使うことは避けるべきです。

func (*Int) SetBytes

func (z *Int) SetBytes(buf []byte) *Int

SetBytes は, buf をビッグエンディアンの符号なし整数のバイトとして解釈し, z をその値に設定して z を返します。

func (*Int) SetInt64

func (z *Int) SetInt64(x int64) *Int

SetInt64 は z を x に設定し, z を返します。

func (*Int) SetString

func (z *Int) SetString(s string, base int) (*Int, bool)

SetString は, z を指定された基数で解釈された s の値に設定し, z と成功を示すブール値を返します。 文字列全体 (単なる接頭辞ではない) は成功のために有効でなければなりません。 SetString が失敗した場合, z の値は未定義ですが戻り値は nil です。

base (基数) 引数は 0 ,または 2 から MaxBase の間の値でなければなりません。 base が 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 の場合,アンダースコア文字 "_" が基数プレフィックスと隣接する数字の間,および連続する数字の間に現れることがあります。 このようなアンダースコアは,数値の値を変更しません。 他にエラーがない場合,アンダースコアの不適切な配置はエラーとして報告されます。 base != 0 の場合,アンダースコアは認識されず,有効な数字ではない他の文字と同様に機能します。

コード:

i := new(big.Int)
i.SetString("644", 8) // 八進
fmt.Println(i)

出力:

420

func (*Int) SetUint64 1.1

func (z *Int) SetUint64(x uint64) *Int

SetUint64 は z を x に設定し, z を返します。

func (*Int) Sign

func (x *Int) Sign() int

サインが戻ります :

-1, x <  0 の場合
 0, x == 0 の場合
+1, x >  0 の場合

func (*Int) Sqrt 1.8

func (z *Int) Sqrt(x *Int) *Int

Sqrt は z を z²≤ x のような最大の整数 ⌊√x⌋ に設定し, z を返します。 x が負の場合はパニックします。

func (*Int) String

func (x *Int) String() string

String は, x.Text(10) によって生成された x の 10 進表現を返します。

func (*Int) Sub

func (z *Int) Sub(x, y *Int) *Int

Sub は z を差 x-y に設定し, z を返します。

func (*Int) Text 1.6

func (x *Int) Text(base int) string

テキストは,指定されたベースで x の文字列表現を返します。基数は 2~62 である必要があります。結果は,数字の 10~35 に小文字の "a"~"z" を使用し,数字の 36~61 に大文字の "A"~"Z" を使用します。プレフィックスなし ("0x" など)) が文字列に追加されます。 x が nil ポインターの場合, "<nil>" を返します。

func (*Int) TrailingZeroBits 1.13

func (x *Int) TrailingZeroBits() uint

TrailingZeroBits は, |x| の連続する最下位ゼロビットの数を返します。

func (*Int) Uint64 1.1

func (x *Int) Uint64() uint64

Uint64 は, x の uint64 表現を返します。 x が uint64 で表現できない場合,結果は未定義です。

func (*Int) UnmarshalJSON 1.1

func (z *Int) UnmarshalJSON(text []byte) error

UnmarshalJSON は json.Unmarshaler インターフェースを実装します。

func (*Int) UnmarshalText 1.3

func (z *Int) UnmarshalText(text []byte) error

UnmarshalText は encoding.TextUnmarshaler インターフェースを実装します。

func (*Int) Xor

func (z *Int) Xor(x, y *Int) *Int

Xor は z = x ^ y を設定し, z を返します。

type Rat

Rat は任意精度の商 a/b を表します。 ラットのゼロ値は値 0 を表します。

操作は常に Rat 値ではなくポインター引数 (*Rat) を取り,固有の Rat 値ごとに固有の固有の *Rat ポインターが必要です。 Rat 値を " コピー " するには, Rat.Set メソッドを使用して既存の (または新しく割り当てられた) Rat を新しい値に設定する必要があります。 ラットの浅いコピーはサポートされていないため,エラーが発生する可能性があります。

type Rat struct {
    // エクスポートされていないフィールドがあります
}

func NewRat

func NewRat(a, b int64) *Rat

NewRat は,分子 a と分母 b を持つ新しい Rat を作成します。

func (*Rat) Abs

func (z *Rat) Abs(x *Rat) *Rat

Abs は z を |x| (x の絶対値) に設定し, z を返します。

func (*Rat) Add

func (z *Rat) Add(x, y *Rat) *Rat

Add は, z を x+y の和に設定し, z を返します。

func (*Rat) Cmp

func (x *Rat) Cmp(y *Rat) int

Cmp は x と y を比較して返します。

-1, x <  y の場合
 0, x == y の場合
+1, x >  y の場合

func (*Rat) Denom

func (x *Rat) Denom() *Int

Denom は x の分母を返します。 それは常に > 0 です。 結果は x の分母への参照です。 新しい値が x に割り当てられた場合は変更される可能性があり,またその逆の場合も同様です。

func (*Rat) Float32 1.4

func (x *Rat) Float32() (f float32, exact bool)

Float32 は, x に最も近い float32 値と, f が x を正確に表すかどうかを示すブール値を返します。 x の大きさが float32 で表現するには大きすぎる場合, f は無限大で, exact は false です。 f == 0 の場合でも, f の符号は常に x の符号と一致します。

func (*Rat) Float64 1.1

func (x *Rat) Float64() (f float64, exact bool)

Float64 は, x に最も近い float64 値と, f が正確に x を表すかどうかを示すブール値を返します。 x の大きさが float64 で表すには大きすぎる場合, f は無限大で, exact は false です。 f == 0 の場合でも, f の符号は常に x の符号と一致します。

func (*Rat) FloatString

func (x *Rat) FloatString(prec int) string

FloatString は,基数ポイントの後の精度が prec の 10 進数形式の x の文字列表現を返します。最後の桁は最も近い値に丸められ,半分はゼロから離れて丸められます。

func (*Rat) GobDecode

func (z *Rat) GobDecode(buf []byte) error

GobDecode は gob.GobDecoder インターフェースを実装します。

func (*Rat) GobEncode

func (x *Rat) GobEncode() ([]byte, error)

GobEncode は gob.GobEncoder インターフェースを実装します。

func (*Rat) Inv

func (z *Rat) Inv(x *Rat) *Rat

Inv は z を 1/x に設定し, z を返します。

func (*Rat) IsInt

func (x *Rat) IsInt() bool

IsInt は, x の分母が 1 かどうかを報告します。

func (*Rat) MarshalText 1.3

func (x *Rat) MarshalText() (text []byte, err error)

MarshalText は encoding.TextMarshaler インターフェースを実装します。

func (*Rat) Mul

func (z *Rat) Mul(x, y *Rat) *Rat

Mul は z を積 x*y に設定し, z を返します。

func (*Rat) Neg

func (z *Rat) Neg(x *Rat) *Rat

Neg は z を -x に設定し, z を返します。

func (*Rat) Num

func (x *Rat) Num() *Int

Num は x の分子を返します。 結果は x の分子への参照です。 新しい値が x に割り当てられた場合は変更される可能性があり,またその逆の場合も同様です。 分子の符号は x の符号に対応します。

func (*Rat) Quo

func (z *Rat) Quo(x, y *Rat) *Rat

Quo は, z を商 x/y に設定し, z を返します。 y == 0 の場合,ゼロ除算実行時パニックが発生します。

func (*Rat) RatString

func (x *Rat) RatString() string

RatString は, b != 1 の場合は "a/b" の形式で, b == 1 の場合は "a" の形式で x の文字列表現を返します。

func (*Rat) Scan

func (z *Rat) Scan(s fmt.ScanState, ch rune) error

Scan は fmt.Scanner のサポートルーチンです。 フォーマット 'e', 'E', 'f', 'F', 'g', 'G' ,および 'v' を受け入れます。 すべての形式は同等です。

コード:

// 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)
}

出力:

3/2

func (*Rat) Set

func (z *Rat) Set(x *Rat) *Rat

Set は, (x のコピーを作成することによって) z を x に設定し, z を返します。

func (*Rat) SetFloat64 1.1

func (z *Rat) SetFloat64(f float64) *Rat

SetFloat64 は z を正確に f に設定し, z を返します。 f が有限ではない場合, SetFloat は nil を返します。

func (*Rat) SetFrac

func (z *Rat) SetFrac(a, b *Int) *Rat

SetFrac は z を a/b に設定し, z を返します。

func (*Rat) SetFrac64

func (z *Rat) SetFrac64(a, b int64) *Rat

SetFrac64 は z を a/b に設定し, z を返します。

func (*Rat) SetInt

func (z *Rat) SetInt(x *Int) *Rat

SetInt は (x のコピーを作成することによって) z を x に設定し, z を返します。

func (*Rat) SetInt64

func (z *Rat) SetInt64(x int64) *Rat

SetInt64 は z を x に設定し, z を返します。

func (*Rat) SetString

func (z *Rat) SetString(s string) (*Rat, bool)

SetString は, z を s の値に設定し, z と成功を示すブール値を返します。 s は, (おそらく符号付きの) 分数 "a/b" として,またはオプションで指数が後に続く浮動小数点数として指定できます。分数が指定されている場合,被除数と除数の両方が 10 進整数であるか, "0b" , "0" , "0o" ,または "0x"(またはそれらのそれぞれ大文字, 2 進数, 8 進数, 16 進数の整数を表します。除数は符号がない可能性があります。浮動小数点数が渡される場合,それは 10 進数形式であるか,上記と同じプレフィックスのいずれかを使用しますが, "0" は非 10 進数の仮数を示します。先行する "0" は,先行する 0 の 10 進数と見なされます。この場合, 8 進数表現を示しません。オプションの base-10 “ e” または base-2 “ p” (または大文字のバリアント) 指数も提供できますが, (オプションの) “ p” のみを受け入れる 16 進浮動小数点数を除きます指数 ("e" または "E" は仮数と区別できないため) 成功するためには,プレフィックスだけでなく文字列全体が有効でなければなりません。操作が失敗した場合, z の値は未定義ですが,戻り値は nil です。

コード:

r := new(big.Rat)
r.SetString("355/113")
fmt.Println(r.FloatString(3))

出力:

3.142

func (*Rat) SetUint64 1.13

func (z *Rat) SetUint64(x uint64) *Rat

SetUint64 は, z を x に設定し, z を返します。

func (*Rat) Sign

func (x *Rat) Sign() int

サインが戻ります :

-1, x <  0 の場合
 0, x == 0 の場合
+1, x >  0 の場合

func (*Rat) String

func (x *Rat) String() string

String は x の文字列表現を "a/b" の形式で返します (b==1 の場合でも) 。

func (*Rat) Sub

func (z *Rat) Sub(x, y *Rat) *Rat

Sub は z を差 x-y に設定し, z を返します。

func (*Rat) UnmarshalText 1.3

func (z *Rat) UnmarshalText(text []byte) error

UnmarshalText は encoding.TextUnmarshaler インターフェースを実装します。

type RoundingMode 1.5

RoundingMode は, Float 値を希望の精度に丸める方法を決定します。 四捨五入すると Float 値が変わることがあります。 丸め誤差は Float's Accuracy によって表されます。

type RoundingMode byte

これらの定数はサポートされている丸めモードを定義します。

const (
    ToNearestEven RoundingMode = iota // == IEEE 754-2008 roundTiesToEven
    ToNearestAway                     // == IEEE 754-2008 roundTiesToAway
    ToZero                            // == IEEE 754-2008 roundTowardZero
    AwayFromZero                      // IEEE 754-2008 相当はありません
    ToNegativeInf                     // == IEEE 754-2008 roundTowardNegative
    ToPositiveInf                     // == IEEE 754-2008 roundTowardPositive
)

コード:

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++ {
        // sample operands above require 2 bits to represent mantissa
        // set binary precision to 2 to round them to integer values
        f := new(big.Float).SetPrec(2).SetMode(mode).SetFloat64(f64)
        fmt.Printf("  %*g", len(mode.String()), f)
    }
    fmt.Println()
}

出力:

   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

func (RoundingMode) String 1.5

func (i RoundingMode) String() string

type Word 1.9

Word は,多倍長の符号なし整数の 1 桁の数字を表します。

type Word uint