Пакет big
Обзор
Пакет big реализует арифметику произвольной точности (большие числа). Поддерживаются следующие числовые типы:
Int signed integers Rat rational numbers Float floating-point numbers
Нулевое значение для Int, Rat или Float соответствует 0. Таким образом, новые значения можно объявлять обычным способом и обозначать 0 без дальнейшей инициализации:
var x Int // &x is an *Int of value 0
var r = &Rat{} // r is a *Rat of value 0
y := new(Float) // y is a *Float of value 0
В качестве альтернативы новые значения можно выделять и инициализировать с помощью функций-фабрик следующего вида:
func NewT(v V) *T
Например, NewInt(x) возвращает *Int, установленный в значение int64 аргумента x, NewRat(a, b) возвращает *Rat, установленный в дробь a/b, где a и b — значения int64, а NewFloat(f) возвращает *Float, инициализированный аргументом float64 f. Больше гибкости предоставляют явные установщики, например:
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 в сумме.
(Постоянно передавая значение результата через получателя, можно гораздо лучше управлять использованием памяти. Вместо того, чтобы выделять новую память для каждого результата, операция может повторно использовать пространство, выделенное для значения результата, и перезаписать это значение новым результатом в процессе.)
Условность записи: Входящие параметры метода (включая получателя) имеют согласованное именование в 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 для форматированного вывода.
Пример (EConvergents)
Этот пример демонстрирует, как использовать big.Rat для вычисления первых 15 членов последовательности рациональных конвергентов для константы e (основание натурального логарифма).
Код:
package big_test
import (
"fmt"
"math/big"
)
// Use the classic continued fraction for e
//
// e = [1; 0, 1, 1, 2, 1, 1, ... 2n, 1, 1, ...]
//
// i.e., for the nth term, use
//
// 1 if n mod 3 != 1
// (n-1)/3 * 2 if 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
}
// Directly initialize frac as the fractional
// inverse of the result of recur.
frac := new(big.Rat).Inv(recur(n+1, lim))
return term.Add(term, frac)
}
// This example demonstrates how to use big.Rat to compute the
// first 15 terms in the sequence of rational convergents for
// the constant e (base of natural logarithm).
func Example_eConvergents() {
for i := 1; i <= 15; i++ {
r := recur(0, int64(i))
// Print r both as a fraction and as a floating-point number.
// Since big.Rat implements fmt.Formatter, we can use %-13s to
// get a left-aligned string representation of the fraction.
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
}
Пример (Фибоначчи)
Этот пример демонстрирует, как использовать big.Int для вычисления наименьшего числа Фибоначчи с 100 десятичными знаками и проверки, является ли оно простым.
Код:
// Initialize two big ints with the first two numbers in the sequence.
a := big.NewInt(0)
b := big.NewInt(1)
// Initialize limit as 10^99, the smallest integer with 100 digits.
var limit big.Int
limit.Exp(big.NewInt(10), big.NewInt(99), nil)
// Loop while a is smaller than 1e100.
for a.Cmp(&limit) < 0 {
// Compute the next Fibonacci number, storing it in a.
a.Add(a, b)
// Swap a and b so that b is the next number in the sequence.
a, b = b, a
}
fmt.Println(a) // 100-digit Fibonacci number
// Test a for primality.
// (ProbablyPrimes' argument sets the number of Miller-Rabin
// rounds to be performed. 20 is a good value.)
fmt.Println(a.ProbablyPrime(20))
Вывод:
1344719667586153181419716641724567886890850696275767987106294472017884974410332069524504824747437757 false
Пример (Sqrt2)
Этот пример показывает, как использовать big.Float для вычисления квадратного корня из 2 с точностью 200 бит и как вывести результат в виде десятичного числа.
Код:
// We'll do computations with 200 bits of precision in the mantissa.
const prec = 200
// Compute the square root of 2 using Newton's Method. We start with
// an initial estimate for sqrt(2), and then iterate:
// x_{n+1} = 1/2 * ( x_n + (2.0 / x_n) )
// Since Newton's Method doubles the number of correct digits at each
// iteration, we need at least log_2(prec) steps.
steps := int(math.Log2(prec))
// Initialize values we need for the computation.
two := new(big.Float).SetPrec(prec).SetInt64(2)
half := new(big.Float).SetPrec(prec).SetFloat64(0.5)
// Use 1 as the initial estimate.
x := new(big.Float).SetPrec(prec).SetInt64(1)
// We use t as a temporary variable. There's no need to set its precision
// since big.Float values with unset (== 0) precision automatically assume
// the largest precision of the arguments when used as the result (receiver)
// of a big.Float operation.
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
}
// We can use the usual fmt.Printf verbs since big.Float implements fmt.Formatter
fmt.Printf("sqrt(2) = %.50f\n", x)
// Print the error between 2 and 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
Индекс
Примеры
Файлы пакета
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 natdiv.go prime.go rat.go ratconv.go ratmarsh.go roundingmode_string.go sqrt.go
Константы
Пределы экспоненты и точности.
const (
MaxExp = math.MaxInt32 // largest supported exponent
MinExp = math.MinInt32 // smallest supported exponent
MaxPrec = math.MaxUint32 // largest (theoretically) supported precision; likely memory-limited
) MaxBase — это наибольшая система счисления, принимаемая для преобразований строк.
const MaxBase = 10 + ('z' - 'a' + 1) + ('Z' - 'A' + 1) func Jacobi 1.5
func Jacobi(x, y *Int) int
Jacobi возвращает символ Якоби (x/y), либо +1, -1, или 0. Аргумент y должен быть нечётным целым числом.
тип Accuracy 1.5
Accuracy описывает погрешность округления, произведённую последней операцией, которая сгенерировала значение Float, относительно точного значения.
type Accuracy int8
Константы, описывающие Accuracy Float.
const (
Below Accuracy = -1
Exact Accuracy = 0
Above Accuracy = +1
) func (Accuracy) String 1.5
func (i Accuracy) String() string
тип ErrNaN 1.5
Ошибка ErrNaN возникает при выполнении операции Float, которая привела бы к NaN в соответствии с правилами IEEE 754. ErrNaN реализует интерфейс ошибки.
type ErrNaN struct {
// contains filtered or unexported fields
}
func (ErrNaN) Error 1.5
func (err ErrNaN) Error() string
тип Float 1.5
Неравное нулю конечное Float представляет число с плавающей точкой с многократной точностью
sign × mantissa × 2**exponent
с 0,5 <= мантисса < 1,0 и MinExp <= экспонента <= MaxExp. Float также может быть нулём (+0, -0) или бесконечным (+Inf, -Inf). Все Float упорядочены, и порядок двух Float x и y определяется x.Cmp(y).
Каждое значение Float также имеет точность, режим округления и точность. Точность — это максимальное количество битов мантиссы, доступных для представления значения. Режим округления определяет, как результат должен быть округлен, чтобы поместиться в биты мантиссы, а точность описывает погрешность округления по отношению к точному результату.
Если не указано иное, все операции (включая установщики), которые указывают *Float переменную для результата (обычно через получатель с исключением Float.MantExp), округляют числовой результат в соответствии с точностью и режимом округления переменной результата.
Если указанная точность результата равна 0 (см. ниже), она устанавливается в точность аргумента с наибольшим значением точности перед любым округлением, а режим округления остаётся неизменным. Таким образом, неинициализированные Float, предоставленные в качестве аргументов результата, будут иметь свою точность установленной в разумное значение, определяемое операндами, а их режим — нулевое значение для RoundingMode (ToNearestEven).
Установив желаемую точность в 24 или 53 и используя соответствующий режим округления (обычно ToNearestEven), операции с Float производят те же результаты, что и соответствующая арифметика float32 или float64 IEEE 754 для операндов, соответствующих нормальным (т. е. не денормальным) float32 или float64 числам. Подпороговый и перепороговый экспоненты приводят к 0 или Бесконечности для различных значений, чем IEEE 754, потому что экспоненты Float имеют гораздо больший диапазон.
Нулевое (неинициализированное) значение для Float готово к использованию и представляет число +0,0 точно, с точностью 0 и режимом округления ToNearestEven.
Операции всегда принимают аргументы указателей (*Float), а не значения Float, и каждое уникальное значение Float требует своего собственного уникального указателя *Float. Для «копирования» значения Float необходимо установить существующее (или вновь выделенное) Float в новое значение с помощью метода Float.Set; неглубокие копии Float не поддерживаются и могут привести к ошибкам.
type Float struct {
// contains filtered or unexported fields
}
Пример (Сдвиг)
Код:
// 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 выделяет и возвращает новый Float, установленный на x, с точностью 53 и режимом округления ToNearestEven. NewFloat вызывает ошибку ErrNaN, если x — NaN.
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
Add устанавливает z в округленное значение суммы x+y и возвращает z. Если точность z равна 0, она изменяется на большую из точности x или y до операции. Округление выполняется в соответствии с точностью и режимом округления z; и точность z сообщает об ошибке результата относительно точного (не округленного) результата. Add вызывает ошибку ErrNaN, если x и y — бесконечности с противоположными знаками. Значение 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 добавляет к buf строковое представление числа с плавающей точкой x, сгенерированное x.Text, и возвращает расширенный буфер.
func (*Float) AppendText 1.24
func (x *Float) AppendText(b []byte) ([]byte, error)
AppendText реализует интерфейс encoding.TextAppender. Маршалируется только значение Float (в полной точности), другие атрибуты, такие как точность или точность, игнорируются.
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 и +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 устанавливает z в x с той же точностью, режимом округления и точностью, что и у x. Copy возвращает z. Если x и z идентичны, Copy — это нетранзакционная операция.
Пример
Код:
var x, z big.Float
x.SetFloat64(1.23)
r := z.Copy(&x)
fmt.Printf("a) r = %g, z = %g, x = %g, r == z = %v\n", r, &z, &x, r == &z)
// changing z changes r since they are identical
z.SetInt64(42)
fmt.Printf("b) r = %g, z = %g, r == z = %v\n", r, &z, r == &z)
x.SetPrec(1)
z.Copy(&x)
fmt.Printf("c) z = %g, x = %g, z == x = %v\n", &z, &x, &z == &x)
Вывод:
a) r = 1.23, z = 1.23, x = 1.23, r == z = true b) r = 42, z = 42, r == z = true c) z = 1, x = 1, z == x = false
func (*Float) Float32 1.5
func (x *Float) Float32() (float32, Accuracy)
Float32 возвращает значение float32, ближайшее к x. Если x слишком мало, чтобы быть представленным float32 (|x| < math.SmallestNonzeroFloat32), результат — (0, Below) или (-0, Above) соответственно в зависимости от знака x. Если x слишком велик, чтобы быть представленным float32 (|x| > math.MaxFloat32), результат — (+Inf, Above) или (-Inf, Below) соответственно в зависимости от знака x.
func (*Float) Float64 1.5
func (x *Float) Float64() (float64, Accuracy)
Float64 возвращает значение float64, ближайшее к x. Если x слишком мало, чтобы быть представленным float64 (|x| < math.SmallestNonzeroFloat64), результат — (0, Below) или (-0, Above) соответственно в зависимости от знака x. Если x слишком велик, чтобы быть представленным float64 (|x| > math.MaxFloat64), результат — (+Inf, Above) или (-Inf, Below) соответственно в зависимости от знака x.
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'. См. (*Float).Text для интерпретации 'p'. Формат 'v' обрабатывается как 'g'. Format также поддерживает указание минимальной точности в цифрах, ширины вывода поля, а также флагов форматирования '+' и ' ' для управления знаком, '0' для заполнения пробелами или нулями, и '-' для выравнивания слева или справа. См. пакет fmt для деталей.
func (*Float) GobDecode 1.7
func (z *Float) GobDecode(buf []byte) error
GobDecode реализует интерфейс encoding/gob.GobDecoder. Результат округляется в соответствии с точностью и режимом округления z, если точность z равна 0, в этом случае z устанавливается точно в декодированное значение.
func (*Float) GobEncode 1.7
func (x *Float) GobEncode() ([]byte, error)
GobEncode реализует интерфейс encoding/gob.GobEncoder. Значение Float и все его атрибуты (точность, режим округления, точность) маршаллируются.
func (*Float) Int 1.5
func (x *Float) Int(z *Int) (*Int, Accuracy)
Int возвращает результат усечения x к нулю; или nil, если x — бесконечность. Результат является точным, если x.IsInt(); в противном случае он является ниже для x > 0 и выше для x < 0. Если предоставлен непустой аргумент *Int z, Int сохраняет результат в z вместо выделения нового Int.
func (*Float) Int64 1.5
func (x *Float) Int64() (int64, Accuracy)
Int64 возвращает целое число, полученное в результате усечения x к нулю. Если math.MinInt64 ≤ x ≤ math.MaxInt64, результат является точным, если x — целое число, и выше (x < 0) или ниже (x > 0) в противном случае. Результат равен (math.MinInt64, выше) для x < math.MinInt64 и (math.MaxInt64, ниже) для x > math.MaxInt64.
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 на компоненты мантиссы и экспоненты и возвращает экспоненту. Если аргумент mant не равен nil, его значение устанавливается в мантиссу x с той же точностью и режимом округления, что и у x. Компоненты удовлетворяют x == mant × 2**exp, где 0.5 ≤ |mant| < 1.0. Вызов MantExp с аргументом nil — это эффективный способ получить экспоненту получателя.
Особые случаи:
( ±0).MantExp(mant) = 0, with mant set to ±0 (±Inf).MantExp(mant) = 0, with mant set to ±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). Результат равен 0 для |x| == 0 и |x| == Inf.
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. Точность, округление и сообщения об точности такие же, как для Float.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 анализирует s, который должен содержать текстовое представление числа с плавающей запятой с мантиссой в заданной системе счисления (экспонента всегда является десятичным числом) или строку, представляющую бесконечное значение.
Для базы 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, и префикс не принимается. Восьмеричный префикс «0» не поддерживается (ведущая «0» просто рассматривается как «0»).
Экспонента «p» или «P» указывает на базу 2 (а не базу 10) экспоненты; например, «0x1.fffffffffffffp1023» (используя базу 0) представляет максимальное значение float64. Для шестнадцатеричных мантисс символ экспоненты должен быть одним из 'p' или 'P', если он присутствует (индикатор экспоненты «e» или «E» нельзя отличить от цифры мантиссы).
Возвращаемый *Float f равен nil, а значение z является допустимым, но не определённым, если сообщается об ошибке.
func (*Float) Prec 1.5
func (x *Float) Prec() uint
Prec возвращает точность мантиссы x в битах. Результат может быть 0 для |x| == 0 и |x| == Inf.
func (*Float) Quo 1.5
func (z *Float) Quo(x, y *Float) *Float
Quo устанавливает z в округленное частное x/y и возвращает z. Точность, округление и сообщения об точности такие же, как для Float.Add. Quo вызывает панику с ErrNaN, если оба операнда равны нулю или бесконечности. В этом случае значение z не определено.
func (*Float) Rat 1.5
func (x *Float) Rat(z *Rat) (*Rat, Accuracy)
Rat возвращает рациональное число, соответствующее x; или nil, если x — бесконечность. Результат является точным, если x не является Inf. Если предоставлен непустой аргумент *Rat z, Rat сохраняет результат в z вместо выделения нового Rat.
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.
Пример
Код:
// The Scan function is rarely used directly;
// the fmt package recognizes it as an implementation of 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, она изменяется на точность x перед установкой z (и округление не будет иметь эффекта). Округление выполняется в соответствии с точностью и режимом округления z; и точность z сообщает об ошибке результата по отношению к точному (не округленному) результату.
func (*Float) SetFloat64 1.5
func (z *Float) SetFloat64(x float64) *Float
SetFloat64 устанавливает z в (возможно, округленное) значение x и возвращает z. Если точность z равна 0, она изменяется на 53 (и округление не будет иметь эффекта). SetFloat64 вызывает панику с ErrNaN, если x — NaN.
func (*Float) SetInf 1.5
func (z *Float) SetInf(signbit bool) *Float
SetInf устанавливает z в бесконечный Float -Inf, если установлен флаг знака, или +Inf, если флаг знака не установлен, и возвращает z. Точность z не изменяется, и результат всегда точный.
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 является обратным Float.MantExp, но не требует 0.5 ≤ |mant| < 1.0. В частности, для данного x типа *Float, SetMantExp относится к Float.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 1.5
func (z *Float) SetMode(mode RoundingMode) *Float
SetMode устанавливает режим округления z в mode и возвращает точный z. В противном случае z остаётся без изменений. z.SetMode(z.Mode()) — это дешёвый способ установить точность z на точную.
func (*Float) SetPrec 1.5
func (z *Float) SetPrec(prec uint) *Float
SetPrec устанавливает точность z на prec и возвращает (возможно) округленное значение z. Округление происходит в соответствии с режимом округления z, если мантиссу нельзя представить в prec битах без потери точности. 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 должен быть числом с плавающей запятой в том же формате, что и принимаемое Float.Parse, с аргументом базы 0. Для успеха вся строка (а не только префикс) должна быть корректной. Если операция не удалась, значение z не определено, но возвращаемое значение равно nil.
Пример
Код:
f := new(big.Float)
f.SetString("3.14159")
fmt.Println(f)
Вывод:
3.14159
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 не вычисляется. В частности, результат z.Acc() не определён.
Функция вызывает ошибку, если z < 0. Значение z в этом случае не определено.
func (*Float) String 1.5
func (x *Float) String() string
String форматирует x как x.Text('g', 10). (String необходимо вызывать явно, Float.Format не поддерживает версию %s.)
func (*Float) Sub 1.5
func (z *Float) Sub(x, y *Float) *Float
Sub устанавливает z в округлённую разность x-y и возвращает z. Точность, округление и отчёт о точности такие же, как у Float.Add. Sub вызывает ошибку с ErrNaN, если x и y являются бесконечностями с одинаковыми знаками. Значение z в этом случае не определено.
func (*Float) Text 1.5
func (x *Float) Text(format byte, prec int) string
Text преобразует число с плавающей точкой x в строку в соответствии с заданным форматом и точностью prec. Формат — один из:
'e' -d.dddde±dd, decimal exponent, at least two (possibly 0) exponent digits '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)
Для форматов экспоненты в степени двойки мантисса печатается в нормализованной форме:
'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' используется большинством других языков и библиотек.
Если формат — другой символ, Text возвращает "%" вместе с нераспознанным символом формата.
Точность prec управляет количеством цифр (исключая экспоненту), выводимых форматами 'e', 'E', 'f', 'g', 'G' и 'x'. Для 'e', 'E', 'f' и 'x' это число цифр после десятичной точки. Для 'g' и 'G' — общее число цифр. Отрицательная точность выбирает минимальное количество десятичных цифр, необходимое для однозначной идентификации значения x с использованием битов мантиссы x.Prec(). Значение prec игнорируется для форматов 'b' и 'p'.
func (*Float) Uint64 1.5
func (x *Float) Uint64() (uint64, Accuracy)
Uint64 возвращает целое беззнаковое число, полученное в результате усечения x в сторону нуля. Если 0 ≤ x ≤ math.MaxUint64, результат является Exact, если x является целым числом, и Below в противном случае. Результат — (0, Above) для x < 0 и (math.MaxUint64, Below) для x > math.MaxUint64.
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 с помощью метода Int.Set; неглубокие копии Int не поддерживаются и могут привести к ошибкам.
Обратите внимание, что методы могут раскрывать значение Int через временные каналы. Из-за этого и из-за области и сложности реализации Int не подходит для реализации криптографических операций. Стандартная библиотека избегает экспонирования нетривиальных методов Int для вводимых пользователем данных и определение, считается ли ошибка в math/big уязвимостью в безопасности, может зависеть от влияния на стандартную библиотеку.
type Int struct {
// contains filtered or unexported fields
}
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, сгенерированное x.Text(base), в buf и возвращает расширенный буфер.
func (*Int) AppendText 1.24
func (x *Int) AppendText(b []byte) (text []byte, err error)
AppendText реализует интерфейс encoding.TextAppender.
func (*Int) Binomial
func (z *Int) Binomial(n, k int64) *Int
Binomial устанавливает z в биномиальный коэффициент C(n, k) и возвращает z.
func (*Int) Bit
func (x *Int) Bit(i int) uint
Bit возвращает значение i-го бита x. То есть, возвращает (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 предоставляет прямой (но не проверенный, но быстрый) доступ к x, возвращая его абсолютное значение в виде little-endian Word среза. Результат и x разделяют один и тот же массив. Bits предназначен для поддержки реализации отсутствующей низкоуровневой функциональности Int вне этого пакета; его следует избегать в противном случае.
func (*Int) Bytes
func (x *Int) Bytes() []byte
Bytes возвращает абсолютное значение x в виде big-endian байтового среза.
Для использования среза фиксированной длины или предварительно выделенного среза используйте Int.FillBytes.
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 устанавливает z в частное x/y для y != 0 и возвращает z. Если y == 0, возникает ошибка деления на ноль во время выполнения. Div реализует евклидово деление (в отличие от Go); см. Int.DivMod для получения дополнительных сведений.
func (*Int) DivMod
func (z *Int) DivMod(x, y, m *Int) (*Int, *Int)
DivMod устанавливает z в частное x div y и m в остаток x mod y и возвращает пару (z, m) для y != 0. Если y == 0, возникает ошибка деления на ноль во время выполнения.
DivMod реализует евклидово деление и остаток (в отличие от Go):
q = x div y such that m = x - y*q with 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.) См. Int.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, z = x**y, за исключением случаев, когда y ≤ 0, в этом случае z = 1. Если m != 0, y < 0 и x и m не взаимно просты, z не изменяется, и возвращается nil.
Модулярное возведение в степень входных данных определенного размера не является криптографически постоянной по времени операцией.
func (*Int) FillBytes 1.15
func (x *Int) FillBytes(buf []byte) []byte
FillBytes устанавливает buf в абсолютное значение x, сохраняя его как нулевое расширение big-endian байтового среза, и возвращает buf.
Если абсолютное значение x не помещается в buf, FillBytes вызовет ошибку.
func (*Int) Float64 1.21
func (x *Int) Float64() (float64, Accuracy)
Float64 возвращает ближайшее к x значение float64 и указание на любые произошедшие округления.
func (*Int) Format
func (x *Int) Format(s fmt.State, ch rune)
Format реализует fmt.Formatter. Он принимает форматы 'b' (двоичный), 'o' (восьмеричный с префиксом 0), 'O' (восьмеричный с префиксом 0o), 'd' (десятичный), 'x' (нижняя граница шестнадцатеричного) и 'X' (верхняя граница шестнадцатеричного). Также поддерживаются все флаги формата пакета fmt для целочисленных типов, включая '+' и ' ' для управления знаком, '#' для ведущего нуля в восьмеричной и шестнадцатеричной системе счисления, ведущего "0x" или "0X" для "%#x" и "%#X" соответственно, указание минимальной точности цифр, ширины поля вывода, заполнения пробелом или нулём, и '-' для выравнивания влево или вправо.
func (*Int) GCD
func (z *Int) GCD(x, y, a, b *Int) *Int
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) GobDecode
func (z *Int) GobDecode(buf []byte) error
GobDecode реализует интерфейс encoding/gob.GobDecoder.
func (*Int) GobEncode
func (x *Int) GobEncode() ([]byte, error)
GobEncode реализует интерфейс encoding/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 реализует интерфейс encoding/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 устанавливает z в остаток от деления x на y (x%y), если y != 0, и возвращает z. Если y == 0, возникает ошибка времени выполнения деления на ноль. Mod реализует евклидов остаток (в отличие от Go); см. Int.DivMod для получения более подробной информации.
func (*Int) ModInverse
func (z *Int) ModInverse(g, n *Int) *Int
ModInverse устанавливает z в мультипликативную обратную величину g в кольце ℤ/nℤ и возвращает z. Если g и n не являются взаимно простыми, у g нет мультипликативной обратной величины в кольце ℤ/nℤ. В этом случае z остается неизменным, а возвращаемое значение равно nil. Если n == 0, возникает ошибка времени выполнения деления на ноль.
func (*Int) ModSqrt 1.5
func (z *Int) ModSqrt(x, p *Int) *Int
ModSqrt устанавливает z в квадратный корень из x по модулю p, если такой квадратный корень существует, и возвращает z. Модуль p должен быть нечётным простым числом. Если x не является квадратом по модулю p, ModSqrt оставляет z без изменений и возвращает nil. Данная функция вызывает ошибку, если p не является нечётным целым числом; её поведение не определено, если 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 псевдослучайными основаниями, а также тест Балли—ПСВ.
Если x является простым числом, ProbablyPrime возвращает true. Если x выбран случайным образом и не является простым, ProbablyPrime, вероятно, вернёт false. Вероятность возвращения true для случайно выбранного не простого числа не превышает ¼ⁿ.
ProbablyPrime имеет 100% точность для входных данных меньше 2⁶⁴. Дополнительную информацию об ошибках см. в книге Menezes et al., «Справочник по прикладной криптографии», 1997, стр. 145-149, и в приложении F к FIPS 186-4.
ProbablyPrime не подходит для проверки простых чисел, которые могут быть сконструированы противником для обмана теста.
Начиная с Go 1.8, ProbablyPrime(0) разрешен и применяет только тест Балли—ПСВ. До Go 1.8 ProbablyPrime применял только тесты Миллера—Рабина, и ProbablyPrime(0) вызывал ошибку.
func (*Int) Quo
func (z *Int) Quo(x, y *Int) *Int
Quo устанавливает z в частное x/y для y != 0 и возвращает z. Если y == 0, возникает ошибка времени выполнения деления на ноль. Quo реализует усеченное деление (как в Go); см. Int.QuoRem для получения более подробной информации.
func (*Int) QuoRem
func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)
QuoRem устанавливает z в частное x/y и r в остаток x%y и возвращает пару (z, r) для y != 0. Если y == 0, возникает ошибка времени выполнения деления на ноль.
QuoRem реализует T-деление и модуль (как в Go):
q = x/y with the result truncated to zero r = x - y*q
(См. Daan Leijen, «Деление и модуль для специалистов по вычислительной технике».) См. Int.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 устанавливает z в остаток x%y для y != 0 и возвращает z. Если y == 0, возникает ошибка времени выполнения деления на ноль. Rem реализует усечённый модуль (как в Go); см. Int.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' (двоичный), 'o' (восьмеричный), 'd' (десятичный), 'x' (нижний регистр шестнадцатеричный) и 'X' (верхний регистр шестнадцатеричный).
Пример
Код:
// The Scan function is rarely used directly;
// the fmt package recognizes it as an implementation of 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, с i-м битом x, установленным на 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 обеспечивает прямой (непроверенный, но быстрый) доступ к z, устанавливая его значение в abs, интерпретированное как срез little-endian Word, и возвращает 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) // octal
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
Sign возвращает:
- -1, если x < 0;
- 0, если x == 0;
- +1, если x > 0.
func (*Int) Sqrt 1.8
func (z *Int) Sqrt(x *Int) *Int
Sqrt устанавливает z в ⌊√x⌋, наибольшее целое число, такое что z² ≤ x, и возвращает z. Возникает ошибка, если x отрицательно.
func (*Int) String
func (x *Int) String() string
String возвращает десятичное представление x, сгенерированное x.Text(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
Text возвращает строковое представление x в заданном основании. Основание должно быть от 2 до 62 включительно. Результат использует строчные буквы 'a' до 'z' для значений цифр от 10 до 35 и прописные буквы 'A' до 'Z' для значений цифр от 36 до 61. Префиксов (таких как "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 реализует интерфейс encoding/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 произвольной точности. Нулевое значение для Rat представляет значение 0.
Операции всегда принимают аргументы указателей (*Rat) вместо значений Rat, и каждое уникальное значение Rat требует собственного уникального указателя *Rat. Чтобы «скопировать» значение Rat, необходимо установить новое значение существующему (или новому) Rat, используя метод Rat.Set; поверхностные копии Rat не поддерживаются и могут привести к ошибкам.
type Rat struct {
// contains filtered or unexported fields
}
func NewRat
func NewRat(a, b int64) *Rat
NewRat создаёт новый Rat с числителем a и знаменателем b.
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) AppendText 1.24
func (x *Rat) AppendText(b []byte) ([]byte, error)
AppendText реализует интерфейс encoding.TextAppender.
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 — неинициализированное (нулевое) значение Rat, в этом случае результат — новый Int со значением 1. (Для инициализации x подойдёт любая операция, которая устанавливает x, включая x.Set(x)). Если результат — ссылка на знаменатель x, он может измениться при присвоении нового значения x, и наоборот.
func (*Rat) Float32 1.4
func (x *Rat) Float32() (f float32, exact bool)
Float32 возвращает ближайшее значение float32 для x и булево значение, указывающее, представляет ли f значение x точно. Если абсолютное значение x слишком велико, чтобы быть представленным float32, f является бесконечностью, а exact — ложью. Знак f всегда соответствует знаку x, даже если f == 0.
func (*Rat) Float64 1.1
func (x *Rat) Float64() (f float64, exact bool)
Float64 возвращает ближайшее значение float64 для x и булево значение, указывающее, представляет ли f значение x точно. Если абсолютное значение x слишком велико, чтобы быть представленным float64, f является бесконечностью, а exact — ложью. Знак f всегда соответствует знаку x, даже если f == 0.
func (*Rat) FloatPrec 1.22
func (x *Rat) FloatPrec() (n int, exact bool)
FloatPrec возвращает количество n не повторяющихся цифр, непосредственно следующих за десятичной точкой в десятичном представлении x. Булево значение результата указывает, является ли десятичное представление x с таким количеством дробных цифр точным или округленным.
Примеры:
x n exact decimal representation n fractional digits 0 0 true 0 1 0 true 1 1/2 1 true 0.5 1/3 0 false 0 (0.333... rounded) 1/4 2 true 0.25 1/6 1 false 0.2 (0.166... rounded)
func (*Rat) FloatString
func (x *Rat) FloatString(prec int) string
FloatString возвращает строковое представление x в десятичной форме с prec цифрами точности после десятичной точки. Последняя цифра округляется до ближайшего значения, причём половины округляются в сторону от нуля.
func (*Rat) GobDecode
func (z *Rat) GobDecode(buf []byte) error
GobDecode реализует интерфейс encoding/gob.GobDecoder.
func (*Rat) GobEncode
func (x *Rat) GobEncode() ([]byte, error)
GobEncode реализует интерфейс encoding/gob.GobEncoder.
func (*Rat) Inv
func (z *Rat) Inv(x *Rat) *Rat
Inv устанавливает z в 1/x и возвращает z. Если x == 0, Inv вызывает панику.
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; он может быть <= 0. Результат является ссылкой на числитель x; он может измениться, если x получит новое значение, и наоборот. Знак числителя соответствует знаку x.
func (*Rat) Quo
func (z *Rat) Quo(x, y *Rat) *Rat
Quo устанавливает z в частное x/y и возвращает z. Если y == 0, Quo вызывает панику.
func (*Rat) RatString
func (x *Rat) RatString() string
RatString возвращает строковое представление x в форме "a/b", если b != 1, и в форме "a", если b == 1.
func (*Rat) Scan
func (z *Rat) Scan(s fmt.ScanState, ch rune) error
Scan — вспомогательная функция для fmt.Scanner. Она принимает форматы 'e', 'E', 'f', 'F', 'g', 'G' и 'v'. Все форматы эквивалентны.
Пример
Код:
// The Scan function is rarely used directly;
// the fmt package recognizes it as an implementation of 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 устанавливает z в x (создавая копию 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. Если b == 0, SetFrac вызывает панику.
func (*Rat) SetFrac64
func (z *Rat) SetFrac64(a, b int64) *Rat
SetFrac64 устанавливает z в a/b и возвращает z. Если b == 0, SetFrac64 вызывает панику.
func (*Rat) SetInt
func (z *Rat) SetInt(x *Int) *Rat
SetInt устанавливает z в x (создавая копию 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" или как число с плавающей точкой, необязательно с показателем степени. Если задана дробь, и числитель, и знаменатель могут быть целым десятичным числом или использовать префикс "0b", "0", "0o" или "0x" (или их заглавные аналоги) для обозначения двоичного, восьмеричного или шестнадцатеричного целого числа соответственно. Знаменатель не может быть со знаком. Если задано число с плавающей точкой, оно может быть в десятичном формате или использовать любые из тех же префиксов, что и для "0", для обозначения мантиссы, не являющейся десятичной. Ведущая "0" рассматривается как десятичный ведущий 0; в этом случае это не указывает на восьмеричное представление. Также может быть предоставлен необязательный десятичный показатель степени "e" или двоичный "p" (или их заглавные аналоги), за исключением шестнадцатеричных чисел с плавающей точкой, которые принимают только (необязательный) показатель степени "p" (потому что "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
Sign возвращает:
- -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 // no IEEE 754-2008 equivalent
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
Word представляет собой одну цифру многоразрядного беззнакового целого числа.
type Word uint
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/math/big/
