wip math

ethutil/big.go

@@ -33,6 +33,12 @@ func Bytes2Big(data []byte) *big.Int {
 }
 func BigD(data []byte) *big.Int { return Bytes2Big(data) }
 
+func String2Big(num string) *big.Int {
+	n := new(big.Int)
+	n.SetString(num, 0)
+	return n
+}
+
 func BitTest(num *big.Int, i int) bool {
 	return num.Bit(i) > 0
 }

ethutil/math/dist.go

@@ -0,0 +1,80 @@
+package math
+
+import (
+	"math/big"
+	"sort"
+
+	"github.com/ethereum/go-ethereum/ethutil"
+)
+
+type Summer interface {
+	Sum(i int) *big.Int
+	Len() int
+}
+
+func Sum(slice Summer) (sum *big.Int) {
+	sum = new(big.Int)
+
+	for i := 0; i < slice.Len(); i++ {
+		sum.Add(sum, slice.Sum(i))
+	}
+	return
+}
+
+type Vector struct {
+	Gas, Price *big.Int
+}
+
+type VectorsBy func(v1, v2 Vector) bool
+
+func (self VectorsBy) Sort(vectors []Vector) {
+	bs := vectorSorter{
+		vectors: vectors,
+		by:      self,
+	}
+	sort.Sort(bs)
+}
+
+type vectorSorter struct {
+	vectors []Vector
+	by      func(v1, v2 Vector) bool
+}
+
+func (v vectorSorter) Len() int           { return len(v.vectors) }
+func (v vectorSorter) Less(i, j int) bool { return v.by(v.vectors[i], v.vectors[j]) }
+func (v vectorSorter) Swap(i, j int)      { v.vectors[i], v.vectors[j] = v.vectors[j], v.vectors[i] }
+
+func PriceSort(v1, v2 Vector) bool { return v1.Price.Cmp(v2.Price) < 0 }
+func GasSort(v1, v2 Vector) bool   { return v1.Gas.Cmp(v2.Gas) < 0 }
+
+type vectorSummer struct {
+	vectors []Vector
+	by      func(v Vector) *big.Int
+}
+
+type VectorSum func(v Vector) *big.Int
+
+func (v VectorSum) Sum(vectors []Vector) *big.Int {
+	vs := vectorSummer{
+		vectors: vectors,
+		by:      v,
+	}
+	return Sum(vs)
+}
+
+func (v vectorSummer) Len() int           { return len(v.vectors) }
+func (v vectorSummer) Sum(i int) *big.Int { return v.by(v.vectors[i]) }
+
+func GasSum(v Vector) *big.Int { return v.Gas }
+
+var etherInWei = new(big.Rat).SetInt(ethutil.String2Big("1000000000000000000"))
+
+func GasPrice(bp, gl, ep *big.Int) *big.Int {
+	BP := new(big.Rat).SetInt(bp)
+	GL := new(big.Rat).SetInt(gl)
+	EP := new(big.Rat).SetInt(ep)
+	GP := new(big.Rat).Quo(BP, GL)
+	GP = GP.Quo(GP, EP)
+
+	return GP.Mul(GP, etherInWei).Num()
+}

ethutil/math/dist_test.go

@@ -0,0 +1,66 @@
+package math
+
+import (
+	"fmt"
+	"math/big"
+	"testing"
+)
+
+type summer struct {
+	numbers []*big.Int
+}
+
+func (s summer) Len() int { return len(s.numbers) }
+func (s summer) Sum(i int) *big.Int {
+	return s.numbers[i]
+}
+
+func TestSum(t *testing.T) {
+	summer := summer{numbers: []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}}
+	sum := Sum(summer)
+	if sum.Cmp(big.NewInt(6)) != 0 {
+		t.Errorf("not 6", sum)
+	}
+}
+
+func TestDist(t *testing.T) {
+	var vectors = []Vector{
+		Vector{big.NewInt(1000), big.NewInt(1234)},
+		Vector{big.NewInt(500), big.NewInt(10023)},
+		Vector{big.NewInt(1034), big.NewInt(1987)},
+		Vector{big.NewInt(1034), big.NewInt(1987)},
+		Vector{big.NewInt(8983), big.NewInt(1977)},
+		Vector{big.NewInt(98382), big.NewInt(1887)},
+		Vector{big.NewInt(12398), big.NewInt(1287)},
+		Vector{big.NewInt(12398), big.NewInt(1487)},
+		Vector{big.NewInt(12398), big.NewInt(1987)},
+		Vector{big.NewInt(12398), big.NewInt(128)},
+		Vector{big.NewInt(12398), big.NewInt(1987)},
+		Vector{big.NewInt(1398), big.NewInt(187)},
+		Vector{big.NewInt(12328), big.NewInt(1927)},
+		Vector{big.NewInt(12398), big.NewInt(1987)},
+		Vector{big.NewInt(22398), big.NewInt(1287)},
+		Vector{big.NewInt(1370), big.NewInt(1981)},
+		Vector{big.NewInt(12398), big.NewInt(1957)},
+		Vector{big.NewInt(42198), big.NewInt(1987)},
+	}
+
+	VectorsBy(GasSort).Sort(vectors)
+	fmt.Println(vectors)
+
+	BP := big.NewInt(15)
+	GL := big.NewInt(1000000)
+	EP := big.NewInt(100)
+	fmt.Println("BP", BP, "GL", GL, "EP", EP)
+	GP := GasPrice(BP, GL, EP)
+	fmt.Println("GP =", GP, "Wei per GU")
+
+	S := len(vectors) / 4
+	fmt.Println("L", len(vectors), "S", S)
+	for i := 1; i <= S*4; i += S {
+		fmt.Printf("T%d = %v\n", i, vectors[i])
+	}
+
+	g := VectorSum(GasSum).Sum(vectors)
+	fmt.Printf("G = ∑g* (%v)\n", g)
+}