Google Git
Sign in
go/text/863dea0c5012ac1222058781721697b285f31f5f^!/.
commit
863dea0c5012ac1222058781721697b285f31f5f
[log]
author
Marcel van Lohuizen <mpvl@golang.org>
Wed Aug 23 13:47:58 2017 +0200
committer
Marcel van Lohuizen <mpvl@golang.org>
Fri Aug 25 06:53:00 2017 +0000
tree
6ccad9d7119f0724ade9ea98d107e6f98f26db4f
parent
b296a27a355dd1b0ad413ee28d36ca0f045c9334 [diff]
internal/number: introduce Digits

Digits are needed by pluralization.

add setScale, update, setPrecision

Change-Id: If7ac134e8371f232421e69c1abe58a52296b5948
Reviewed-on: https://go-review.googlesource.com/58550
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Nigel Tao <nigeltao@golang.org>

diff --git a/internal/number/decimal.go b/internal/number/decimal.go
index fd62310..7c28dc1 100644
--- a/internal/number/decimal.go
+++ b/internal/number/decimal.go

@@ -27,11 +27,37 @@
 
 const maxIntDigits = 20
 
-// A Decimal represents floating point number represented in digits of the base
-// in which a number is to be displayed. Digits represents a number [0, 1.0),
-// and the absolute value represented by Decimal is Digits * 10^Exp.
-// Leading and trailing zeros may be omitted and Exp may point outside a valid
-// position in Digits.
+// A Decimal represents a floating point number in decimal format.
+// Digits represents a number [0, 1.0), and the absolute value represented by
+// Decimal is Digits * 10^Exp. Leading and trailing zeros may be omitted and Exp
+// may point outside a valid position in Digits.
+//
+// Examples:
+//      Number     Decimal
+//      12345      Digits: [1, 2, 3, 4, 5], Exp: 5
+//      12.345     Digits: [1, 2, 3, 4, 5], Exp: 2
+//      12000      Digits: [1, 2],          Exp: 5
+//      12000.00   Digits: [1, 2],          Exp: 5
+//      0.00123    Digits: [1, 2, 3],       Exp: -2
+//      0          Digits: [],              Exp: 0
+type Decimal struct {
+	digits
+
+	buf [maxIntDigits]byte
+}
+
+type digits struct {
+	Digits []byte // mantissa digits, big-endian
+	Exp    int32  // exponent
+	Neg    bool
+	Inf    bool // Takes precedence over Digits and Exp.
+	NaN    bool // Takes precedence over Inf.
+}
+
+// Digits represents a floating point number represented in digits of the
+// base in which a number is to be displayed. It is similar to Decimal, but
+// keeps track of trailing fraction zeros and the comma placement for
+// engineering notation.
 //
 // Examples:
 //      Number     Decimal
@@ -47,20 +73,23 @@
 //      1.23e4     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 1
 //    engineering
 //      12.3e3     Digits: [1, 2, 3],       Exp: 5, End: 3, Comma: 2
-type Decimal struct {
-	Digits []byte // mantissa digits, big-endian
-	Exp    int32  // exponent
+type Digits struct {
+	digits
 	// End indicates the end position of the number.
 	End int32 // For decimals Exp <= End. For scientific len(Digits) <= End.
 	// Comma is used for the comma position for scientific (always 0 or 1) and
 	// engineering notation (always 0, 1, 2, or 3).
 	Comma uint8
+	// IsScientific indicates whether this number is to be rendered as a
+	// scientific number.
+	IsScientific bool
+}
 
-	Neg bool
-	Inf bool // Takes precedence over Digits and Exp.
-	NaN bool // Takes precedence over Inf.
-
-	buf [maxIntDigits]byte
+func (d *Digits) NumFracDigits() int {
+	if d.Exp >= d.End {
+		return 0
+	}
+	return int(d.End - d.Exp)
 }
 
 // normalize returns a new Decimal with leading and trailing zeros removed.
@@ -142,7 +171,7 @@
 	return buf
 }
 
