mirror of
https://github.com/golang/go
synced 2024-11-13 17:30:24 -07:00
- lowercase non-exported functions in bignum
R=r DELTA=117 (1 added, 0 deleted, 116 changed) OCL=22764 CL=22863
This commit is contained in:
Robert Griesemer
parent
aa1264472e
commit
364a852027
@ -11,7 +11,8 @@ package bignum
|
||||
// - Integer signed integer numbers
|
||||
// - Rational rational numbers
|
||||
|
||||
import Fmt "fmt"
|
||||
import "fmt"
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Internal representation
|
||||
@ -51,27 +52,27 @@ import Fmt "fmt"
|
||||
// results are packed again. For faster unpacking/packing, the base size
|
||||
// in bits must be even.
|
||||
|
||||
type (
|
||||
export type (
|
||||
Digit uint64;
|
||||
Digit2 uint32; // half-digits for division
|
||||
)
|
||||
|
||||
|
||||
const LogW = 64;
|
||||
const LogH = 4; // bits for a hex digit (= "small" number)
|
||||
const LogB = LogW - LogH; // largest bit-width available
|
||||
const _LogW = 64;
|
||||
const _LogH = 4; // bits for a hex digit (= "small" number)
|
||||
const _LogB = _LogW - _LogH; // largest bit-width available
|
||||
|
||||
|
||||
const (
|
||||
// half-digits
|
||||
W2 = LogB / 2; // width
|
||||
B2 = 1 << W2; // base
|
||||
M2 = B2 - 1; // mask
|
||||
_W2 = _LogB / 2; // width
|
||||
_B2 = 1 << _W2; // base
|
||||
_M2 = _B2 - 1; // mask
|
||||
|
||||
// full digits
|
||||
W = W2 * 2; // width
|
||||
B = 1 << W; // base
|
||||
M = B - 1; // mask
|
||||
_W = _W2 * 2; // width
|
||||
_B = 1 << _W; // base
|
||||
_M = _B - 1; // mask
|
||||
)
|
||||
|
||||
|
||||
@ -86,7 +87,7 @@ func assert(p bool) {
|
||||
|
||||
|
||||
func IsSmall(x Digit) bool {
|
||||
return x < 1<<LogH;
|
||||
return x < 1<<_LogH;
|
||||
}
|
||||
|
||||
|
||||
@ -129,7 +130,7 @@ export func Nat(x uint) Natural {
|
||||
case 2: return NatTwo;
|
||||
case 10: return NatTen;
|
||||
}
|
||||
assert(Digit(x) < B);
|
||||
assert(Digit(x) < _B);
|
||||
return Natural{Digit(x)};
|
||||
}
|
||||
|
||||
@ -148,7 +149,7 @@ func (x Natural) IsZero() bool {
|
||||
|
||||
// Operations
|
||||
|
||||
func Normalize(x Natural) Natural {
|
||||
func normalize(x Natural) Natural {
|
||||
n := len(x);
|
||||
for n > 0 && x[n - 1] == 0 { n-- }
|
||||
if n < len(x) {
|
||||
@ -170,12 +171,12 @@ func (x Natural) Add(y Natural) Natural {
|
||||
i := 0;
|
||||
for i < m {
|
||||
t := c + x[i] + y[i];
|
||||
c, z[i] = t>>W, t&M;
|
||||
c, z[i] = t>>_W, t&_M;
|
||||
i++;
|
||||
}
|
||||
for i < n {
|
||||
t := c + x[i];
|
||||
c, z[i] = t>>W, t&M;
|
||||
c, z[i] = t>>_W, t&_M;
|
||||
i++;
|
||||
}
|
||||
if c != 0 {
|
||||
@ -199,12 +200,12 @@ func (x Natural) Sub(y Natural) Natural {
|
||||
i := 0;
|
||||
for i < m {
|
||||
t := c + x[i] - y[i];
|
||||
c, z[i] = Digit(int64(t)>>W), t&M; // requires arithmetic shift!
|
||||
c, z[i] = Digit(int64(t)>>_W), t&_M; // requires arithmetic shift!
|
||||
i++;
|
||||
}
|
||||
for i < n {
|
||||
t := c + x[i];
|
||||
c, z[i] = Digit(int64(t)>>W), t&M; // requires arithmetic shift!
|
||||
c, z[i] = Digit(int64(t)>>_W), t&_M; // requires arithmetic shift!
|
||||
i++;
|
||||
}
|
||||
for i > 0 && z[i - 1] == 0 { // normalize
|
||||
@ -216,7 +217,7 @@ func (x Natural) Sub(y Natural) Natural {
|
||||
|
||||
|
||||
// Returns c = x*y div B, z = x*y mod B.
|
||||
func Mul11(x, y Digit) (Digit, Digit) {
|
||||
func mul11(x, y Digit) (Digit, Digit) {
|
||||
// Split x and y into 2 sub-digits each,
|
||||
// multiply the digits separately while avoiding overflow,
|
||||
// and return the product as two separate digits.
|
||||
@ -224,10 +225,10 @@ func Mul11(x, y Digit) (Digit, Digit) {
|
||||
// This code also works for non-even bit widths W
|
||||
// which is why there are separate constants below
|
||||
// for half-digits.
|
||||
const W2 = (W + 1)/2;
|
||||
const DW = W2*2 - W; // 0 or 1
|
||||
const W2 = (_W + 1)/2;
|
||||
const DW = W2*2 - _W; // 0 or 1
|
||||
const B2 = 1<<W2;
|
||||
const M2 = B2 - 1;
|
||||
const M2 = _B2 - 1;
|
||||
|
||||
// split x and y into sub-digits
|
||||
// x = (x1*B2 + x0)
|
||||
@ -242,8 +243,8 @@ func Mul11(x, y Digit) (Digit, Digit) {
|
||||
|
||||
// compute the result digits but avoid overflow
|
||||
// z = z1*B + z0 = x*y
|
||||
z0 := (t1<<W2 + t0)&M;
|
||||
z1 := t2<<DW + (t1 + t0>>W2)>>(W-W2);
|
||||
z0 := (t1<<W2 + t0)&_M;
|
||||
z1 := t2<<DW + (t1 + t0>>W2)>>(_W-W2);
|
||||
|
||||
return z1, z0;
|
||||
}
|
||||
@ -260,16 +261,16 @@ func (x Natural) Mul(y Natural) Natural {
|
||||
c := Digit(0);
|
||||
for i := 0; i < n; i++ {
|
||||
// z[i+j] += c + x[i]*d;
|
||||
z1, z0 := Mul11(x[i], d);
|
||||
z1, z0 := mul11(x[i], d);
|
||||
t := c + z[i+j] + z0;
|
||||
c, z[i+j] = t>>W, t&M;
|
||||
c, z[i+j] = t>>_W, t&_M;
|
||||
c += z1;
|
||||
}
|
||||
z[n+j] = c;
|
||||
}
|
||||
}
|
||||
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
@ -278,13 +279,13 @@ func (x Natural) Mul(y Natural) Natural {
|
||||
// into operands with twice as many digits of half the size (Digit2), do
|
||||
// DivMod, and then pack the results again.
|
||||
|
||||
func Unpack(x Natural) []Digit2 {
|
||||
func unpack(x Natural) []Digit2 {
|
||||
n := len(x);
|
||||
z := make([]Digit2, n*2 + 1); // add space for extra digit (used by DivMod)
|
||||
for i := 0; i < n; i++ {
|
||||
t := x[i];
|
||||
z[i*2] = Digit2(t & M2);
|
||||
z[i*2 + 1] = Digit2(t >> W2 & M2);
|
||||
z[i*2] = Digit2(t & _M2);
|
||||
z[i*2 + 1] = Digit2(t >> _W2 & _M2);
|
||||
}
|
||||
|
||||
// normalize result
|
||||
@ -294,7 +295,7 @@ func Unpack(x Natural) []Digit2 {
|
||||
}
|
||||
|
||||
|
||||
func Pack(x []Digit2) Natural {
|
||||
func pack(x []Digit2) Natural {
|
||||
n := (len(x) + 1) / 2;
|
||||
z := make(Natural, n);
|
||||
if len(x) & 1 == 1 {
|
||||
@ -303,37 +304,37 @@ func Pack(x []Digit2) Natural {
|
||||
z[n] = Digit(x[n*2]);
|
||||
}
|
||||
for i := 0; i < n; i++ {
|
||||
z[i] = Digit(x[i*2 + 1]) << W2 | Digit(x[i*2]);
|
||||
z[i] = Digit(x[i*2 + 1]) << _W2 | Digit(x[i*2]);
|
||||
}
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
func Mul1(z, x []Digit2, y Digit2) Digit2 {
|
||||
func mul1(z, x []Digit2, y Digit2) Digit2 {
|
||||
n := len(x);
|
||||
c := Digit(0);
|
||||
f := Digit(y);
|
||||
for i := 0; i < n; i++ {
|
||||
t := c + Digit(x[i])*f;
|
||||
c, z[i] = t>>W2, Digit2(t&M2);
|
||||
c, z[i] = t>>_W2, Digit2(t&_M2);
|
||||
}
|
||||
return Digit2(c);
|
||||
}
|
||||
|
||||
|
||||
func Div1(z, x []Digit2, y Digit2) Digit2 {
|
||||
func div1(z, x []Digit2, y Digit2) Digit2 {
|
||||
n := len(x);
|
||||
c := Digit(0);
|
||||
d := Digit(y);
|
||||
for i := n-1; i >= 0; i-- {
|
||||
t := c*B2 + Digit(x[i]);
|
||||
t := c*_B2 + Digit(x[i]);
|
||||
c, z[i] = t%d, Digit2(t/d);
|
||||
}
|
||||
return Digit2(c);
|
||||
}
|
||||
|
||||
|
||||
// DivMod returns q and r with x = y*q + r and 0 <= r < y.
|
||||
// divmod returns q and r with x = y*q + r and 0 <= r < y.
|
||||
// x and y are destroyed in the process.
|
||||
//
|
||||
// The algorithm used here is based on 1). 2) describes the same algorithm
|
||||
@ -353,7 +354,7 @@ func Div1(z, x []Digit2, y Digit2) Digit2 {
|
||||
// minefield. "Software - Practice and Experience 24", (June 1994),
|
||||
// 579-601. John Wiley & Sons, Ltd.
|
||||
|
||||
func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
func divmod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
n := len(x);
|
||||
m := len(y);
|
||||
if m == 0 {
|
||||
@ -366,7 +367,7 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
if m == 1 {
|
||||
// division by single digit
|
||||
// result is shifted left by 1 in place!
|
||||
x[0] = Div1(x[1 : n+1], x[0 : n], y[0]);
|
||||
x[0] = div1(x[1 : n+1], x[0 : n], y[0]);
|
||||
|
||||
} else if m > n {
|
||||
// y > x => quotient = 0, remainder = x
|
||||
@ -381,15 +382,15 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
// TODO Instead of multiplying, it would be sufficient to
|
||||
// shift y such that the normalization condition is
|
||||
// satisfied (as done in "Hacker's Delight").
|
||||
f := B2 / (Digit(y[m-1]) + 1);
|
||||
f := _B2 / (Digit(y[m-1]) + 1);
|
||||
if f != 1 {
|
||||
Mul1(x, x, Digit2(f));
|
||||
Mul1(y, y, Digit2(f));
|
||||
mul1(x, x, Digit2(f));
|
||||
mul1(y, y, Digit2(f));
|
||||
}
|
||||
assert(B2/2 <= y[m-1] && y[m-1] < B2); // incorrect scaling
|
||||
assert(_B2/2 <= y[m-1] && y[m-1] < _B2); // incorrect scaling
|
||||
|
||||
y1, y2 := Digit(y[m-1]), Digit(y[m-2]);
|
||||
d2 := Digit(y1)<<W2 + Digit(y2);
|
||||
d2 := Digit(y1)<<_W2 + Digit(y2);
|
||||
for i := n-m; i >= 0; i-- {
|
||||
k := i+m;
|
||||
|
||||
@ -397,11 +398,11 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
var q Digit;
|
||||
{ x0, x1, x2 := Digit(x[k]), Digit(x[k-1]), Digit(x[k-2]);
|
||||
if x0 != y1 {
|
||||
q = (x0<<W2 + x1)/y1;
|
||||
q = (x0<<_W2 + x1)/y1;
|
||||
} else {
|
||||
q = B2 - 1;
|
||||
q = _B2 - 1;
|
||||
}
|
||||
for y2*q > (x0<<W2 + x1 - y1*q)<<W2 + x2 {
|
||||
for y2*q > (x0<<_W2 + x1 - y1*q)<<_W2 + x2 {
|
||||
q--
|
||||
}
|
||||
}
|
||||
@ -410,7 +411,7 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
c := Digit(0);
|
||||
for j := 0; j < m; j++ {
|
||||
t := c + Digit(x[i+j]) - Digit(y[j])*q;
|
||||
c, x[i+j] = Digit(int64(t)>>W2), Digit2(t&M2); // requires arithmetic shift!
|
||||
c, x[i+j] = Digit(int64(t) >> _W2), Digit2(t & _M2); // requires arithmetic shift!
|
||||
}
|
||||
|
||||
// correct if trial digit was too large
|
||||
@ -419,7 +420,7 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
c := Digit(0);
|
||||
for j := 0; j < m; j++ {
|
||||
t := c + Digit(x[i+j]) + Digit(y[j]);
|
||||
c, x[i+j] = t >> W2, Digit2(t & M2)
|
||||
c, x[i+j] = t >> _W2, Digit2(t & _M2)
|
||||
}
|
||||
assert(c + Digit(x[k]) == 0);
|
||||
// correct trial digit
|
||||
@ -431,7 +432,7 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
|
||||
// undo normalization for remainder
|
||||
if f != 1 {
|
||||
c := Div1(x[0 : m], x[0 : m], Digit2(f));
|
||||
c := div1(x[0 : m], x[0 : m], Digit2(f));
|
||||
assert(c == 0);
|
||||
}
|
||||
}
|
||||
@ -441,29 +442,29 @@ func DivMod(x, y []Digit2) ([]Digit2, []Digit2) {
|
||||
|
||||
|
||||
func (x Natural) Div(y Natural) Natural {
|
||||
q, r := DivMod(Unpack(x), Unpack(y));
|
||||
return Pack(q);
|
||||
q, r := divmod(unpack(x), unpack(y));
|
||||
return pack(q);
|
||||
}
|
||||
|
||||
|
||||
func (x Natural) Mod(y Natural) Natural {
|
||||
q, r := DivMod(Unpack(x), Unpack(y));
|
||||
return Pack(r);
|
||||
q, r := divmod(unpack(x), unpack(y));
|
||||
return pack(r);
|
||||
}
|
||||
|
||||
|
||||
func (x Natural) DivMod(y Natural) (Natural, Natural) {
|
||||
q, r := DivMod(Unpack(x), Unpack(y));
|
||||
return Pack(q), Pack(r);
|
||||
q, r := divmod(unpack(x), unpack(y));
|
||||
return pack(q), pack(r);
|
||||
}
|
||||
|
||||
|
||||
func Shl(z, x []Digit, s uint) Digit {
|
||||
assert(s <= W);
|
||||
func shl(z, x []Digit, s uint) Digit {
|
||||
assert(s <= _W);
|
||||
n := len(x);
|
||||
c := Digit(0);
|
||||
for i := 0; i < n; i++ {
|
||||
c, z[i] = x[i] >> (W-s), x[i] << s & M | c;
|
||||
c, z[i] = x[i] >> (_W-s), x[i] << s & _M | c;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
@ -471,21 +472,21 @@ func Shl(z, x []Digit, s uint) Digit {
|
||||
|
||||
func (x Natural) Shl(s uint) Natural {
|
||||
n := uint(len(x));
|
||||
m := n + s/W;
|
||||
m := n + s/_W;
|
||||
z := make(Natural, m+1);
|
||||
|
||||
z[m] = Shl(z[m-n : m], x, s%W);
|
||||
z[m] = shl(z[m-n : m], x, s%_W);
|
||||
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
func Shr(z, x []Digit, s uint) Digit {
|
||||
assert(s <= W);
|
||||
func shr(z, x []Digit, s uint) Digit {
|
||||
assert(s <= _W);
|
||||
n := len(x);
|
||||
c := Digit(0);
|
||||
for i := n - 1; i >= 0; i-- {
|
||||
c, z[i] = x[i] << (W-s) & M, x[i] >> s | c;
|
||||
c, z[i] = x[i] << (_W-s) & _M, x[i] >> s | c;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
@ -493,15 +494,15 @@ func Shr(z, x []Digit, s uint) Digit {
|
||||
|
||||
func (x Natural) Shr(s uint) Natural {
|
||||
n := uint(len(x));
|
||||
m := n - s/W;
|
||||
m := n - s/_W;
|
||||
if m > n { // check for underflow
|
||||
m = 0;
|
||||
}
|
||||
z := make(Natural, m);
|
||||
|
||||
Shr(z, x[n-m : n], s%W);
|
||||
shr(z, x[n-m : n], s%_W);
|
||||
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
@ -518,11 +519,11 @@ func (x Natural) And(y Natural) Natural {
|
||||
}
|
||||
// upper bits are 0
|
||||
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
func Copy(z, x []Digit) {
|
||||
func copy(z, x []Digit) {
|
||||
for i, e := range x {
|
||||
z[i] = e
|
||||
}
|
||||
@ -540,7 +541,7 @@ func (x Natural) Or(y Natural) Natural {
|
||||
for i := 0; i < m; i++ {
|
||||
z[i] = x[i] | y[i];
|
||||
}
|
||||
Copy(z[m : n], x[m : n]);
|
||||
copy(z[m : n], x[m : n]);
|
||||
|
||||
return z;
|
||||
}
|
||||
@ -557,9 +558,9 @@ func (x Natural) Xor(y Natural) Natural {
|
||||
for i := 0; i < m; i++ {
|
||||
z[i] = x[i] ^ y[i];
|
||||
}
|
||||
Copy(z[m : n], x[m : n]);
|
||||
copy(z[m : n], x[m : n]);
|
||||
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
@ -584,7 +585,7 @@ func (x Natural) Cmp(y Natural) int {
|
||||
}
|
||||
|
||||
|
||||
func Log2(x Digit) uint {
|
||||
func log2(x Digit) uint {
|
||||
assert(x > 0);
|
||||
n := uint(0);
|
||||
for x > 0 {
|
||||
@ -598,7 +599,7 @@ func Log2(x Digit) uint {
|
||||
func (x Natural) Log2() uint {
|
||||
n := len(x);
|
||||
if n > 0 {
|
||||
return (uint(n) - 1)*W + Log2(x[n - 1]);
|
||||
return (uint(n) - 1)*_W + log2(x[n - 1]);
|
||||
}
|
||||
panic("Log2(0)");
|
||||
}
|
||||
@ -606,16 +607,16 @@ func (x Natural) Log2() uint {
|
||||
|
||||
// Computes x = x div d in place (modifies x) for "small" d's.
|
||||
// Returns updated x and x mod d.
|
||||
func DivMod1(x Natural, d Digit) (Natural, Digit) {
|
||||
func divmod1(x Natural, d Digit) (Natural, Digit) {
|
||||
assert(0 < d && IsSmall(d - 1));
|
||||
|
||||
c := Digit(0);
|
||||
for i := len(x) - 1; i >= 0; i-- {
|
||||
t := c<<W + x[i];
|
||||
t := c<<_W + x[i];
|
||||
c, x[i] = t%d, t/d;
|
||||
}
|
||||
|
||||
return Normalize(x), c;
|
||||
return normalize(x), c;
|
||||
}
|
||||
|
||||
|
||||
@ -626,19 +627,19 @@ func (x Natural) ToString(base uint) string {
|
||||
|
||||
// allocate buffer for conversion
|
||||
assert(2 <= base && base <= 16);
|
||||
n := (x.Log2() + 1) / Log2(Digit(base)) + 1; // +1: round up
|
||||
n := (x.Log2() + 1) / log2(Digit(base)) + 1; // +1: round up
|
||||
s := make([]byte, n);
|
||||
|
||||
// don't destroy x
|
||||
t := make(Natural, len(x));
|
||||
Copy(t, x);
|
||||
copy(t, x);
|
||||
|
||||
// convert
|
||||
i := n;
|
||||
for !t.IsZero() {
|
||||
i--;
|
||||
var d Digit;
|
||||
t, d = DivMod1(t, Digit(base));
|
||||
t, d = divmod1(t, Digit(base));
|
||||
s[i] = "0123456789abcdef"[d];
|
||||
};
|
||||
|
||||
@ -651,7 +652,7 @@ func (x Natural) String() string {
|
||||
}
|
||||
|
||||
|
||||
func FmtBase(c int) uint {
|
||||
func fmtbase(c int) uint {
|
||||
switch c {
|
||||
case 'b': return 2;
|
||||
case 'o': return 8;
|
||||
@ -661,13 +662,13 @@ func FmtBase(c int) uint {
|
||||
}
|
||||
|
||||
|
||||
func (x Natural) Format(h Fmt.Formatter, c int) {
|
||||
Fmt.Fprintf(h, "%s", x.ToString(FmtBase(c)));
|
||||
func (x Natural) Format(h fmt.Formatter, c int) {
|
||||
fmt.Fprintf(h, "%s", x.ToString(fmtbase(c)));
|
||||
}
|
||||
|
||||
|
||||
func HexValue(ch byte) uint {
|
||||
d := uint(1 << LogH);
|
||||
func hexvalue(ch byte) uint {
|
||||
d := uint(1 << _LogH);
|
||||
switch {
|
||||
case '0' <= ch && ch <= '9': d = uint(ch - '0');
|
||||
case 'a' <= ch && ch <= 'f': d = uint(ch - 'a') + 10;
|
||||
@ -685,11 +686,11 @@ func MulAdd1(x Natural, d, c Digit) Natural {
|
||||
|
||||
for i := 0; i < n; i++ {
|
||||
t := c + x[i]*d;
|
||||
c, z[i] = t>>W, t&M;
|
||||
c, z[i] = t>>_W, t&_M;
|
||||
}
|
||||
z[n] = c;
|
||||
|
||||
return Normalize(z);
|
||||
return normalize(z);
|
||||
}
|
||||
|
||||
|
||||
@ -713,7 +714,7 @@ export func NatFromString(s string, base uint, slen *int) (Natural, uint) {
|
||||
assert(2 <= base && base <= 16);
|
||||
x := Nat(0);
|
||||
for ; i < n; i++ {
|
||||
d := HexValue(s[i]);
|
||||
d := hexvalue(s[i]);
|
||||
if d < base {
|
||||
x = MulAdd1(x, Digit(base), Digit(d));
|
||||
} else {
|
||||
@ -732,7 +733,7 @@ export func NatFromString(s string, base uint, slen *int) (Natural, uint) {
|
||||
|
||||
// Natural number functions
|
||||
|
||||
func Pop1(x Digit) uint {
|
||||
func pop1(x Digit) uint {
|
||||
n := uint(0);
|
||||
for x != 0 {
|
||||
x &= x-1;
|
||||
@ -745,7 +746,7 @@ func Pop1(x Digit) uint {
|
||||
func (x Natural) Pop() uint {
|
||||
n := uint(0);
|
||||
for i := len(x) - 1; i >= 0; i-- {
|
||||
n += Pop1(x[i]);
|
||||
n += pop1(x[i]);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
@ -1095,8 +1096,8 @@ func (x *Integer) String() string {
|
||||
}
|
||||
|
||||
|
||||
func (x *Integer) Format(h Fmt.Formatter, c int) {
|
||||
Fmt.Fprintf(h, "%s", x.ToString(FmtBase(c)));
|
||||
func (x *Integer) Format(h fmt.Formatter, c int) {
|
||||
fmt.Fprintf(h, "%s", x.ToString(fmtbase(c)));
|
||||
}
|
||||
|
||||
|
||||
@ -1225,8 +1226,8 @@ func (x *Rational) String() string {
|
||||
}
|
||||
|
||||
|
||||
func (x *Rational) Format(h Fmt.Formatter, c int) {
|
||||
Fmt.Fprintf(h, "%s", x.ToString(FmtBase(c)));
|
||||
func (x *Rational) Format(h fmt.Formatter, c int) {
|
||||
fmt.Fprintf(h, "%s", x.ToString(fmtbase(c)));
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user