```add Dec.Round()
```
```diff --git a/dec/dec.go b/dec/dec.go
index b6d03a5..e14bf5c 100644
--- a/dec/dec.go
+++ b/dec/dec.go
```
```@@ -72,7 +72,8 @@
}

// Rounder represents a method for rounding the (possibly infinite decimal)
-// result of a division to a finite Dec. It is used by Quo().
+// result of a division to a finite Dec. It is used by Dec.Round() and
+// Dec.Quo().
//
type Rounder interface {

@@ -228,6 +229,12 @@
return z
}

+// Round sets z to the value of x rounded to Scale s using Rounder r, and
+// returns z.
+func (z *Dec) Round(x *Dec, s Scale, r Rounder) *Dec {
+	return z.Quo(x, NewDecInt64(1), s, r)
+}
+
// Quo sets z to the quotient x/y, with the scale obtained from the given
// Scaler, rounded using the given Rounder.
// If the result from the rounder is nil, Quo also returns nil, and the value
```
```diff --git a/dec/dec_test.go b/dec/dec_test.go
index 5a2c475..8d5036d 100644
--- a/dec/dec_test.go
+++ b/dec/dec_test.go
```
```@@ -132,7 +132,7 @@
}
}

-var rounderInputs = [...]struct {
+var decRounderInputs = [...]struct {
quo    *Dec
rA, rB *big.Int
}{
@@ -157,9 +157,9 @@
{NewDec(big.NewInt(1), 1), big.NewInt(8), big.NewInt(10)},
}

-var rounderResults = [...]struct {
+var decRounderResults = [...]struct {
rounder Rounder
-	results [len(rounderInputs)]*Dec
+	results [len(decRounderInputs)]*Dec
}{
{RoundExact, [...]*Dec{nil, nil, nil, nil,
nil, nil, nil, nil, nil, nil,
@@ -208,9 +208,9 @@
NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1), NewDec(big.NewInt(2), 1)}},
}

-func TestRound(t *testing.T) {
-	for i, a := range rounderResults {
-		for j, input := range rounderInputs {
+func TestDecRounders(t *testing.T) {
+	for i, a := range decRounderResults {
+		for j, input := range decRounderInputs {
q := new(Dec).Set(input.quo)
rA, rB := new(big.Int).Set(input.rA), new(big.Int).Set(input.rB)
res := a.rounder.Round(new(Dec), q, rA, rB)
@@ -226,6 +226,33 @@
}
}

+var decRoundTests = [...]struct {
+	in  *Dec
+	s   Scale
+	r   Rounder
+	exp *Dec
+}{
+	{NewDec(big.NewInt(123424999999999993), 15), 2, RoundHalfUp, NewDec(big.NewInt(12342), 2)},
+	{NewDec(big.NewInt(123425000000000001), 15), 2, RoundHalfUp, NewDec(big.NewInt(12343), 2)},
+	{NewDec(big.NewInt(123424999999999993), 15), 15, RoundHalfUp, NewDec(big.NewInt(123424999999999993), 15)},
+	{NewDec(big.NewInt(123424999999999993), 15), 16, RoundHalfUp, NewDec(big.NewInt(1234249999999999930), 16)},
+	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -1, RoundHalfUp, NewDec(big.NewInt(1844674407370955162), -1)},
+	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -2, RoundHalfUp, NewDec(big.NewInt(184467440737095516), -2)},
+	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -3, RoundHalfUp, NewDec(big.NewInt(18446744073709552), -3)},
+	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -4, RoundHalfUp, NewDec(big.NewInt(1844674407370955), -4)},
+	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -5, RoundHalfUp, NewDec(big.NewInt(184467440737096), -5)},
+	{NewDec(new(big.Int).Lsh(big.NewInt(1), 64), 0), -6, RoundHalfUp, NewDec(big.NewInt(18446744073710), -6)},
+}
+
+func TestDecRound(t *testing.T) {
+	for i, tt := range decRoundTests {
+		z := new(Dec).Round(tt.in, tt.s, tt.r)
+		if tt.exp.Cmp(z) != 0 {
+			t.Errorf("#%d Round got %v; expected %v", i, z, tt.exp)
+		}
+	}
+}
+
var decStringTests = []struct {
in     string
out    string
```