Golang big.NewRat类(方法)实例源码

func (b *Bayesian) ProbAWhenB(word string) *big.Rat {
	probA := big.NewRat(b.countA, b.totalCount)
	v := b.words[word]
	probBWhenA := big.NewRat(v.countAWithB, b.countA)
	probB := big.NewRat(v.countB, b.totalCount)
	br := &BayesRule{probBWhenA, probA, probB}
	probAWhenB := br.Calculate()
	return probAWhenB
}

func TestTweets(t *T) {
	b := makeTweets()

	assertProb(t, b, big.NewRat(1, 1), "grinnell")
	assertProb(t, b, big.NewRat(1, 1), "president")
	assertProb(t, b, big.NewRat(1, 9), "one")
	assertProb(t, b, big.NewRat(1, 3), "four")
	assertProb(t, b, big.NewRat(1, 2), "other")
}

func TestRatSub(t *testing.T) {
	fmt.Println("Testing RatSub")
	x := big.NewRat(0, 1).Sub(big.NewRat(1, 3), big.NewRat(1, 2))
	fmt.Print("x ")
	fmt.Println(x)
	if (x.Num().Cmp(big.NewInt(-1)) != 0) || (x.Denom().Cmp(big.NewInt(6)) != 0) {
		t.Error("Num and Denom don't match")
	}
}

func number_divide(x, y Obj) Obj {
	xfx := (uintptr(unsafe.Pointer(x)) & fixnum_mask) == fixnum_tag
	yfx := (uintptr(unsafe.Pointer(y)) & fixnum_mask) == fixnum_tag
	if xfx && yfx {
		i1 := int(uintptr(unsafe.Pointer(x))) >> fixnum_shift
		i2 := int(uintptr(unsafe.Pointer(y))) >> fixnum_shift
		// A good optimizer will combine the div and mod into
		// one instruction.
		r, m := i1/i2, i1%i2
		if m == 0 && r > fixnum_min && r < fixnum_max {
			return Make_fixnum(r)
		} else {
			return wrap(big.NewRat(int64(i1), int64(i2)))
		}
	}

	if (!xfx && (uintptr(unsafe.Pointer(x))&heap_mask) != heap_tag) ||
		(!yfx && (uintptr(unsafe.Pointer(y))&heap_mask) != heap_tag) {
		panic("bad type")
	}

	if xfx {
		x = wrap(big.NewInt(int64(fixnum_to_int(x))))
	}
	if yfx {
		y = wrap(big.NewInt(int64(fixnum_to_int(y))))
		//return wrap(z.Div(vx,vy))
	}

	switch vx := (*x).(type) {
	case *big.Int:
		var z *big.Int = big.NewInt(0)
		switch vy := (*y).(type) {
		case *big.Int:
			return simpBig(z.Div(vx, vy))
		case *big.Rat:
			z := big.NewRat(1, 1)
			z.SetInt(vx)
			return simpRat(z.Quo(z, vy))
		default:
			panic("bad type")
		}
	case *big.Rat:
		z := big.NewRat(1, 1)
		switch vy := (*y).(type) {
		case *big.Int:
			z.SetInt(vy)
			return simpRat(z.Quo(vx, z))
		case *big.Rat:
			return simpRat(z.Quo(vx, vy))
		}
	}
	panic("bad type")
}

func Euler33() string {
	prod := big.NewRat(1, 1)
	for a := 10; a < 100; a++ {
		for b := a + 1; b < 100; b++ {
			if hasProperty(a, b) {
				prod.Mul(prod, big.NewRat(int64(a), int64(b)))
			}
		}
	}
	den := prod.Denom()
	return fmt.Sprint(den.String())
}

func main() {

	current := big.NewRat(1, 1)
	result := big.NewRat(0, 1)

	for rounds := 1; rounds <= 15; rounds += 1 {

		result.SetFrac64(0, 1)

		split(1, rounds, 0, current, result)
		fmt.Println(result)
	}
}

