panic("d out of range")
	}

	precise := big.NewRat((1<<d)*int64(x), q) // (2ᵈ / q) * x == (2ᵈ * x) / q

	// FloatString rounds halves away from 0, and our result should always be positive,
	// so it should work as we expect. (There's no direct way to round a Rat.)
	rounded, err := strconv.ParseInt(precise.FloatString(0), 10, 64)
	if err != nil {
		panic(err)
	}

	{".55", -1, "1"},
}

func TestFloatString(t *testing.T) {
	for i, test := range floatStringTests {
		x, _ := new(Rat).SetString(test.in)

		if x.FloatString(test.prec) != test.out {
			t.Errorf("#%d got %s want %s", i, x.FloatString(test.prec), test.out)
		}
	}
}

// Test inputs to Rat.SetString. The prefix "long:" causes the test
// to be skipped except in -long mode.  (The threshold is about 500us.)

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

package big_test

import (
	"fmt"
	"log"
	"math"
	"math/big"
)

func ExampleRat_SetString() {
	r := new(big.Rat)
	r.SetString("355/113")
	fmt.Println(r.FloatString(3))
	// Output: 3.142
}

func ExampleInt_SetString() {
	i := new(big.Int)
	i.SetString("644", 8) // octal
	fmt.Println(i)
	// Output: 420
}

func ExampleFloat_SetString() {
	f := new(big.Float)

	if x.IsInt() {
		return x.a.String()
	}
	return x.String()
}

// FloatString returns a string representation of x in decimal form with prec
// digits of precision after the radix point. The last digit is rounded to
// nearest, with halves rounded away from zero.
func (x *Rat) FloatString(prec int) string {
	var buf []byte

	if x.IsInt() {
		buf = x.a.Append(buf, 10)
		if prec > 0 {

		{"(*Rat).Add", Method, 0},
		{"(*Rat).Cmp", Method, 0},
		{"(*Rat).Denom", Method, 0},
		{"(*Rat).Float32", Method, 4},
		{"(*Rat).Float64", Method, 1},
		{"(*Rat).FloatPrec", Method, 22},
		{"(*Rat).FloatString", Method, 0},
		{"(*Rat).GobDecode", Method, 0},
		{"(*Rat).GobEncode", Method, 0},
		{"(*Rat).Inv", Method, 0},
		{"(*Rat).IsInt", Method, 0},
		{"(*Rat).MarshalText", Method, 3},

pkg math/big, method (*Rat) Abs(*Rat) *Rat
pkg math/big, method (*Rat) Add(*Rat, *Rat) *Rat
pkg math/big, method (*Rat) Cmp(*Rat) int
pkg math/big, method (*Rat) Denom() *Int
pkg math/big, method (*Rat) FloatString(int) string
pkg math/big, method (*Rat) GobDecode([]uint8) error
pkg math/big, method (*Rat) GobEncode() ([]uint8, error)
pkg math/big, method (*Rat) Inv(*Rat) *Rat
pkg math/big, method (*Rat) IsInt() bool