func (n *Number) UnmarshalJSON(data []byte) error { input := strings.TrimSpace(string(data)) if len(input) >= 2 && input[0] == '"' && input[len(input)-1] == '"' { input = input[1 : len(input)-1] } if len(input) == 0 { *n = Number(latestBlockNumber.Int64()) return nil } in := new(big.Int) _, ok := in.SetString(input, 0) if !ok { // test if user supplied string tag return fmt.Errorf(`invalid number %s`, data) } if in.Cmp(earliestBlockNumber) >= 0 && in.Cmp(maxBlockNumber) <= 0 { *n = Number(in.Int64()) return nil } return fmt.Errorf("blocknumber not in range [%d, %d]", earliestBlockNumber, maxBlockNumber) }
// Base58Encode encodes a byte slice to a modified base58 string. func Base58Encode(b []byte, alphabet string) string { x := new(big.Int) x.SetBytes(b) answer := make([]byte, 0) for x.Cmp(bigZero) > 0 { mod := new(big.Int) x.DivMod(x, bigRadix, mod) answer = append(answer, alphabet[mod.Int64()]) } // leading zero bytes for _, i := range b { if i != 0 { break } answer = append(answer, alphabet[0]) } // reverse alen := len(answer) for i := 0; i < alen/2; i++ { answer[i], answer[alen-1-i] = answer[alen-1-i], answer[i] } return string(answer) }
// Encode encodes src into EncodedMaxLen(len(src)) // or fewer bytes of dst. It returns the number of bytes written to dst. func Encode(dst, src []byte) int { zeros := 0 for _, b := range src { if int(b) == 0 { zeros++ } else { break } } i := new(big.Int).SetBytes(src) big58 := big.NewInt(58) big0 := big.NewInt(0) var index int for i.Cmp(big0) > 0 { tmp := new(big.Int).Mod(i, big58) i.Div(i, big58) dst[index] = base58alphabet[tmp.Int64()] index++ } for ; zeros > 0; zeros-- { dst[index] = base58alphabet[0] index++ } reverseInplace(dst[0:index]) return index }
// BigComma produces a string form of the given big.Int in base 10 // with commas after every three orders of magnitude. func BigComma(b *big.Int) string { sign := "" if b.Sign() < 0 { sign = "-" b.Abs(b) } athousand := big.NewInt(1000) c := (&big.Int{}).Set(b) _, m := oom(c, athousand) parts := make([]string, m+1) j := len(parts) - 1 mod := &big.Int{} for b.Cmp(athousand) >= 0 { b.DivMod(b, athousand, mod) parts[j] = strconv.FormatInt(mod.Int64(), 10) switch len(parts[j]) { case 2: parts[j] = "0" + parts[j] case 1: parts[j] = "00" + parts[j] } j-- } parts[j] = strconv.Itoa(int(b.Int64())) return sign + strings.Join(parts[j:len(parts)], ",") }
func rand(max *big.Int) int64 { i, err := urandom.Int(urandom.Reader, max) if err != nil { return prandom.Int63n(max.Int64()) } return i.Int64() }
func EncodeBase58(ba []byte) []byte { if len(ba) == 0 { return nil } // Expected size increase from base58 conversion is approximately 137%, use 138% to be safe ri := len(ba) * 138 / 100 ra := make([]byte, ri+1) x := new(big.Int).SetBytes(ba) // ba is big-endian x.Abs(x) y := big.NewInt(58) m := new(big.Int) for x.Sign() > 0 { x, m = x.DivMod(x, y, m) ra[ri] = base58[int32(m.Int64())] ri-- } // Leading zeroes encoded as base58 zeros for i := 0; i < len(ba); i++ { if ba[i] != 0 { break } ra[ri] = '1' ri-- } return ra[ri+1:] }
func Validate(user string, pass string) bool { sess := GetSession() defer sess.Close() authdb := sess.DB("prod").C("auth") var r *big.Int r, _ = rand.Int(rand.Reader, big.NewInt(5)) time.Sleep(time.Duration(r.Int64()) * time.Nanosecond) var person S.User err := authdb.Find(bson.M{"user": user}).One(&person) if err != nil { fmt.Println(err) } else { hasher := sha256.New() hasher.Write([]byte(pass + string(person.Salt))) hashed := base64.URLEncoding.EncodeToString(hasher.Sum(nil)) if hashed == person.Pass { return true } } return false }
func (self *EthReg) Resolver(n *big.Int) *registrar.Registrar { xe := self.backend if n != nil { xe = self.backend.AtStateNum(n.Int64()) } return registrar.New(xe) }
func setBignum(rv reflect.Value, x *big.Int) error { switch rv.Kind() { case reflect.Ptr: return setBignum(reflect.Indirect(rv), x) case reflect.Interface: rv.Set(reflect.ValueOf(*x)) return nil case reflect.Int32: if x.BitLen() < 32 { rv.SetInt(x.Int64()) return nil } else { return fmt.Errorf("int too big for int32 target") } case reflect.Int, reflect.Int64: if x.BitLen() < 64 { rv.SetInt(x.Int64()) return nil } else { return fmt.Errorf("int too big for int64 target") } default: return fmt.Errorf("cannot assign bignum into Kind=%s Type=%s %#v", rv.Kind().String(), rv.Type().String(), rv) } }
// EncodeBigInt returns the base62 encoding of an arbitrary precision integer func (e *Encoding) EncodeBigInt(n *big.Int) string { var ( b = make([]byte, 0) rem = new(big.Int) bse = new(big.Int) zero = new(big.Int) ) bse.SetInt64(base) zero.SetInt64(0) // Progressively divide by base, until we hit zero // store remainder each time // Prepend as an additional character is the higher power for n.Cmp(zero) == 1 { n, rem = n.DivMod(n, bse, rem) b = append([]byte{e.encode[rem.Int64()]}, b...) } s := string(b) if e.padding > 0 { s = e.pad(s, e.padding) } return s }
func (c *StateObject) GetInstr(pc *big.Int) *common.Value { if int64(len(c.code)-1) < pc.Int64() { return common.NewValue(0) } return common.NewValueFromBytes([]byte{c.code[pc.Int64()]}) }
func main() { lim := 1000 primes := allPrimes(lim) mx_cyc := 0 mx_len := 0 for _, i := range primes { j := 1 for j < i { p := new(big.Int) *p = bigPow(10, j) res := new(big.Int) res.Mod(p, big.NewInt(int64(i))) if res.Int64() == 1 { if mx_len < j { mx_len = i mx_cyc = j } break } j++ } } fmt.Printf("Found: 1/%d yields %d cycles\n", mx_len, mx_cyc) }
func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) { var obj []struct { Payload string To string From string Topics []string Priority interface{} Ttl interface{} } if err = json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) < 1 { return shared.NewInsufficientParamsError(len(obj), 1) } args.Payload = obj[0].Payload args.To = obj[0].To args.From = obj[0].From args.Topics = obj[0].Topics var num *big.Int if num, err = numString(obj[0].Priority); err != nil { return err } args.Priority = uint32(num.Int64()) if num, err = numString(obj[0].Ttl); err != nil { return err } args.Ttl = uint32(num.Int64()) return nil }
func bigRsh(z, x, y *big.Int) *big.Int { i := y.Int64() if i < 0 { panic("negative shift") } return z.Rsh(x, uint(i)) }
func (c *StateObject) GetInstr(pc *big.Int) *ethutil.Value { if int64(len(c.Code)-1) < pc.Int64() { return ethutil.NewValue(0) } return ethutil.NewValueFromBytes([]byte{c.Code[pc.Int64()]}) }
func (c *Context) GetByte(n *big.Int) byte { if n.Cmp(big.NewInt(int64(len(c.Code)))) < 0 { return c.Code[n.Int64()] } return 0 }
func (args *WaitForBlockArgs) UnmarshalJSON(b []byte) (err error) { var obj []interface{} if err := json.Unmarshal(b, &obj); err != nil { return shared.NewDecodeParamError(err.Error()) } if len(obj) > 2 { return fmt.Errorf("waitForArgs needs 0, 1, 2 arguments") } // default values when not provided args.MinHeight = -1 args.Timeout = -1 if len(obj) >= 1 { var minHeight *big.Int if minHeight, err = numString(obj[0]); err != nil { return err } args.MinHeight = int(minHeight.Int64()) } if len(obj) >= 2 { timeout, err := numString(obj[1]) if err != nil { return err } args.Timeout = int(timeout.Int64()) } return nil }
func readBigInt(r io.Reader, b []byte, sign byte) (interface{}, error) { if _, err := io.ReadFull(r, b); err != nil { return nil, err } size := len(b) hsize := size >> 1 for i := 0; i < hsize; i++ { b[i], b[size-i-1] = b[size-i-1], b[i] } v := new(big.Int).SetBytes(b) if sign != 0 { v = v.Neg(v) } // try int and int64 v64 := v.Int64() if x := int(v64); v.Cmp(big.NewInt(int64(x))) == 0 { return x, nil } else if v.Cmp(big.NewInt(v64)) == 0 { return v64, nil } return v, nil }
func (h *hasher) GetLoggregatorServerForAppId(appId string) string { var id, numberOfItems big.Int id.SetBytes([]byte(appId)) numberOfItems.SetInt64(int64(len(h.items))) id.Mod(&id, &numberOfItems) return h.items[id.Int64()] }
func newRandomInt(max *big.Int) int { rand, err := rand.Int(rand.Reader, max) if err != nil { // Fallback to pseudo-random return pseudoRand.Intn(int(max.Int64())) } return int(rand.Int64()) }
func contains(slice []*big.Int, x *big.Int) bool { for _, v := range slice { if v.Int64() == x.Int64() { return true } } return false }
func (c *Closure) Gets(x, y *big.Int) *ethutil.Value { if x.Int64() >= int64(len(c.Code)) || y.Int64() >= int64(len(c.Code)) { return ethutil.NewValue(0) } partial := c.Code[x.Int64() : x.Int64()+y.Int64()] return ethutil.NewValue(partial) }
func EncodeBigInt(chars string, bigInt *big.Int) string { if bigInt.Cmp(big.NewInt(int64(len(chars)))) < 0 { return string(chars[bigInt.Int64()]) } mod := big.NewInt(0) rest := big.NewInt(0) rest.DivMod(bigInt, big.NewInt(int64(len(chars))), mod) return EncodeBigInt(chars, rest) + string(chars[mod.Int64()]) }
// total order of magnitude // (same as above, but with no upper limit) func oom(n, b *big.Int) (float64, int) { mag := 0 m := &big.Int{} for n.Cmp(b) >= 0 { n.DivMod(n, b, m) mag++ } return float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag }
func factorial(x float64) float64 { if x != float64(uint64(x)) { panic("Factorial input must be a positive integer.") } var res *big.Int = new(big.Int) res.MulRange(1, int64(x)) return float64(res.Int64()) }
func TestMarshalBigInt(t *testing.T) { var expected *big.Int = big.NewInt(1000) i64 := expected.Int64() actual := big.NewInt(i64) if expected.Cmp(actual) != 0 { t.Fatalf("big.Int numbers are not equal. expected: %v, actual %v", expected.String(), actual.String()) } }
func (st *Stack) Get(amount *big.Int) []*big.Int { // offset + size <= len(data) length := big.NewInt(int64(len(st.data))) if amount.Cmp(length) <= 0 { start := new(big.Int).Sub(length, amount) return st.data[start.Int64():length.Int64()] } return nil }
func BenchmarkPrivateKey_MarshalBigIntInt64(b *testing.B) { var n *big.Int = big.NewInt(1000) var i64 int64 = 0 for i := 0; i < b.N; i++ { i64 = n.Int64() } log.Println(i64) }
// If y dividable to x without without remains // then it returns true and pointer to divided x parameter with final result func IsBigDividable(x, y *big.Int) (bool, *big.Int) { div := big.Int{} div.Mod(x, y) if div.Int64() == 0 { x.Div(x, y) return true, x } return false, x }
// mul multiplies the input amount by the input price func mul(amount int64, pricen int64, priced int64) int64 { var r, n, d big.Int r.SetInt64(amount) n.SetInt64(pricen) d.SetInt64(priced) r.Mul(&r, &n) r.Quo(&r, &d) return r.Int64() }