func number_multiply(x, y Obj) Obj {
	xfx := (uintptr(unsafe.Pointer(x)) & fixnum_mask) == fixnum_tag
	yfx := (uintptr(unsafe.Pointer(y)) & fixnum_mask) == fixnum_tag
	if xfx && yfx {
		i1 := int64(int(uintptr(unsafe.Pointer(x))))
		i2 := int64(int(uintptr(unsafe.Pointer(y))))
		r := (i1 >> fixnum_shift) * (i2 >> fixnum_shift)
		if r > int64(fixnum_min) && r < int64(fixnum_max) {
			return Make_fixnum(int(r))
		} else {
			return wrap(big.NewInt(r))
		}
	}

	if (!xfx && (uintptr(unsafe.Pointer(x))&heap_mask) != heap_tag) ||
		(!yfx && (uintptr(unsafe.Pointer(y))&heap_mask) != heap_tag) {
		panic("bad type")
	}

	if xfx {
		x = wrap(big.NewInt(int64(fixnum_to_int(x))))
	}
	if yfx {
		y = wrap(big.NewInt(int64(fixnum_to_int(y))))
	}

	switch vx := (*x).(type) {
	case *big.Int:
		var z *big.Int = big.NewInt(0)
		switch vy := (*y).(type) {
		case *big.Int:
			return simpBig(z.Mul(vx, vy))
		case *big.Rat:
			z := big.NewRat(1, 1)
			z.SetInt(vx)
			return simpRat(z.Mul(z, vy))
		default:
			panic("bad type")
		}
	case *big.Rat:
		z := big.NewRat(1, 1)
		switch vy := (*y).(type) {
		case *big.Int:
			z.SetInt(vy)
			return simpRat(z.Mul(vx, z))
		case *big.Rat:
			return simpRat(z.Mul(vx, vy))
		}
	}
	panic("bad type")
}

func (rs *ResultSet) rat(ord int) (value *big.Rat, isNull bool) {
	if rs.conn.LogLevel >= LogVerbose {
		defer rs.conn.logExit(rs.conn.logEnter("*ResultSet.rat"))
	}

	isNull = rs.isNull(ord)
	if isNull {
		return
	}

	val := rs.values[ord]

	switch rs.fields[ord].format {
	case textFormat:
		x := big.NewRat(1, 1)
		if _, ok := x.SetString(string(val)); !ok {
			panic("*big.Rat.SetString failed")
		}
		value = x

	case binaryFormat:
		panicNotImplemented()
	}

	return
}

func Test_Numeric(t *testing.T) {
	strWant := "0." + strings.Repeat("0123456789", 100)[1:]
	numWant, _ := big.NewRat(1, 1).SetString(strWant)
	numParam := param("@num", Numeric, numWant)

	withStatementResultSet(t, "SELECT @num;", []*Parameter{numParam}, func(rs *ResultSet) {
		// Use interface{}, so *resultSet.Any will be tested as well.
		var numHaveInterface interface{}

		_, err := rs.ScanNext(&numHaveInterface)
		if err != nil {
			t.Error("failed to scan next:", err)
		}

		numHave, ok := numHaveInterface.(*big.Rat)
		if !ok {
			t.Errorf("unexpected type: %T", numHaveInterface)
			return
		}

		strHave := numHave.FloatString(999)
		if strHave != strWant {
			t.Errorf("have: %s, but want: %s", strHave, strWant)
		}
	})
}

// MakeConst makes an ideal constant from a literal
// token and the corresponding literal string.
func MakeConst(tok token.Token, lit string) Const {
	switch tok {
	case token.INT:
		var x big.Int
		_, ok := x.SetString(lit, 0)
		assert(ok)
		return Const{&x}
	case token.FLOAT:
		var y big.Rat
		_, ok := y.SetString(lit)
		assert(ok)
		return Const{&y}
	case token.IMAG:
		assert(lit[len(lit)-1] == 'i')
		var im big.Rat
		_, ok := im.SetString(lit[0 : len(lit)-1])
		assert(ok)
		return Const{cmplx{big.NewRat(0, 1), &im}}
	case token.CHAR:
		assert(lit[0] == '\'' && lit[len(lit)-1] == '\'')
		code, _, _, err := strconv.UnquoteChar(lit[1:len(lit)-1], '\'')
		assert(err == nil)
		return Const{big.NewInt(int64(code))}
	case token.STRING:
		s, err := strconv.Unquote(lit)
		assert(err == nil)
		return Const{s}
	}
	panic("unreachable")
}

