func BenchmarkHasFactorBigIntRnd_128b(b *testing.B) {
const N = 1 << 16
b.StopTimer()
type t struct {
d *big.Int
e uint32
}
a := make([]t, N)
r, err := mathutil.NewFCBig(_1, New(128), true)
if err != nil {
b.Fatal(err)
}
r2 := r32()
for i := range a {
dd := r.Next()
a[i] = t{
dd.SetBit(dd, 0, 1),
uint32(r2.Next()),
}
}
once358.Do(func() { b.Log("Random 128 bit factor, random 32 bit exponent\n") })
runtime.GC()
b.StartTimer()
for i := 0; i < b.N; i++ {
v := a[i&(N-1)]
HasFactorBigInt(v.d, v.e)
}
}
func r64() *mathutil.FCBig {
r, err := mathutil.NewFCBig(r64lo, r64hi, true)
if err != nil {
panic(err)
}
return r
}
func TestMod(t *testing.T) {
const N = 1e4
data := []struct {
mod, n int64
exp uint32
}{
{0, 0x00, 3},
{1, 0x01, 3},
{3, 0x03, 3},
{0, 0x07, 3},
{1, 0x0f, 3},
{3, 0x1f, 3},
{0, 0x3f, 3},
{1, 0x7f, 3},
{3, 0xff, 3},
{0, 0x1ff, 3},
}
var mod, n big.Int
for _, v := range data {
n.SetInt64(v.n)
p := Mod(&mod, &n, v.exp)
if p != &mod {
t.Fatal(p)
}
if g, e := mod.Int64(), v.mod; g != e {
t.Fatal(v.n, v.exp, g, e)
}
}
f := func(in int64, exp uint32) {
n.SetInt64(in)
mod.Mod(&n, New(exp))
e := mod.Int64()
Mod(&mod, &n, exp)
g := mod.Int64()
if g != e {
t.Fatal(in, exp, g, e)
}
}
r32, _ := mathutil.NewFC32(1, 1e6, true)
r64, _ := mathutil.NewFCBig(_0, big.NewInt(math.MaxInt64), true)
for i := 0; i < N; i++ {
f(r64.Next().Int64(), uint32(r32.Next()))
}
}