Пакет 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, заменяя его прежнее значение. Если не указано иное, операции допускают псевдонимы параметров, поэтому вполне допустимо написать
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 для сканирования, а также интерфейс Formatter (кроме *Rat) для форматированного вывода.
Пример (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
}
Пример (Fibonacci)
В этом примере показано, как использовать 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 natmul.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
) Режимы округления, определяющие, как корректируется целочисленное частное при целочисленном делении. Подробности см. в статье Даана Лейена «Division and Modulus for Computer Scientists».
const (
Trunc = ToZero // T-division (same as Go division)
Floor = ToNegativeInf // F-division
Round = ToNearestEven // R-division
Ceil = ToPositiveInf // C-division
) 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 должен быть нечётным целым числом.
type 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
type ErrNaN 1.5
Паника ErrNaN возникает при выполнении операции Float, которая по правилам IEEE 754 привела бы к NaN. ErrNaN реализует интерфейс error.
type ErrNaN struct {
// contains filtered or unexported fields
}
func (ErrNaN) Error 1.5
func (err ErrNaN) Error() string
type Float 1.5
Ненулевое конечное значение Float представляет собой число с плавающей точкой и многократной точностью
sign × mantissa × 2**exponent
с мантиссой 0.5 <= mantissa < 1.0 и показателем MinExp <= exponent <= 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 будут давать те же результаты, что и соответствующие операции арифметики IEEE 754 над float32 или float64, для операндов, соответствующих нормальным (то есть не субнормальным) числам 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
}
Пример (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 выделяет память для нового 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 возвращает ближайшее к x значение float32. Если x слишком мало для представления в формате float32 (|x| < math.SmallestNonzeroFloat32), результатом будет (0, Below) или (-0, Above) в зависимости от знака x. Если x слишком велико для представления в формате float32 (|x| > math.MaxFloat32), результатом будет (+Inf, Above) или (-Inf, Below) в зависимости от знака x.
func (*Float) Float64 1.5
func (x *Float) Float64() (float64, Accuracy)
Float64 возвращает ближайшее к x значение float64. Если x слишком мало для представления в формате float64 (|x| < math.SmallestNonzeroFloat64), результатом будет (0, Below) или (-0, Above) в зависимости от знака x. Если x слишком велико для представления в формате float64 (|x| > math.MaxFloat64), результатом будет (+Inf, Above) или (-Inf, Below) в зависимости от знака x.
func (*Float) Format 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'. 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 — бесконечность. Результат имеет значение Exact, если x.IsInt(); в противном случае — Below при x > 0 и Above при 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, результат имеет значение Exact, если x — целое число, и Above (при x < 0) или Below (при x > 0) в противном случае. Результатом будет (math.MinInt64, Above) при x < math.MinInt64 и (math.MaxInt64, Below) при 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, ему присваивается мантисса 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 (то есть наименьшее значение prec, при котором 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 символ подчёркивания «_» может находиться между префиксом основания и следующей за ним цифрой, а также между соседними цифрами; такие символы подчёркивания не влияют на значение числа и количество возвращаемых цифр. Неправильное расположение символов подчёркивания сообщается как ошибка, если других ошибок нет. Если 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, и префикс не допускается. Восьмеричный префикс "0" не поддерживается (начальный "0" просто считается цифрой "0").
Порядок на основании 2 обозначается символом "p" или "P"; например, "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, перед установкой z она изменяется на точность x (округление не повлияет на результат). Округление выполняется в соответствии с точностью и режимом округления 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, если установлен signbit, или +Inf, если signbit не установлен, и возвращает 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 в значение Exact.
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 при аргументе base, равном 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' используется в большинстве других языков и библиотек.
Если format — другой символ, Text возвращает "%" и следующий за ним нераспознанный символ формата.
Точность prec задаёт количество цифр (без учёта порядка), выводимых форматами 'e', 'E', 'f', 'g', 'G' и 'x'. Для 'e', 'E', 'f' и 'x' это количество цифр после десятичной точки. Для 'g' и 'G' это общее количество цифр. Отрицательная точность выбирает минимальное количество десятичных цифр, необходимое для однозначной идентификации значения x с использованием x.Prec() бит мантиссы. Значение prec игнорируется для форматов 'b' и 'p'.
Обратите внимание, что Text может возвращать результат, отличный от strconv.FormatFloat с соответствующими аргументами, если переданное в strconv.FormatFloat соответствующее число float32 или float64 является денормализованным.
func (*Float) Uint64 1.5
func (x *Float) Uint64() (uint64, Accuracy)
Uint64 возвращает беззнаковое целое число, полученное усечением x в сторону нуля. Если 0 <= x <= math.MaxUint64, результат является точным, если x — целое число, и меньшим в противном случае. Для 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 новое значение с помощью метода 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 добавляет в buf строковое представление x, сформированное методом x.Text(base), и возвращает расширенный буфер.
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, возвращая его абсолютное значение в виде среза Word в порядке от младшего байта к старшему. Результат и x используют один и тот же базовый массив. Bits предназначен для реализации недостающей низкоуровневой функциональности Int вне этого пакета; в остальных случаях его следует избегать.
func (*Int) Bytes
func (x *Int) Bytes() []byte
Bytes возвращает абсолютное значение x в виде среза байтов в порядке от старшего байта к младшему.
Для среза фиксированной длины или предварительно выделенного среза используйте 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.) Реализацию T-деления и взятия остатка (как в Go) см. в Int.QuoRem.
func (*Int) Divide 1.27
func (z *Int) Divide(x, y, r *Int, mode RoundingMode) (*Int, *Int)
Divide вычисляет целочисленное частное q и остаток r так, что
q = f(x/y) r = x - y*q
где f определяется режимом округления, которым должно быть одно из значений Trunc, Floor, Round или Ceil. Divide устанавливает z равным q, если z != nil, обновляет r, если r != nil, и возвращает пару (z, r) при y != 0. Если y == 0, возникает паника во время выполнения из-за деления на ноль.
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, записывая его в срез байтов с нулевым дополнением в порядке от старшего байта к младшему, и возвращает 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 при 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 псевдослучайно выбранными основаниями, а также тест Бейли — PSW.
Если x — простое число, ProbablyPrime возвращает true. Если x выбрано случайным образом и не является простым, ProbablyPrime, скорее всего, вернёт false. Вероятность возврата true для случайно выбранного составного числа не превышает ¼ⁿ.
ProbablyPrime абсолютно точен для входных значений меньше 2⁶⁴. Дополнительные сведения о вероятностях ошибок см. в Menezes et al., Handbook of Applied Cryptography, 1997, pp. 145-149, и FIPS 186-4 Appendix F.
ProbablyPrime не подходит для проверки простых чисел, которые злоумышленник мог специально подобрать, чтобы обмануть тест.
Начиная с Go 1.8 вызов ProbablyPrime(0) допустим и применяет только тест Бейли — PSW. До 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, «Division and Modulus for Computer Scientists».) Реализацию евклидова деления и взятия остатка (в отличие от Go) см. в Int.DivMod.
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-й бит установлен в 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, интерпретируемому как срез 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. При основании 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 — false. Знак 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 — false. Знак 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 единице.
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” считается начальным десятичным нулем и в этом случае не обозначает восьмеричную запись. Также можно указать необязательную экспоненту по основанию 10 “e” или по основанию 2 “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; погрешность округления описывается значением Accuracy для этого Float.
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/
