Ejemplo n.º 1
0
func scalar2big(out *big.Int, in *[4]C.ulonglong) {
	bits := make([]big.Word, 8)
	for i := 0; i < len(bits); i += 2 {
		bits[i] = big.Word(in[i>>1] & 0x00000000ffffffff)
		bits[i+1] = big.Word((in[i>>1] & 0xffffffff00000000) >> 32)
	}
	out.SetBits(bits)
}
Ejemplo n.º 2
0
// Credit for this func: Hugo Peixoto (https://github.com/hugopeixoto)
func (key *KeyID) add2nModK(n int, k int) *KeyID {
	words := key.integer.Bits()
	extended := make([]big.Word, (k+_W-1)/_W)
	copy(extended, words)

	for n/_W < k {
		i := n / _W
		w := extended[i]

		new_w := w + (big.Word(1) << uint(n-i*_W))
		extended[i] = new_w

		if new_w < w {
			n = (i + 1) * _W
		} else {
			break
		}
	}

	result := big.NewInt(0).SetBits(extended)
	hex := fmt.Sprintf("%040x", result)

	return &KeyID{
		hex:     hex,
		integer: result,
	}
}
Ejemplo n.º 3
0
func scalar2big(out *big.Int, in *[4]C.ulonglong) {
	bits := make([]big.Word, 4)
	for i := range bits {
		bits[i] = big.Word(in[i])
	}
	out.SetBits(bits)
}
Ejemplo n.º 4
0
Archivo: value.go Proyecto: 2thetop/go
// MakeFromBytes returns the Int value given the bytes of its little-endian
// binary representation. An empty byte slice argument represents 0.
func MakeFromBytes(bytes []byte) Value {
	words := make([]big.Word, (len(bytes)+(wordSize-1))/wordSize)

	i := 0
	var w big.Word
	var s uint
	for _, b := range bytes {
		w |= big.Word(b) << s
		if s += 8; s == wordSize*8 {
			words[i] = w
			i++
			w = 0
			s = 0
		}
	}
	// store last word
	if i < len(words) {
		words[i] = w
		i++
	}
	// remove leading 0's
	for i > 0 && words[i-1] == 0 {
		i--
	}

	return makeInt(newInt().SetBits(words[:i]))
}
Ejemplo n.º 5
0
// Big produces a uniformly distributed random positive number up to nbits bits
// in length. It panics if nbits <= 0.
func (r RNG) Big(nbits int) *big.Int {
	if nbits <= 0 {
		panic("maximum zero or below")
	}
	var p []big.Word
	if ^big.Word(0) != 0xffffffff {
		// 64-bit
		n := nbits >> 6
		if nbits&63 != 0 {
			n++
		}
		p = make([]big.Word, n)
		for i := range p {
			p[i] = big.Word(r.Uint64())
		}
		p[0] &= 0xffffffffffffffff >> big.Word(64-nbits&63)
	} else {
		// 32-bit
		n := nbits >> 5
		if nbits&31 != 0 {
			n++
		}
		p = make([]big.Word, n)
		for i := 1; i < len(p); i += 2 {
			// Use each value for two words.
			x := r.Uint64()
			p[i-1] = big.Word(x)
			p[i] = big.Word(x >> 32)
		}
		p[n-1] = big.Word(r.Uint64())
		p[0] &= 0xffffffff >> big.Word(32-nbits&31)
	}
	return new(big.Int).SetBits(p)
}
Ejemplo n.º 6
0
// TrailingOnesBig returns the number of trailing 1 bits in v.
func TrailingOnesBig(v *big.Int) int {
	words := v.Bits()
	for i, b := range words {
		if b != ^big.Word(0) {
			return i*wordBits + tzw(^b)
		}
	}
	return len(words) * wordBits
}
Ejemplo n.º 7
0
// reads num into buf as big-endian bytes.
func readBits(buf []byte, num *big.Int) {
	const wordLen = int(unsafe.Sizeof(big.Word(0)))
	i := len(buf)
	for _, d := range num.Bits() {
		for j := 0; j < wordLen && i > 0; j++ {
			i--
			buf[i] = byte(d)
			d >>= 8
		}
	}
}
Ejemplo n.º 8
0
// Shift computes (x << k) mod (2^n+1).
func (z fermat) Shift(x fermat, k int) {
	if len(z) != len(x) {
		println(len(z), len(x))
		panic("len(z) != len(x) in Shift")
	}
	n := len(x) - 1
	// Shift by n*_W is taking the opposite.
	k %= 2 * n * _W
	if k < 0 {
		k += 2 * n * _W
	}
	neg := false
	if k >= n*_W {
		k -= n * _W
		neg = true
	}

	kw, kb := k/_W, k%_W

	z[n] = 1 // Add (-1)
	if !neg {
		for i := 0; i < kw; i++ {
			z[i] = 0
		}
		// Shift left by kw words.
		// x = a·2^(n-k) + b
		// x<<k = (b<<k) - a
		copy(z[kw:], x[:n-kw])
		b := subVV(z[:kw+1], z[:kw+1], x[n-kw:])
		if z[kw+1] > 0 {
			z[kw+1] -= b
		} else {
			subVW(z[kw+1:], z[kw+1:], b)
		}
	} else {
		for i := kw + 1; i < n; i++ {
			z[i] = 0
		}
		// Shift left and negate, by kw words.
		copy(z[:kw+1], x[n-kw:n+1])            // z_low = x_high
		b := subVV(z[kw:n], z[kw:n], x[:n-kw]) // z_high -= x_low
		z[n] -= b
	}
	// Add back 1.
	if z[0] < ^big.Word(0) {
		z[0]++
	} else {
		addVW(z, z, 1)
	}
	// Shift left by kb bits
	shlVU(z, z, uint(kb))
	z.norm()
}
Ejemplo n.º 9
0
func NewConnection(file string, callback uvr1611.PacketCallback) *gpio {
	pin, err := InitGPIO(file)
	if err != nil {
		log.Fatal(err)
	}

	packetReceiver := uvr1611.NewPacketReceiver()
	packetDecoder := uvr1611.NewPacketDecoder(packetReceiver)
	byteDecoder := uvr.NewByteDecoder(packetDecoder, uvr.NewTimeout(488.0, 0.4))
	syncDecoder := uvr1611.NewSyncDecoder(byteDecoder, byteDecoder, uvr.NewTimeout(488.0*2, 0.4))
	signal := uvr.NewSignal(syncDecoder)

	pin_callback := func(pin embd.DigitalPin) {
		value, read_err := pin.Read()
		if read_err != nil {
			fmt.Println(read_err)
		} else {
			signal.Consume(big.Word(value))
		}
	}

	packetReceiver.RegisterCallback(func(packet uvr1611.Packet) {
		if callback != nil {
			callback(packet)
		}

		// Stop watching the pin and let other threads do their job
		pin.StopWatching()
		syncDecoder.Reset()
		byteDecoder.Reset()
		packetDecoder.Reset()

		// Rewatch after 10 seconds again
		time.AfterFunc(30*time.Second, func() {
			pin.Watch(embd.EdgeBoth, pin_callback)
			if err != nil {
				log.Fatal("Could not watch pin.", err)
			}
		})
	})

	err = pin.Watch(embd.EdgeBoth, pin_callback)
	if err != nil {
		log.Fatal("Could not watch pin.", err)
	}

	return &gpio{
		pin: pin,
	}
}
Ejemplo n.º 10
0
// Takes a slice of alphabet.Letter and returns the big.Int binary
// representation of that sequence.
func lettersToBigInt(seq alphabet.Letters) (*big.Int, error) {
	out := big.NewInt(0)
	words := make([]big.Word, len(seq)/33+1)
	for i := range seq {
		index := alphabet.DNA.IndexOf(seq[len(seq)-i-1])
		if index < 0 {
			return out, fmt.Errorf("Sequence is not a valid DNA sequence at position %d\n", i+1)
		} else {
			wordIndex := i / 32
			shiftDist := uint(i-wordIndex*32) * 2
			words[wordIndex] |= big.Word(index << shiftDist)
		}
	}
	return out.SetBits(words), nil
}
Ejemplo n.º 11
0
// Sub computes substraction mod 2^n+1.
func (z fermat) Sub(x, y fermat) fermat {
	if len(z) != len(x) {
		panic("Add: len(z) != len(x)")
	}
	n := len(y) - 1
	b := subVV(z[:n], x[:n], y[:n])
	b += y[n]
	// If b > 0, we need to subtract b<<n, which is the same as adding b.
	z[n] = x[n]
	if z[0] <= ^big.Word(0)-b {
		z[0] += b
	} else {
		addVW(z, z, b)
	}
	z.norm()
	return z
}
Ejemplo n.º 12
0
// copyWords was adapted from math/big/nat.go. It writes the value of
// nat into buf using big-endian encoding. len(buf) must be >= len(nat)*bigWordSize.
func copyWords(buf []byte, nat []big.Word) []byte {
	// Omit leading zeros from the resulting byte slice, which is both
	// safe and exactly what big.Int.Bytes() does. See big.nat.setBytes()
	// and big.nat.norm() for how this is normalized on decoding.
	leading := true
	for w := len(nat) - 1; w >= 0; w-- {
		d := nat[w]
		for j := bigWordSize - 1; j >= 0; j-- {
			by := byte(d >> (8 * big.Word(j)))
			if by == 0 && leading {
				continue
			}
			leading = false
			buf = append(buf, by)
		}
	}
	return buf
}
Ejemplo n.º 13
0
func (bin *CortexVarBinary) NextKmer() (*colouredKmer.Kmer, error) {
	kmer := colouredKmer.Kmer{
		Int:       big.NewInt(0),
		Coverages: make([]uint32, bin.ColourCount),
		Edges:     make([]uint8, bin.ColourCount),
	}

	bits := make([]uint64, bin.wordsPerKmer)
	err := bin.read(&bits)
	if err != nil {
		return &kmer, err
	}
	words := make([]big.Word, bin.wordsPerKmer)
	for i, v := range bits {
		words[i] = big.Word(v)
	}
	kmer.SetBits(words)
	bin.read(kmer.Coverages)
	bin.read(kmer.Edges)
	return &kmer, nil
}
Ejemplo n.º 14
0
func (r *AllocationBitmap) Release(offset int) error {
	r.lock.Lock()
	defer r.lock.Unlock()

	if r.allocated.Bit(offset) == 0 {
		return nil
	}

	r.allocated = r.allocated.SetBit(r.allocated, offset, 0)
	r.count--
	return nil
}

