func mandelbrotRat(a, b *big.Rat) color.Color { var x, y, nx, ny, x2, y2, f2, f4, r2, tmp big.Rat f2.SetInt64(2) f4.SetInt64(4) x.SetInt64(0) y.SetInt64(0) defer func() { recover() }() for n := uint8(0); n < iterations; n++ { // Not update x2 and y2 // because they are already updated in the previous loop nx.Sub(&x2, &y2) nx.Add(&nx, a) tmp.Mul(&x, &y) ny.Mul(&f2, &tmp) ny.Add(&ny, b) x.Set(&nx) y.Set(&ny) x2.Mul(&x, &x) y2.Mul(&y, &y) r2.Add(&x2, &y2) if r2.Cmp(&f4) > 0 { return color.Gray{255 - contrast*n} } } return color.Black }
func unaryFloatOp(x *big.Rat, op token.Token) interface{} { var z big.Rat switch op { case token.ADD: return z.Set(x) case token.SUB: return z.Neg(x) } panic("unreachable") }
func b(n int) *big.Rat { var f big.Rat a := make([]big.Rat, n+1) for m := range a { a[m].SetFrac64(1, int64(m+1)) for j := m; j >= 1; j-- { d := &a[j-1] d.Mul(f.SetInt64(int64(j)), d.Sub(d, &a[j])) } } return f.Set(&a[0]) }
func abs(x *complexRat) *big.Rat { r := new(big.Rat) i := new(big.Rat) r.Set(x.r) i.Set(x.i) r.Mul(r, x.r) // r^2 i.Mul(i, x.i) // i^2 r.Add(r, i) // r^2 + i^2 return sqrtFloat(r) // sqrt(r^2 + i^2) }
func sqrtFloat(x *big.Rat) *big.Rat { t1 := new(big.Rat) t2 := new(big.Rat) t1.Set(x) // Iterate. // x{n} = (x{n-1}+x{0}/x{n-1}) / 2 for i := 0; i <= 4; i++ { if t1.Cmp(zero) == 0 { return t1 } t2.Quo(x, t1) t2.Add(t2, t1) t1.Mul(half, t2) } return t1 }
func (r BigRat) floatString(verb byte, prec int) string { switch verb { case 'f', 'F': return r.Rat.FloatString(prec) case 'e', 'E': // The exponent will alway be >= 0. sign := "" var x, t big.Rat x.Set(r.Rat) if x.Sign() < 0 { sign = "-" x.Neg(&x) } t.Set(&x) exp := ratExponent(&x) ratScale(&t, exp) str := t.FloatString(prec + 1) // +1 because first digit might be zero. // Drop the decimal. if str[0] == '0' { str = str[2:] exp-- } else if len(str) > 1 && str[1] == '.' { str = str[0:1] + str[2:] } return eFormat(verb, prec, sign, str, exp) case 'g', 'G': var x big.Rat x.Set(r.Rat) exp := ratExponent(&x) // Exponent could be positive or negative if exp < -4 || prec <= exp { // Use e format. verb -= 2 // g becomes e. return trimEZeros(verb, r.floatString(verb, prec-1)) } // Use f format. // If it's got zeros right of the decimal, they count as digits in the precision. // If it's got digits left of the decimal, they count as digits in the precision. // Both are handled by adjusting prec by exp. str := r.floatString(verb-1, prec-exp-1) // -1 for the one digit left of the decimal. // Trim trailing decimals. point := strings.IndexByte(str, '.') if point > 0 { n := len(str) for str[n-1] == '0' { n-- } str = str[:n] if str[n-1] == '.' { str = str[:n-1] } } return str default: Errorf("can't handle verb %c for rational", verb) } return "" }
func (me *StatisticalAccumulator) N() *big.Rat { n := new(big.Rat) n.Set(me.n) return n }
func GetAccountTransactions(user *User, accountid int64, sort string, page uint64, limit uint64) (*AccountTransactionsList, error) { var transactions []Transaction var atl AccountTransactionsList transaction, err := DB.Begin() if err != nil { return nil, err } var sqlsort, balanceLimitOffset string var balanceLimitOffsetArg uint64 if sort == "date-asc" { sqlsort = " ORDER BY transactions.Date ASC" balanceLimitOffset = " LIMIT ?" balanceLimitOffsetArg = page * limit } else if sort == "date-desc" { numSplits, err := transaction.SelectInt("SELECT count(*) FROM splits") if err != nil { transaction.Rollback() return nil, err } sqlsort = " ORDER BY transactions.Date DESC" balanceLimitOffset = fmt.Sprintf(" LIMIT %d OFFSET ?", numSplits) balanceLimitOffsetArg = (page + 1) * limit } var sqloffset string if page > 0 { sqloffset = fmt.Sprintf(" OFFSET %d", page*limit) } account, err := GetAccountTx(transaction, accountid, user.UserId) if err != nil { transaction.Rollback() return nil, err } atl.Account = account sql := "SELECT DISTINCT transactions.* FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + " LIMIT ?" + sqloffset _, err = transaction.Select(&transactions, sql, user.UserId, accountid, limit) if err != nil { transaction.Rollback() return nil, err } atl.Transactions = &transactions var pageDifference, tmp big.Rat for i := range transactions { _, err = transaction.Select(&transactions[i].Splits, "SELECT * FROM splits where TransactionId=?", transactions[i].TransactionId) if err != nil { transaction.Rollback() return nil, err } // Sum up the amounts from the splits we're returning so we can return // an ending balance for j := range transactions[i].Splits { if transactions[i].Splits[j].AccountId == accountid { rat_amount, err := GetBigAmount(transactions[i].Splits[j].Amount) if err != nil { transaction.Rollback() return nil, err } tmp.Add(&pageDifference, rat_amount) pageDifference.Set(&tmp) } } } count, err := transaction.SelectInt("SELECT count(DISTINCT transactions.TransactionId) FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?", user.UserId, accountid) if err != nil { transaction.Rollback() return nil, err } atl.TotalTransactions = count security, err := GetSecurity(atl.Account.SecurityId, user.UserId) if err != nil { return nil, err } if security == nil { return nil, errors.New("Security not found") } // Sum all the splits for all transaction splits for this account that // occurred before the page we're returning var amounts []string sql = "SELECT splits.Amount FROM splits WHERE splits.AccountId=? AND splits.TransactionId IN (SELECT DISTINCT transactions.TransactionId FROM transactions INNER JOIN splits ON transactions.TransactionId = splits.TransactionId WHERE transactions.UserId=? AND splits.AccountId=?" + sqlsort + balanceLimitOffset + ")" _, err = transaction.Select(&amounts, sql, accountid, user.UserId, accountid, balanceLimitOffsetArg) if err != nil { transaction.Rollback() return nil, err } var balance big.Rat for _, amount := range amounts { rat_amount, err := GetBigAmount(amount) if err != nil { transaction.Rollback() return nil, err } tmp.Add(&balance, rat_amount) balance.Set(&tmp) } atl.BeginningBalance = balance.FloatString(security.Precision) atl.EndingBalance = tmp.Add(&balance, &pageDifference).FloatString(security.Precision) err = transaction.Commit() if err != nil { transaction.Rollback() return nil, err } return &atl, nil }