func (b *Bayesian) Filter(data Data, threshold *big.Rat) bool {
	total := big.NewRat(1, 1)
	for _, word := range data.GetWords() {
		w := lowerTrim(word)
		_, has := b.words[w]
		if has {
			probAWhenB := b.ProbAWhenB(word)
			one := big.NewRat(1, 1)
			total = total.Mul(total, one.Sub(one, probAWhenB))
		}

	}
	one := big.NewRat(1, 1)
	inverseThreshold := one.Sub(one, threshold)
	return total.Cmp(inverseThreshold) <= 0
}

func (d *Deserializer) ReadObject() Obj {
	tag := d.readInt().Int64()
	length := d.readInt()
	switch tag {
	case Integer:
		if length.Cmp(fixnum_min_Int) < 0 || length.Cmp(fixnum_max_Int) > 0 {
			var vv interface{} = length
			return Obj(&vv)
		}
		return Make_fixnum(int(length.Int64()))
	case Rational:
		i := big.NewRat(1, 1)
		return wrap(i.SetFrac(length, d.readInt()))
	case Float64:
		var v float64
		binary.Read(d.r, binary.LittleEndian, &v)
		return wrap(v)
	case Complex128:
		var v complex128
		binary.Read(d.r, binary.LittleEndian, &v)
		return wrap(v)
	case Pair:
		o1 := d.ReadObject()
		o2 := d.ReadObject()
		return Cons(o1, o2)
	case Vector:
		l := length.Int64() // fix
		obj := Make_vector(Make_fixnum(int(l)), Void)
		var i int64 = 0
		for ; i < l; i++ {
			t := d.ReadObject()
			Vector_set_ex(obj, Make_fixnum(int(i)), t)
		}
		return obj
	case Null:
		return Eol
	case String:
		s := d.readString(length.Int64())
		return String_string(s)
	case Symbol:
		i := length.Int64()
		s := d.readString(i)
		return String_to_symbol(String_string(s))
	case Bytevector:
		b := make([]byte, length.Int64())
		d.r.Read(b)
		return wrap(b)
	case Boolean:
		if length.Int64() != 0 {
			return Make_boolean(true)
		}
		return Make_boolean(false)
	case Char:
		c := length.Int64()
		return Make_char(int(c))
	}
	s := fmt.Sprintf("unknown tag: %v length: %v", tag, length)
	panic(s)
}

// Match attempts to match the internal constant representations of x and y.
// If the attempt is successful, the result is the values of x and y,
// if necessary converted to have the same internal representation; otherwise
// the results are invalid.
func (x Const) Match(y Const) (u, v Const) {
	switch a := x.val.(type) {
	case bool:
		if _, ok := y.val.(bool); ok {
			u, v = x, y
		}
	case *big.Int:
		switch y.val.(type) {
		case *big.Int:
			u, v = x, y
		case *big.Rat:
			var z big.Rat
			z.SetInt(a)
			u, v = Const{&z}, y
		case cmplx:
			var z big.Rat
			z.SetInt(a)
			u, v = Const{cmplx{&z, big.NewRat(0, 1)}}, y
		}
	case *big.Rat:
		switch y.val.(type) {
		case *big.Int:
			v, u = y.Match(x)
		case *big.Rat:
			u, v = x, y
		case cmplx:
			u, v = Const{cmplx{a, big.NewRat(0, 0)}}, y
		}
	case cmplx:
		switch y.val.(type) {
		case *big.Int, *big.Rat:
			v, u = y.Match(x)
		case cmplx:
			u, v = x, y
		}
	case string:
		if _, ok := y.val.(string); ok {
			u, v = x, y
		}
	default:
		panic("unreachable")
	}
	return
}

func TestRatString(t *testing.T) {
	fmt.Println("Testing RatString")
	x := big.NewRat(0, 1)
	_, ok := x.SetString("5.23")
	fmt.Print("x ")
	fmt.Print(x)
	fmt.Print(" ")
	fmt.Println(x.FloatString(4))
	fmt.Print("ok ")
	fmt.Println(ok)
}