-func (d *Decimal) round(mode RoundingMode, n int) {
+func (d *digits) round(mode RoundingMode, n int) {
 	if n >= len(d.Digits) {
 		return
 	}
@@ -218,7 +247,7 @@
 	return i
 }
 
-func (x *Decimal) roundUp(n int) {
+func (x *digits) roundUp(n int) {
 	if n < 0 || n >= len(x.Digits) {
 		return // nothing to do
 	}
@@ -239,7 +268,7 @@
 	// x already trimmed
 }
 
-func (x *Decimal) roundDown(n int) {
+func (x *digits) roundDown(n int) {
 	if n < 0 || n >= len(x.Digits) {
 		return // nothing to do
 	}
@@ -249,7 +278,7 @@
 
 // trim cuts off any trailing zeros from x's mantissa;
 // they are meaningless for the value of x.
-func trim(x *Decimal) {
+func trim(x *digits) {
 	i := len(x.Digits)
 	for i > 0 && x.Digits[i-1] == 0 {
 		i--

diff --git a/internal/number/decimal_test.go b/internal/number/decimal_test.go
index e21b8a3..11d7644 100644
--- a/internal/number/decimal_test.go
+++ b/internal/number/decimal_test.go

@@ -86,11 +86,11 @@
 		want string
 	}{
 		{want: "0"},
-		{Decimal{Digits: nil, Exp: 1000}, "0"}, // exponent of 1000 is ignored
-		{Decimal{Digits: byteNum("12345"), Exp: 0}, "0.12345"},
-		{Decimal{Digits: byteNum("12345"), Exp: -3}, "0.00012345"},
-		{Decimal{Digits: byteNum("12345"), Exp: +3}, "123.45"},
-		{Decimal{Digits: byteNum("12345"), Exp: +10}, "1234500000"},
+		{Decimal{digits: digits{Digits: nil, Exp: 1000}}, "0"}, // exponent of 1000 is ignored
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: 0}}, "0.12345"},
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: -3}}, "0.00012345"},
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: +3}}, "123.45"},
+		{Decimal{digits: digits{Digits: byteNum("12345"), Exp: +10}}, "1234500000"},
 	} {
 		if got := test.x.String(); got != test.want {
 			t.Errorf("%v == %q; want %q", test.x, got, test.want)

diff --git a/internal/number/format.go b/internal/number/format.go
index dd703a7..9c764dc 100755
--- a/internal/number/format.go
+++ b/internal/number/format.go

@@ -81,17 +81,29 @@
 
 func (f *Formatter) Append(dst []byte, x interface{}) []byte {
 	var d Decimal
-	d.Convert(&f.RoundingContext, x)
-	return f.Format(dst, &d)
+	r := &f.RoundingContext
+	d.Convert(r, x)
+	return f.Render(dst, FormatDigits(&d, r))
+}
+
+func FormatDigits(d *Decimal, r *RoundingContext) Digits {
+	if r.isScientific() {
+		return scientificVisibleDigits(r, d)
+	}
+	return decimalVisibleDigits(r, d)
 }
 
 func (f *Formatter) Format(dst []byte, d *Decimal) []byte {
+	return f.Render(dst, FormatDigits(d, &f.RoundingContext))
+}
+
+func (f *Formatter) Render(dst []byte, d Digits) []byte {
 	var result []byte
 	var postPrefix, preSuffix int
-	if f.isScientific() {
-		result, postPrefix, preSuffix = appendScientific(dst, f, d)
+	if d.IsScientific {
+		result, postPrefix, preSuffix = appendScientific(dst, f, &d)
 	} else {
-		result, postPrefix, preSuffix = appendDecimal(dst, f, d)
+		result, postPrefix, preSuffix = appendDecimal(dst, f, &d)
 	}
 	if f.PadRune == 0 {
 		return result
@@ -130,12 +142,12 @@
 	return result
 }
 
-// TODO: just return visible digits.
-func decimalVisibleDigits(r *RoundingContext, d *Decimal) Decimal {
+func decimalVisibleDigits(r *RoundingContext, d *Decimal) Digits {
 	if d.NaN || d.Inf {
-		return *d
+		return Digits{digits: digits{Neg: d.Neg, NaN: d.NaN, Inf: d.Inf}}
 	}
-	n := d.normalize()
+	n := Digits{digits: d.normalize().digits}
+
 	if maxSig := int(r.MaxSignificantDigits); maxSig > 0 {
 		// TODO: really round to zero?
 		n.round(ToZero, maxSig)
@@ -199,11 +211,10 @@
 
 // appendDecimal appends a formatted number to dst. It returns two possible
 // insertion points for padding.
-func appendDecimal(dst []byte, f *Formatter, d *Decimal) (b []byte, postPre, preSuf int) {
-	if dst, ok := f.renderSpecial(dst, d); ok {
+func appendDecimal(dst []byte, f *Formatter, n *Digits) (b []byte, postPre, preSuf int) {
+	if dst, ok := f.renderSpecial(dst, n); ok {
 		return dst, 0, len(dst)
 	}
-	n := decimalVisibleDigits(&f.RoundingContext, d)
 	digits := n.Digits
 	exp := n.Exp
 
@@ -223,7 +234,7 @@
 		fracDigits = digits
 	}
 
-	neg := d.Neg
+	neg := n.Neg
 	affix, suffix := f.getAffixes(neg)
 	dst = appendAffix(dst, f, affix, neg)
 	savedLen := len(dst)
@@ -256,7 +267,7 @@
 	if numFrac > 0 || f.Flags&AlwaysDecimalSeparator != 0 {
 		dst = append(dst, f.Symbol(SymDecimal)...)
 	}
-	// Add leading zeros
+	// Add trailing zeros
 	i = 0
 	for n := -int(n.Exp); i < n; i++ {
 		dst = f.AppendDigit(dst, 0)
@@ -271,11 +282,11 @@
 	return appendAffix(dst, f, suffix, neg), savedLen, len(dst)
 }
 
-func scientificVisibleDigits(r *RoundingContext, d *Decimal) Decimal {
+func scientificVisibleDigits(r *RoundingContext, d *Decimal) Digits {
 	if d.NaN || d.Inf {
-		return *d
+		return Digits{digits: digits{Neg: d.Neg, NaN: d.NaN, Inf: d.Inf}}
 	}
-	n := d.normalize()
+	n := Digits{digits: d.normalize().digits, IsScientific: true}
 
 	// Significant digits are transformed by the parser for scientific notation
 	// and do not need to be handled here.
@@ -326,12 +337,10 @@
 
 // appendScientific appends a formatted number to dst. It returns two possible
 // insertion points for padding.
-func appendScientific(dst []byte, f *Formatter, d *Decimal) (b []byte, postPre, preSuf int) {
-	if dst, ok := f.renderSpecial(dst, d); ok {
+func appendScientific(dst []byte, f *Formatter, n *Digits) (b []byte, postPre, preSuf int) {
+	if dst, ok := f.renderSpecial(dst, n); ok {
 		return dst, 0, 0
 	}
-	// n := d.normalize()
-	n := scientificVisibleDigits(&f.RoundingContext, d)
 	digits := n.Digits
 	exp := n.Exp
 	numInt := int(n.Comma)
@@ -344,7 +353,7 @@
 	} else {
 		intDigits = digits
 	}
-	neg := d.Neg
+	neg := n.Neg
 	affix, suffix := f.getAffixes(neg)
 	dst = appendAffix(dst, f, affix, neg)
 	savedLen := len(dst)
@@ -462,7 +471,7 @@
 	return affix, suffix
 }
 
-func (f *Formatter) renderSpecial(dst []byte, d *Decimal) (b []byte, ok bool) {
+func (f *Formatter) renderSpecial(dst []byte, d *Digits) (b []byte, ok bool) {
 	if d.NaN {
 		return fmtNaN(dst, f), true
 	}
@@ -476,7 +485,7 @@
 	return append(dst, f.Symbol(SymNan)...)
 }
 
-func fmtInfinite(dst []byte, f *Formatter, d *Decimal) []byte {
+func fmtInfinite(dst []byte, f *Formatter, d *Digits) []byte {
 	affix, suffix := f.getAffixes(d.Neg)
 	dst = appendAffix(dst, f, affix, d.Neg)
 	dst = append(dst, f.Symbol(SymInfinity)...)

diff --git a/internal/number/format_test.go b/internal/number/format_test.go
index d7295e0..c56cbc1 100755
--- a/internal/number/format_test.go
+++ b/internal/number/format_test.go

@@ -449,11 +449,12 @@
 		}
 		var f Formatter
 		f.InitPattern(language.English, pat)
-		for dec, want := range tc.test {
+		for num, want := range tc.test {
 			buf := make([]byte, 100)
-			t.Run(tc.pattern+"/"+dec, func(t *testing.T) {
-				dec := mkdec(dec)
-				buf = f.Format(buf[:0], &dec)
+			t.Run(tc.pattern+"/"+num, func(t *testing.T) {
+				var d Decimal
+				d.Convert(&f.RoundingContext, dec(num))
+				buf = f.Format(buf[:0], &d)
 				if got := string(buf); got != want {
 					t.Errorf("\n got %[1]q (%[1]s)\nwant %[2]q (%[2]s)", got, want)
 				}
@@ -478,7 +479,8 @@
 		t.Run(fmt.Sprint(tc.tag, "/", tc.num), func(t *testing.T) {
 			var f Formatter
 			f.InitDecimal(tc.tag)
-			d := mkdec(tc.num)
+			var d Decimal
+			d.Convert(&f.RoundingContext, dec(tc.num))
 			b := f.Format(nil, &d)
 			if got := string(b); got != tc.want {
 				t.Errorf("got %[1]q (%[1]s); want %[2]q (%[2]s)", got, tc.want)
@@ -504,9 +506,9 @@
 	for i, tc := range testCases {
 		t.Run(fmt.Sprint(i, "/", tc.num), func(t *testing.T) {
 			tc.init(language.English)
-			f.Pattern.MinFractionDigits = 2
-			f.Pattern.MaxFractionDigits = 2
-			d := mkdec(tc.num)
+			f.SetScale(2)
+			var d Decimal
+			d.Convert(&f.RoundingContext, dec(tc.num))
 			b := f.Format(nil, &d)
 			if got := string(b); got != tc.want {
 				t.Errorf("got %[1]q (%[1]s); want %[2]q (%[2]s)", got, tc.want)

diff --git a/internal/number/pattern.go b/internal/number/pattern.go
index 8a3f595..881308e 100644
--- a/internal/number/pattern.go
+++ b/internal/number/pattern.go

@@ -60,14 +60,14 @@
 // It contains all information needed to determine the "visible digits" as
 // required by the pluralization rules.
 type RoundingContext struct {
-	Mode RoundingMode
-
 	Precision int32 // maximum number of significant digits.
 	Scale     int32 // maximum number of decimals after the dot.
 
 	// if > 0, round to Increment * 10^-Scale
 	Increment uint32 // Use Min*Digits to determine scale
 
+	Mode RoundingMode
+
 	DigitShift uint8 // Number of decimals to shift. Used for % and ‰.
 
 	// Number of digits.
@@ -82,6 +82,25 @@
 	MinExponentDigits uint8
 }
 
+func (r *RoundingContext) update() {
+	if r.Scale > 0 {
+		r.SetScale(int(r.Scale))
+	}
+	if r.Precision > 0 {
+		r.SetPrecision(int(r.Precision))
+	}
+}
+
+// SetScale fixes the RoundingContext to a fixed number of fraction digits.
+func (r *RoundingContext) SetScale(scale int) {
+	r.MinFractionDigits = uint8(scale)
+	r.MaxFractionDigits = uint8(scale)
+}
+
+func (r *RoundingContext) SetPrecision(prec int) {
+	r.MaxSignificantDigits = uint8(prec)
+}
+
 func (r *RoundingContext) isScientific() bool {
 	return r.MinExponentDigits > 0
 }