const (
	// Find the size of a big.Word in bytes.
	notZero   = uint64(^big.Word(0))
	wordPower = (notZero>>8)&1 + (notZero>>16)&1 + (notZero>>32)&1
	wordSize  = 1 << wordPower
)

// ForEach calls the provided function for each allocated bit.  The
// AllocationBitmap may not be modified while this loop is running.
func (r *AllocationBitmap) ForEach(fn func(int)) {
	r.lock.Lock()
	defer r.lock.Unlock()

	words := r.allocated.Bits()
	for wordIdx, word := range words {
		bit := 0
		for word > 0 {
			if (word & 1) != 0 {
Ejemplo n.º 15
0
Archivo: value.go Proyecto: 2thetop/go
		return x.val.Sign()
	case complexVal:
		return Sign(x.re) | Sign(x.im)
	case unknownVal:
		return 1 // avoid spurious division by zero errors
	default:
		panic(fmt.Sprintf("%v not numeric", x))
	}
}

// ----------------------------------------------------------------------------
// Support for assembling/disassembling numeric values

const (
	// Compute the size of a Word in bytes.
	_m       = ^big.Word(0)
	_log     = _m>>8&1 + _m>>16&1 + _m>>32&1
	wordSize = 1 << _log
)

// Bytes returns the bytes for the absolute value of x in little-
// endian binary representation; x must be an Int.
func Bytes(x Value) []byte {
	var t intVal
	switch x := x.(type) {
	case int64Val:
		t = i64toi(x)
	case intVal:
		t = x
	default:
		panic(fmt.Sprintf("%v not an Int", x))
Ejemplo n.º 16
0
// Size implements the Datum interface.
func (d *DDecimal) Size() uintptr {
	intVal := d.Dec.UnscaledBig()
	return unsafe.Sizeof(*d) + uintptr(cap(intVal.Bits()))*unsafe.Sizeof(big.Word(0))
}
Ejemplo n.º 17
0
	nDigits, _ := numDigits(bi, tmp)
	dec.SetScale(inf.Scale(nDigits))
}

// UpperBoundNonsortingDecimalSize returns the upper bound number of bytes
// that the decimal will need for the non-sorting encoding.
func UpperBoundNonsortingDecimalSize(d *inf.Dec) int {
	// Makeup of upper bound size:
	// - 1 byte for the prefix
	// - maxVarintSize for the exponent
	// - wordLen for the big.Int bytes
	return 1 + maxVarintSize + wordLen(d.UnscaledBig().Bits())
}

// Taken from math/big/arith.go.
const bigWordSize = int(unsafe.Sizeof(big.Word(0)))

func wordLen(nat []big.Word) int {
	return len(nat) * bigWordSize
}

// copyWords was adapted from math/big/nat.go. It writes the value of
// nat into buf using big-endian encoding. len(buf) must be >= len(nat)*bigWordSize.
func copyWords(buf []byte, nat []big.Word) []byte {
	// Omit leading zeros from the resulting byte slice, which is both
	// safe and exactly what big.Int.Bytes() does. See big.nat.setBytes()
	// and big.nat.norm() for how this is normalized on decoding.
	leading := true
	for w := len(nat) - 1; w >= 0; w-- {
		d := nat[w]
		for j := bigWordSize - 1; j >= 0; j-- {
Ejemplo n.º 18
0
var deBruijn64Bits = []byte{
	0, 1, 56, 2, 57, 49, 28, 3, 61, 58, 42, 50, 38, 29, 17, 4,
	62, 47, 59, 36, 45, 43, 51, 22, 53, 39, 33, 30, 24, 18, 12, 5,
	63, 55, 48, 27, 60, 41, 37, 16, 46, 35, 44, 21, 52, 32, 23, 11,
	54, 26, 40, 15, 34, 20, 31, 10, 25, 14, 19, 9, 13, 8, 7, 6,
}

// TrailingZeros64 returns the number of trailing 0 bits in v.
//
// If v is 0, it returns 0.
func TrailingZeros64(v uint64) byte {
	return deBruijn64Bits[v&-v*deBruijn64Multiple>>deBruijn64Shift]
}

// works for 32 and 64 anyway
const wordBits = int((^big.Word(0))>>32&1+1) * 32

var tzw func(big.Word) int

func init() {
	switch wordBits {
	case 32:
		tzw = func(w big.Word) int { return int(TrailingZeros32(uint32(w))) }
	case 64:
		tzw = func(w big.Word) int { return int(TrailingZeros64(uint64(w))) }
	}
}

// TrailingZerosBig returns the number of trailing 0 bits in v.
//
// If v is 0, it returns 0.
Ejemplo n.º 19
0
Archivo: flag.go Proyecto: jloup/utils
// Package flag provides a simple flag utility
package utils

import (
	"math/big"
)

// const taken from math/big package
const (
	_word0    = big.Word(0)
	_word1    = ^_word0
	_logS     = _word1>>8&1 + _word1>>16&1 + _word1>>32&1
	_S        = 1 << _logS
	_WORDSIZE = _S << 3
)

type Flag struct {
	N    big.Int
	name string
}

var zero big.Int

// Print Flag's name
func (f Flag) String() string {
	return f.name
}

// Check that Flags have the same underlying value
func (f Flag) Cmp(flag Flag) bool {
	return f.N.Cmp(&flag.N) == 0
Ejemplo n.º 20
0
Archivo: fibo.go Proyecto: 2thetop/go
	"text/tabwriter"
	"time"
)

var (
	bench = flag.Bool("bench", false, "run benchmarks")
	half  = flag.Bool("half", false, "use half-digit addition")
	opt   = flag.Bool("opt", false, "optimize memory usage")
	short = flag.Bool("short", false, "only print first 10 digits of result")
)

// A large natural number is represented by a nat, each "digit" is
// a big.Word; the value zero corresponds to the empty nat slice.
type nat []big.Word

const W = 1 << (5 + ^big.Word(0)>>63) // big.Word size in bits

// The following methods are extracted from math/big to make this a
// stand-alone program that can easily be run without dependencies
// and compiled with different compilers.

func (z nat) make(n int) nat {
	if n <= cap(z) {
		return z[:n] // reuse z
	}
	// Choosing a good value for e has significant performance impact
	// because it increases the chance that a value can be reused.
	const e = 4 // extra capacity
	return make(nat, n, n+e)
}