func split(turn, maxTurns int, blueDiscsDrawn int, current, result *big.Rat) {

	if blueDiscsDrawn > (maxTurns / 2) {
		result.Add(result, current)
		//fmt.Println(blueDiscsDrawn, current)
		return
	} else if turn > maxTurns {
		return
	}

	redCurrent := big.NewRat(1, 1)
	blueCurrent := big.NewRat(1, 1)

	redCurrent.Mul(current, big.NewRat(int64(turn), int64(turn+1)))
	blueCurrent.Mul(current, big.NewRat(1, int64(turn+1)))

	split(turn+1, maxTurns, blueDiscsDrawn, redCurrent, result)
	split(turn+1, maxTurns, blueDiscsDrawn+1, blueCurrent, result)

}

func TestRat(t *testing.T) {
	fmt.Println("Testing Rat")
	x := big.NewRat(34234212327, 5464523)
	fmt.Print("x ")
	fmt.Print(x)
	fmt.Print(" ")
	fmt.Println(x.FloatString(5))
	if x.FloatString(5) != "6264.81256" {
		t.Error("Float String rep not matching")
	}
}

func (t *idealFloatType) Zero() Value { return &idealFloatV{big.NewRat(0, 1)} }

func (t *uintType) minVal() *big.Rat { return big.NewRat(0, 1) }

Val("i", 1),
	CErr("zzz", undefined),
	// TODO(austin) Test variable in constant context
	//CErr("t", typeAsExpr),

	Val("'a'", big.NewInt('a')),
	Val("'\\uffff'", big.NewInt('\uffff')),
	Val("'\\n'", big.NewInt('\n')),
	CErr("''+x", badCharLit),
	// Produces two parse errors
	//CErr("'''", ""),
	CErr("'\n'", badCharLit),
	CErr("'\\z'", unknownEscape),
	CErr("'ab'", badCharLit),

	Val("1.0", big.NewRat(1, 1)),
	Val("1.", big.NewRat(1, 1)),
	Val(".1", big.NewRat(1, 10)),
	Val("1e2", big.NewRat(100, 1)),

	Val("\"abc\"", "abc"),
	Val("\"\"", ""),
	Val("\"\\n\\\"\"", "\n\""),
	CErr("\"\\z\"", unknownEscape),
	CErr("\"abc", "string not terminated"),

	Val("(i)", 1),

	Val("ai[0]", 1),
	Val("(&ai)[0]", 1),
	Val("ai[1]", 2),

func number_cmp(x, y Obj) Obj {
	xfx := (uintptr(unsafe.Pointer(x)) & fixnum_mask) == fixnum_tag
	yfx := (uintptr(unsafe.Pointer(y)) & fixnum_mask) == fixnum_tag
	if xfx && yfx {
		i1 := int(uintptr(unsafe.Pointer(x))) >> fixnum_shift
		i2 := int(uintptr(unsafe.Pointer(y))) >> fixnum_shift
		switch {
		case i1 > i2:
			return Make_fixnum(1)
		case i1 < i2:
			return Make_fixnum(-1)
		default:
			return Make_fixnum(0)
		}
	}

	if (!xfx && (uintptr(unsafe.Pointer(x))&heap_mask) != heap_tag) ||
		(!yfx && (uintptr(unsafe.Pointer(y))&heap_mask) != heap_tag) {
		panic("bad type")
	}

	if xfx {
		return number_subtract(y, x)
	}

	switch vx := (*x).(type) {
	case *big.Int:
		if yfx {
			vy := big.NewInt(int64(fixnum_to_int(y)))
			return Make_fixnum(vx.Cmp(vy))
		}
		switch vy := (*y).(type) {
		case *big.Int:
			return Make_fixnum(vx.Cmp(vy))
		case *big.Rat:
			r := big.NewRat(1, 1).SetInt(vx)
			return Make_fixnum(r.Cmp(vy))
		case complex128:
			panic("comparison on complex numbers is undefined")
		default:
			panic("bad type")
		}
	case *big.Rat:
		if yfx {
			vy := big.NewRat(int64(fixnum_to_int(y)), 1)
			return Make_fixnum(vx.Cmp(vy))
		}
		switch vy := (*y).(type) {
		case *big.Int:
			r := big.NewRat(1, 1).SetInt(vy)
			return Make_fixnum(vx.Cmp(r))
		case *big.Rat:
			return Make_fixnum(vx.Cmp(vy))
		case complex128:
			panic("comparison on complex numbers is undefined")
		default:
			panic("bad type")
		}
	case complex128:
		panic("comparison on complex numbers is undefined")
	}
	panic("bad type")
}