```
Source File
doc.go
Belonging Package
math/big
```

`// Copyright 2009 The Go Authors. All rights reserved.`

`// Use of this source code is governed by a BSD-style`

`// license that can be found in the LICENSE file.`

`/*`

`Package big implements arbitrary-precision arithmetic (big numbers).`

`The following numeric types are supported:`

`Int signed integers`

`Rat rational numbers`

`Float floating-point numbers`

`The zero value for an Int, Rat, or Float correspond to 0. Thus, new`

`values can be declared in the usual ways and denote 0 without further`

`initialization:`

`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`

`Alternatively, new values can be allocated and initialized with factory`

`functions of the form:`

`func NewT(v V) *T`

`For instance, NewInt(x) returns an *Int set to the value of the int64`

`argument x, NewRat(a, b) returns a *Rat set to the fraction a/b where`

`a and b are int64 values, and NewFloat(f) returns a *Float initialized`

`to the float64 argument f. More flexibility is provided with explicit`

`setters, for instance:`

`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`

`Setters, numeric operations and predicates are represented as methods of`

`the form:`

`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)`

`with T one of Int, Rat, or Float. For unary and binary operations, the`

`result is the receiver (usually named z in that case; see below); if it`

`is one of the operands x or y it may be safely overwritten (and its memory`

`reused).`

`Arithmetic expressions are typically written as a sequence of individual`

`method calls, with each call corresponding to an operation. The receiver`

`denotes the result and the method arguments are the operation's operands.`

`For instance, given three *Int values a, b and c, the invocation`

`c.Add(a, b)`

`computes the sum a + b and stores the result in c, overwriting whatever`

`value was held in c before. Unless specified otherwise, operations permit`

`aliasing of parameters, so it is perfectly ok to write`

`sum.Add(sum, x)`

`to accumulate values x in a sum.`

`(By always passing in a result value via the receiver, memory use can be`

`much better controlled. Instead of having to allocate new memory for each`

`result, an operation can reuse the space allocated for the result value,`

`and overwrite that value with the new result in the process.)`

`Notational convention: Incoming method parameters (including the receiver)`

`are named consistently in the API to clarify their use. Incoming operands`

`are usually named x, y, a, b, and so on, but never z. A parameter specifying`

`the result is named z (typically the receiver).`

`For instance, the arguments for (*Int).Add are named x and y, and because`

`the receiver specifies the result destination, it is called z:`

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

`Methods of this form typically return the incoming receiver as well, to`

`enable simple call chaining.`

`Methods which don't require a result value to be passed in (for instance,`

`Int.Sign), simply return the result. In this case, the receiver is typically`

`the first operand, named x:`

`func (x *Int) Sign() int`

`Various methods support conversions between strings and corresponding`

`numeric values, and vice versa: *Int, *Rat, and *Float values implement`

`the Stringer interface for a (default) string representation of the value,`

`but also provide SetString methods to initialize a value from a string in`

`a variety of supported formats (see the respective SetString documentation).`

`Finally, *Int, *Rat, and *Float satisfy the fmt package's Scanner interface`

`for scanning and (except for *Rat) the Formatter interface for formatted`

`printing.`

`*/`

`package big`

The pages are generated with Golds v0.2.5. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |