--- /dev/null
+package btmhash
+
+import (
+ "encoding/binary"
+ "fmt"
+ "hash"
+ "reflect"
+ "sync/atomic"
+ "unsafe"
+
+ "github.com/ethereum/go-ethereum/common/bitutil"
+ "golang.org/x/crypto/sha3"
+
+ "btmhash/matrix"
+)
+
+const (
+ epochLength = 128 // Blocks per epoch
+ hashBytes = 64 // Hash length in bytes
+ cacheRounds = 3 // Number of rounds in cache production
+)
+
+const (
+ matSize = 1 << 9 // Size of matrix
+ matNum = 1 << 7 // Number of matrix
+ round = 10
+ cacheLength = matSize * matSize * matNum // Bytes of cache production
+)
+
+var (
+ nonce []uint64 = make([]uint64, 4)
+)
+
+// hasher is a repetitive hasher allowing the same hash data structures to be
+// reused between hash runs instead of requiring new ones to be created.
+type hasher func(dest []byte, data []byte)
+
+// makeHasher creates a repetitive hasher, allowing the same hash data structures
+// to be reused between hash runs instead of requiring new ones to be created.
+// The returned function is not thread safe!
+func makeHasher(h hash.Hash) hasher {
+ return func(dest []byte, data []byte) {
+ h.Write(data)
+ h.Sum(dest[:0])
+ h.Reset()
+ }
+}
+
+// seedHash is the seed to use for generating a verification cache and the mining
+// dataset.
+func seedHash(block uint64) []byte {
+ seed := make([]byte, 32)
+ if block < epochLength {
+ return seed
+ }
+ sha256 := makeHasher(sha3.New256())
+ for i := 0; i < int(block/epochLength); i++ {
+ sha256(seed, seed)
+ }
+ return seed
+}
+
+// block contain all the block header data.
+// 现在先产生0序列为区块号的种子。等并入主链的时候建议将每个窗口期的区块哈希值合并，
+// 然后将前一个种子合并，对结合体进行哈希操作，从而得到当前窗口期的种子
+func createSeed(block []byte) []byte {
+ seed := make([]byte, 32)
+ sha256 := makeHasher(sha3.New256())
+ sha256(seed, block)
+ return seed
+}
+
+// generateCache creates a verification cache of a given size for an input seed.
+// The cache production process involves first sequentially filling up 32 MB of
+// memory, then performing two passes of Sergio Demian Lerner's RandMemoHash
+// algorithm from Strict Memory Hard Hashing Functions (2014). The output is a
+// set of 524288 64-byte values.
+// This method places the result into dest in machine byte order.
+func generateCache(dest []uint32, seed []byte) {
+ // Convert our destination slice to a byte buffer
+ header := *(*reflect.SliceHeader)(unsafe.Pointer(&dest))
+ header.Len *= 4
+ header.Cap *= 4
+ cache := *(*[]byte)(unsafe.Pointer(&header))
+
+ // Calculate the number of thoretical rows (we'll store in one buffer nonetheless)
+ size := uint64(len(cache))
+ rows := int(size) / hashBytes
+
+ // Start a monitoring goroutine to report progress on low end devices
+ var progress uint32
+
+ done := make(chan struct{})
+ defer close(done)
+
+ sha512 := makeHasher(sha3.New512())
+
+ // Sequentially produce the initial dataset
+ sha512(cache, seed)
+ for offset := uint64(hashBytes); offset < size; offset += hashBytes {
+ sha512(cache[offset:], cache[offset-hashBytes:offset])
+ atomic.AddUint32(&progress, 1)
+ }
+ // Use a low-round version of randmemohash
+ temp := make([]byte, hashBytes)
+
+ for i := 0; i < cacheRounds; i++ {
+ for j := 0; j < rows; j++ {
+ var (
+ srcOff = ((j - 1 + rows) % rows) * hashBytes
+ dstOff = j * hashBytes
+ xorOff = (binary.LittleEndian.Uint32(cache[dstOff:]) % uint32(rows)) * hashBytes
+ )
+ bitutil.XORBytes(temp, cache[srcOff:srcOff+hashBytes], cache[xorOff:xorOff+hashBytes])
+ sha512(cache[dstOff:], temp)
+
+ atomic.AddUint32(&progress, 1)
+ }
+ }
+ // Swap the byte order on big endian systems and return
+ if !isLittleEndian() {
+ swap(cache)
+ }
+}
+
+// isLittleEndian returns whether the local system is running in little or big
+// endian byte order.
+func isLittleEndian() bool {
+ n := uint32(0x01020304)
+ return *(*byte)(unsafe.Pointer(&n)) == 0x04
+}
+
+// swap changes the byte order of the buffer assuming a uint32 representation.
+func swap(buffer []byte) {
+ for i := 0; i < len(buffer); i += 4 {
+ binary.BigEndian.PutUint32(buffer[i:], binary.LittleEndian.Uint32(buffer[i:]))
+ }
+}
+
+// 从cache中选择数据填充到矩阵中，选择数据的方式
+func fillMatrixList(matList []matrix.Matrix, cache []uint32, blockNum uint64) {
+ //var block uint64 = 0
+ // var epoch uint64 = block / epochLength
+ var locationIndex uint64 = blockNum % epochLength
+
+ // Convert our destination slice to a byte buffer
+ header := *(*reflect.SliceHeader)(unsafe.Pointer(&cache))
+ header.Len *= 4
+ header.Cap *= 4
+ cacheInt8 := *(*[]int8)(unsafe.Pointer(&header))
+
+ //fmt.Println("cacheInt8 is:", cacheInt8)
+
+ for i := 0; i < matNum; i++ {
+ startIndex := (matSize*matSize*i + location[locationIndex]) % cacheLength
+ endIndex := (matSize*matSize*(i+1) + location[locationIndex]) % cacheLength
+ if startIndex < endIndex {
+ matList[i] = matrix.New(matSize, matSize, cacheInt8[startIndex:endIndex])
+ } else {
+ matrixData := make([]int8, matSize*matSize)
+ copy(matrixData, cacheInt8[startIndex:])
+ copy(matrixData[cacheLength-startIndex:], cacheInt8[:endIndex+1])
+ matList[i] = matrix.New(matSize, matSize, matrixData)
+ }
+ }
+
+ fmt.Println("Print the matrix!")
+
+ // for i := 0; i < matNum; i++ {
+ // fmt.Println("No.", i)
+ // matList[i].Print()
+ // }
+
+ fmt.Println("fill the matrix list!")
+ fmt.Println("block number is:", blockNum)
+ fmt.Println("locationIndex is:", locationIndex)
+ fmt.Println("location[block % epochLength] is:", location[blockNum%epochLength])
+}
+
+func getIndex(blockHeader []byte) []byte {
+ sha256 := makeHasher(sha3.New256())
+ matIndex := make([]byte, 32)
+ sha256(matIndex, blockHeader)
+
+ return matIndex
+}
+
+func mulMatrix(matList []matrix.Matrix, matIndex []byte) *matrix.Matrix {
+ var index uint8
+ ma := matrix.Zeros(matSize, matSize)
+ mb := matrix.Zeros(matSize, matSize)
+
+ for i := 1; i <= matSize; i++ {
+ for j := 1; j <= matSize; j++ {
+ mb.Set(i, j, matList[0].Get(i, j))
+ }
+ }
+ fmt.Println("--------------------------------------------------")
+ fmt.Println("initial mb is:")
+ // mb.Print()
+
+ fmt.Println("matIndex is:", matIndex)
+
+ //
+ indexnum := make([]uint16, 128)
+
+ for i := 0; i < round; i++ {
+ index = uint8(matIndex[2*i]) % matNum
+ indexnum[index]++
+ fmt.Println("round is:", i, "; index is:", index)
+ ma = *matrix.Multiply(matList[index], mb)
+
+ index = uint8(matIndex[2*i+1]) % matNum
+ indexnum[index]++
+ fmt.Println("round is:", i, "; index is:", index)
+ mb = *matrix.Multiply(ma, matList[index])
+ }
+
+ fmt.Println("----------------------------------------\nindexnum is:", indexnum)
+
+ return &mb
+}
+
+var location = []int{
+ 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
+ 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137,
+ 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227,
+ 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
+ 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
+ 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509,
+ 523, 541, 571, 601, 613, 619, 643, 661, 691, 709, 739, 751, 769, 823, 829, 859,
+ 991, 1021, 1033, 1069, 1129, 1153, 1171, 1213, 1231, 1321, 1399, 1423, 1453, 1459, 1483, 1489}
--- /dev/null
+package btmhash
+
+import (
+ //"encoding/binary"
+ "fmt"
+ "reflect"
+ "strings"
+ "time"
+ "unsafe"
+
+ "golang.org/x/crypto/sha3"
+
+ "btmhash/matrix"
+)
+
+/*
+ "7ce2991c951f7bf4c4c1bb119887ee07871eb5339d7b97b8588e85c742de90e5bafd5bbe6ce93a134fb6be9ad3e30db99d9528a2ea7846833f52e9ca119b6b54" +
+ "8979480c46e19972bd0738779c932c1b43e665a2fd3122fc3ddb2691f353ceb0ed3e38b8f51fd55b6940290743563c9f8fa8822e611924657501a12aafab8a8d" +
+ "88fb5fbae3a99d14792406672e783a06940a42799b1c38bc28715db6d37cb11f9f6b24e386dc52dd8c286bd8c36fa813dffe4448a9f56ebcbeea866b42f68d22" +
+ "6c32aae4d695a23cab28fd74af53b0c2efcc180ceaaccc0b2e280103d097a03c1d1b0f0f26ce5f32a90238f9bc49f645db001ef9cd3d13d44743f841fad11a37" +
+ "fa290c62c16042f703578921f30b9951465aae2af4a5dad43a7341d7b4a62750954965a47a1c3af638dc3495c4d62a9bab843168c9fc0114e79cffd1b2827b01" +
+ "75d30ba054658f214e946cf24c43b40d3383fbb0493408e5c5392434ca21bbcf43200dfb876c713d201813934fa485f48767c5915745cf0986b1dc0f33e57748" +
+ "bf483ee2aff4248dfe461ec0504a13628401020fc22638584a8f2f5206a13b2f233898c78359b21c8226024d0a7a93df5eb6c282bdbf005a4aab497e096f2847" +
+ "76c71cee57932a8fb89f6d6b8743b60a4ea374899a94a2e0f218d5c55818cefb1790c8529a76dba31ebb0f4592d709b49587d2317970d39c086f18dd244291d9" +
+ "eedb16705e53e3350591bd4ff4566a3595ac0f0ce24b5e112a3d033bc51b6fea0a92296dea7f5e20bf6ee6bc347d868fda193c395b9bb147e55e5a9f67cfe741" +
+ "7eea7d699b155bd13804204df7ea91fa9249e4474dddf35188f77019c67d201e4c10d7079c5ad492a71afff9a23ca7e900ba7d1bdeaf3270514d8eb35eab8a0a" +
+ "718bb7273aeb37768fa589ed8ab01fbf4027f4ebdbbae128d21e485f061c20183a9bc2e31edbda0727442e9d58eb0fe198440fe199e02e77c0f7b99973f1f74c" +
+ "c9089a51ab96c94a84d66e6aa48b2d0a4543adb5a789039a2aa7b335ca85c91026c7d3c894da53ae364188c3fd92f78e01d080399884a47385aa792e38150cda" +
+ "a8620b2ebeca41fbc773bb837b5e724d6eb2de570d99858df0d7d97067fb8103b21757873b735097b35d3bea8fd1c359a9e8a63c1540c76c9784cf8d975e995c" +
+ "778401b94a2e66e6993ad67ad3ecdc2acb17779f1ea8606827ec92b11c728f8c3b6d3f04a3e6ed05ff81dd76d5dc5695a50377bc135aaf1671cf68b750315493" +
+ "6c64510164d53312bf3c41740c7a237b05faf4a191bd8a95dafa068dbcf370255c725900ce5c934f36feadcfe55b687c440574c1f06f39d207a8553d39156a24" +
+ "845f64fd8324bb85312979dead74f764c9677aab89801ad4f927f1c00f12e28f22422bb44200d1969d9ab377dd6b099dc6dbc3222e9321b2c1e84f8e2f07731c")
+*/
+
+/*
+ "1f56855d59cc5a085720899b4377a0198f1abe948d85fe5820dc0e346b7c0931b9cde8e541d751de3b2b3275d0aabfae316209d5879297d8bd99f8a033c9d4df" +
+ "35add1029f4e6404a022d504fb8023e42989aba985a65933b0109c7218854356f9284983c9e7de97de591828ae348b63d1fc78d8db58157344d4e06530ffd422" +
+ "5c7f6080d451ff94961ec2dd9e28e6d81b49102451676dbdcb6ef1094c1e8b29e7e808d47b2ba5aeb52dabf00d5f0ee08c116289cbf56d8132e5ca557c3d6220" +
+ "5ba3a48539acabfd4ca3c89e3aaa668e24ffeaeb9eb0136a9fc5a8a676b6d5ad76175eeda0a1fa44b5ff5591079e4b7f581569b6c82416adcb82d7e92980df67" +
+ "2248c4024013e7be52cf91a82491627d9e6d80eda2770ab82badc5e120cd33a4c84495f718b57396a8f397e797087fad81fa50f0e2f5da71e40816a85de35a96" +
+ "3cd351364905c45b3116ff25851d43a2ca1d2aa5cdb408440dabef8c57778fc18608bf431d0c7ffd37649a21a7bb9d90def39c821669dbaf165c0262434dfb08" +
+ "5d057a12de4a7a59fd2dfc931c29c20371abf748b69b618a9bd485b3fb3166cad4d3d27edf0197aabeceb28b96670bdf020f26d1bb9b564aaf82d866bdffd6d4" +
+ "1aea89e20b15a5d1264ab01d1556bfc2a266081609d60928216bd9646038f07de9fedcc9f2b86ab1b07d7bd88ba1df08b3d89b2ac789001b48a723f217debcb7" +
+ "090303a3ef50c1d5d99a75c640ec2b401ab149e06511753d8c49cafdde2929ae61e09cc0f0319d262869d21ead9e0cf5ff2de3dbedfb994f32432d2e4aa44c82" +
+ "7c42781d1477fe03ea0772998e776d63363c6c3edd2d52c89b4d2c9d89cdd90fa33b2b41c8e3f78ef06fe90bcf5cc5756d33a032f16b744141aaa8852bb4cb3a" +
+ "40792b93489c6d6e56c235ec4aa36c263e9b766a4daaff34b2ea709f9f811aef498a65bfbc1deffd36fcc4d1a123345fac7bf57a1fb50394843cd28976a6c7ff" +
+ "fe70f7b8d8f384aa06e2c9964c92a8788cef397fffdd35181b42a35d5d98cd7244bbd09e802888d7efc0311ae58e0961e3656205df4bdc553f317df4b6ede4ca" +
+ "846294a32aec830ab1aa5aac4e78b821c35c70fd752fec353e373bf9be656e775a0111bcbeffdfebd3bd5251d27b9f6971aa561a2bd27a99d61b2ce3965c3726" +
+ "1e114353e6a31b09340f4078b8a8c6ce6ff4213067a8f21020f78aff4f8b472b701ef730aacb8ce7806ea31b14abe8f8efdd6357ca299d339abc4e43ba324ad1" +
+ "efe6eb1a5a6e137daa6ec9f6be30931ca368a944cfcf2a0a29f9a9664188f0466e6f078c347f9fe26a9a89d2029462b19245f24ace47aecace6ef85a4e96b31b" +
+ "5f470eb0165c6375eb8f245d50a25d521d1e569e3b2dccce626752bb26eae624a24511e831a81fab6898a791579f462574ca4851e6588116493dbccc3072e0c5")
+*/
+
+func TestBtmhash() {
+ fmt.Println("\n----------test btmhash--------------------")
+ start := time.Now()
+
+ //seed := seedHash(0)
+ var blockNum uint64 = 1
+ blockHash := make([]byte, 32)
+ seed := createSeed(blockHash)
+ endSeedHash := time.Now()
+ deltaSeedHash := endSeedHash.Sub(start)
+
+ cache := make([]uint32, cacheLength/4)
+ generateCache(cache, seed)
+ endGenerateCache := time.Now()
+ deltaGenerateCache := endGenerateCache.Sub(endSeedHash)
+
+ matList := make([]matrix.Matrix, matNum)
+ fillMatrixList(matList, cache, blockNum)
+ endFillMatrixList := time.Now()
+ deltaFillMatrixList := endFillMatrixList.Sub(endGenerateCache)
+
+ blockHeader := make([]byte, 80)
+ matIndex := getIndex(blockHeader)
+
+ result := mulMatrix(matList, matIndex)
+ endMulMatrix := time.Now()
+ deltaMulMatrix := endMulMatrix.Sub(endFillMatrixList)
+
+ end := time.Now()
+ delta := end.Sub(start)
+
+ fmt.Println("\n---------------------------------------")
+ fmt.Println("length of location is:", len(location))
+ fmt.Println("result[1,1] is:", result.Get(1, 1))
+ fmt.Println("cache item is:", cache[cacheLength/4-1])
+ //result.Print()
+
+ fmt.Println("\n---------------------------------------")
+ fmt.Println("matSize is:", matSize)
+ fmt.Println("matNum is:", matNum)
+ fmt.Println("seedhash took amount of time is:", deltaSeedHash)
+ fmt.Println("generateCache took amount of time is:", deltaGenerateCache)
+ fmt.Println("fillMatrixList took amount of time is:", deltaFillMatrixList)
+ fmt.Println("mulMatrix took amount of time is:", deltaMulMatrix)
+ fmt.Println("btmhash took amount of time is:", delta)
+}
+
+func TestSHA3() {
+ word := "testing"
+ sum256 := sha3.Sum256([]byte(word))
+
+ // decimal byte slice translate to hex string
+ sum256Channel := make(chan []byte, 1)
+ sum256Channel <- sum256[:]
+ sum256_hex := DecimalByteSlice2HexString(<-sum256Channel)
+
+ fmt.Println("\n----------test SHA3--------------------")
+ fmt.Println("word is:", word)
+ fmt.Println("sum256 length is:", len(sum256))
+ fmt.Println("SHA3-256 sum is:", sum256)
+ fmt.Println("SHA3-256 sum(hex) is:", sum256_hex)
+
+ // testNonce := uint64(3)
+ data_1 := make([]byte, 32)
+ data_2 := make([]byte, 32)
+ fmt.Println("data is:", data_1)
+
+ sha3_sum256 := makeHasher(sha3.New256())
+ //keccak256 := makeHasher(sha3.NewKeccak256())
+ sha3_sum256(data_1, data_1)
+ //keccak256(data_2, data_2)
+
+ fmt.Println("gosha3 data is:", data_1)
+ fmt.Println("sha3 is:", sha3.Sum256(data_1))
+ fmt.Println("gosha3 data(hex) is:", DecimalByteSlice2HexString(data_1))
+ fmt.Println("keccak256 data is:", data_2)
+ fmt.Println("keccak256 data(256) is:", DecimalByteSlice2HexString(data_2))
+ fmt.Println("data_1[0] is:", data_1[0])
+
+ count := make([]int, 128)
+ for i := 0; i < 12800; i++ {
+ sha3_sum256(data_1, data_1)
+ for j := 0; j < 32; j++ {
+ count[data_1[j]%128]++
+ }
+ }
+ fmt.Println("count is:", count)
+ // fmt.Println("testNonce(uint64) is:", testNonce)
+
+ // ----------test SHA3--------------------
+ // word is: testing
+ // sum256 length is: 32
+ // SHA3-256 sum is: [127 89 121 251 120 240 130 232 177 198 118 99 93 184 121 92 74 198 250 186 3 82 95 183 8 203 95 214 143 212 12 94]
+ // SHA3-256 sum(hex) is: 7F5979FB78F082E8B1C676635DB8795C4AC6FABA03525FB708CB5FD68FD40C5E
+}
+
+func TestSeedHash() {
+ seed_1 := seedHash(0)
+ seed_2 := seedHash(30000)
+
+ //decimal byte slice translate to hex string
+ seedHex_1 := DecimalByteSlice2HexString(seed_1)
+ seedHex_2 := DecimalByteSlice2HexString(seed_2)
+
+ fmt.Println("\n----------test seedhash----------------")
+ fmt.Println("seed length is:", len(seed_1))
+ fmt.Println("block is:", 0, "\nseedhash is:", seedHash(0))
+ fmt.Println("seed(hex) is:", seedHex_1)
+ fmt.Println("block is:", 30000, "\nseedhash is:", seedHash(30000))
+ fmt.Println("seed(hex) is:", seedHex_2)
+
+ // ----------test seedhash----------------
+ // seed length is: 32
+ // block is: 0
+ // seedhash is: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+ // seed(hex) is: 0000000000000000000000000000000000000000000000000000000000000000
+ // block is: 30000
+ // seedhash is: [41 13 236 217 84 139 98 168 214 3 69 169 136 56 111 200 75 166 188 149 72 64 8 246 54 47 147 22 14 243 229 99]
+ // seed(hex) is: 290DECD9548B62A8D60345A988386FC84BA6BC95484008F6362F93160EF3E563
+}
+
+func TestGenerateCache() {
+ start := time.Now()
+
+ cache := make([]uint32, cacheLength/4)
+ generateCache(cache, seedHash(uint64(30000)))
+
+ // Convert our destination slice to a byte buffer
+ header := *(*reflect.SliceHeader)(unsafe.Pointer(&cache))
+ header.Len *= 4
+ header.Cap *= 4
+ cacheInt8 := *(*[]int8)(unsafe.Pointer(&header))
+
+ end := time.Now()
+ delta := end.Sub(start)
+
+ fmt.Println("\n----------TestCacheGeneration----------")
+ fmt.Println("cache[0] is:", cache[0])
+ fmt.Println("cache[1] is:", cache[1])
+ fmt.Println("cache length is:", len(cache))
+ fmt.Println("cacheInt8[0]", cacheInt8[0])
+ fmt.Println("cacheInt8[1]", cacheInt8[1])
+ fmt.Println("cacheInt8[2]", cacheInt8[2])
+ fmt.Println("cacheInt8[3]", cacheInt8[3])
+ fmt.Println("cacheInt8[4]", cacheInt8[4])
+ fmt.Println("cacheInt8[5]", cacheInt8[5])
+ fmt.Println("test GenertateCache took amount of time is:", delta)
+}
+
+func TestRandomness() {
+ var blockNum uint64 = 0
+ seed := seedHash(30000)
+ cache := make([]uint32, cacheLength/4)
+ generateCache(cache, seed)
+ matList := make([]matrix.Matrix, matNum)
+ fillMatrixList(matList, cache, blockNum)
+ matIndex := make([]byte, 80)
+ ma := mulMatrix(matList, matIndex)
+ nonce[0]++
+ mb := mulMatrix(matList, matIndex)
+ count := count_diff_bits(ma, mb)
+
+ fmt.Println("\n----------test randomness--------------------")
+ fmt.Println("ma is:")
+ //ma.Print()
+ fmt.Println("\n-----------------")
+ fmt.Println("mb is:")
+ //mb.Print()
+
+ fmt.Println("\n------------------------------------------")
+ fmt.Println("matSize is:", matSize)
+ fmt.Println("matNum is:", matNum)
+ fmt.Println("rate of different bits is:", float32(count)/float32(matSize*matSize*8))
+}
+
+func count_diff_bits(ma, mb *matrix.Matrix) int {
+ var count int
+ var mask int16
+ for i := 1; i <= matSize; i++ {
+ for j := 1; j <= matSize; j++ {
+ for mask = 0x01; mask < 0x100; mask <<= 1 {
+ if (int16(ma.Get(i, j)) & mask) != (int16(mb.Get(i, j)) & mask) {
+ count++
+ }
+ }
+ }
+ }
+
+ return count
+}
+
+func DecimalByteSlice2HexString(DecimalSlice []byte) string {
+ var sa = make([]string, 0)
+ for _, v := range DecimalSlice {
+ sa = append(sa, fmt.Sprintf("%02X", v))
+ }
+ ss := strings.Join(sa, "")
+ return ss
+}
+
+func Testnonce() {
+ nonce := make([]uint64, 4)
+ nonce[0] = 31122932229983
+ nonce[1] = 31122932212982
+ nonce[2] = 31132932042981
+ nonce[3] = 31122932089980
+
+ // Convert our destination slice to a byte buffer
+ header := *(*reflect.SliceHeader)(unsafe.Pointer(&nonce))
+ header.Len *= 8
+ header.Cap *= 8
+ dest := *(*[]byte)(unsafe.Pointer(&header))
+
+ var item int8 = -3
+ var matnum uint8 = 128
+ var index uint8
+ //var result int
+
+ // Swap the byte order on big endian systems and return
+ // if !isLittleEndian() {
+ // swap(dest)
+ // }
+
+ fmt.Println("\n-------------test nonce-------------------------")
+ fmt.Println("item is:", byte(item))
+ fmt.Println("nonce is:", nonce)
+ fmt.Println("matnum is:", matnum)
+ fmt.Println("length of dest is:", len(dest))
+ fmt.Println("dest is:", dest)
+ dest = append(dest, byte(item))
+ fmt.Println("length of dest is:", len(dest))
+ fmt.Println("dest is:", dest)
+ sum256 := sha3.Sum256(dest)
+ fmt.Println("sum256 is:", sum256)
+ fmt.Println("sum256[0] is:", sum256[0])
+ index = uint8(sum256[0] & 0x7f)
+ fmt.Println("index is:", index)
+
+ //getIndex(item, nonce)
+}
--- /dev/null
+package main\r
+\r
+import (\r
+ "fmt"\r
+ "time"\r
+\r
+ "btmhash/btmhash"\r
+)\r
+\r
+func main() {\r
+ start := time.Now()\r
+\r
+ btmhash.TestBtmhash()\r
+ //btmhash.TestSHA3()\r
+ //btmhash.TestSeedHash()\r
+ //btmhash.TestGenerateCache()\r
+ //btmhash.TestRandomness()\r
+ //btmhash.Testnonce()\r
+\r
+ end := time.Now()\r
+ delta := end.Sub(start)\r
+ fmt.Println("\n-----------------------------------------------")\r
+ fmt.Printf("functions took this amount of time: %s\n", delta)\r
+}\r
--- /dev/null
+// Package matrix implements a simple library for creating and\r
+// manipulating matrices, and performing basic linear algebra.\r
+\r
+package matrix\r
+\r
+import (\r
+ "fmt"\r
+ "strconv"\r
+)\r
+\r
+type Matrix struct {\r
+ rows, columns int // the number of rows and columns.\r
+ data []int8 // the contents of the matrix as one long slice.\r
+}\r
+\r
+// Set lets you define the value of a matrix at the given row and\r
+// column.\r
+\r
+func (A *Matrix) Set(r int, c int, val int8) {\r
+ A.data[findIndex(r, c, A)] = val\r
+}\r
+\r
+// Get retrieves the contents of the matrix at the row and column.\r
+\r
+func (A *Matrix) Get(r, c int) int8 {\r
+ return A.data[findIndex(r, c, A)]\r
+}\r
+\r
+// Print converts the matrix into a string and then outputs it to fmt.Printf.\r
+\r
+func (A *Matrix) Print() {\r
+\r
+ // Find the width (in characters) that each column needs to be. We hold these\r
+ // widths as strings, not ints, because we're going to use these in a printf\r
+ // function.\r
+\r
+ columnWidths := make([]string, A.columns)\r
+\r
+ for i := range columnWidths {\r
+ var maxLength int\r
+ thisColumn := A.Column(i + 1)\r
+ for j := range thisColumn {\r
+ thisLength := len(strconv.Itoa(int(thisColumn[j])))\r
+ if thisLength > maxLength {\r
+ maxLength = thisLength\r
+ }\r
+ }\r
+ columnWidths[i] = strconv.Itoa(maxLength)\r
+ }\r
+\r
+ // We have the widths, so now output each element with the correct column\r
+ // width so that they line up properly.\r
+\r
+ for i := 0; i < A.rows; i++ {\r
+ thisRow := A.Row(i + 1)\r
+ fmt.Printf("[")\r
+ for j := range thisRow {\r
+ var printFormat string\r
+ if j == 0 {\r
+ printFormat = "%" + columnWidths[j] + "s"\r
+ } else {\r
+ printFormat = " %" + columnWidths[j] + "s"\r
+ }\r
+ fmt.Printf(printFormat, strconv.Itoa(int(thisRow[j])))\r
+ }\r
+ fmt.Printf("]\n")\r
+ }\r
+}\r
+\r
+// Column returns a slice that represents a column from the matrix.\r
+// This works by examining each row, and adding the nth element of\r
+// each to the column slice.\r
+\r
+func (A *Matrix) Column(n int) []int8 {\r
+ col := make([]int8, A.rows)\r
+ for i := 1; i <= A.rows; i++ {\r
+ col[i-1] = A.Row(i)[n-1]\r
+ }\r
+ return col\r
+}\r
+\r
+// Row returns a slice that represents a row from the matrix.\r
+\r
+func (A *Matrix) Row(n int) []int8 {\r
+ return A.data[findIndex(n, 1, A):findIndex(n, A.columns+1, A)]\r
+}\r
+\r
+// Multiply multiplies two matrices together and return the resulting matrix.\r
+// For each element of the result matrix, we get the dot product of the\r
+// corresponding row from matrix A and column from matrix B.\r
+\r
+func Multiply(A, B Matrix) *Matrix {\r
+ C := Zeros(A.rows, B.columns)\r
+ for r := 1; r <= C.rows; r++ {\r
+ A_row := A.Row(r)\r
+ for c := 1; c <= C.columns; c++ {\r
+ B_col := B.Column(c)\r
+ C.Set(r, c, dotProduct(A_row, B_col))\r
+ }\r
+ }\r
+ return &C\r
+}\r
+\r
+// Add adds two matrices together and returns the resulting matrix. To do\r
+// this, we just add together the corresponding elements from each matrix.\r
+\r
+func Add(A, B Matrix) Matrix {\r
+ C := Zeros(A.rows, A.columns)\r
+ for r := 1; r <= A.rows; r++ {\r
+ for c := 1; c <= A.columns; c++ {\r
+ C.Set(r, c, A.Get(r, c)+B.Get(r, c))\r
+ }\r
+ }\r
+ return C\r
+}\r
+\r
+// Identity creates an identity matrix with n rows and n columns. When you\r
+// multiply any matrix by its corresponding identity matrix, you get the\r
+// original matrix. The identity matrix looks like a zero-filled matrix with\r
+// a diagonal line of one's starting at the upper left.\r
+\r
+func Identity(n int) Matrix {\r
+ A := Zeros(n, n)\r
+ for i := 0; i < len(A.data); i += (n + 1) {\r
+ A.data[i] = 1\r
+ }\r
+ return A\r
+}\r
+\r
+// Zeros creates an r x c sized matrix that's filled with zeros. The initial\r
+// state of an int is 0, so we don't have to do any initialization.\r
+\r
+func Zeros(r, c int) Matrix {\r
+ return Matrix{r, c, make([]int8, r*c)}\r
+}\r
+\r
+// New creates an r x c sized matrix that is filled with the provided data.\r
+// The matrix data is represented as one long slice.\r
+\r
+func New(r, c int, data []int8) Matrix {\r
+ if len(data) != r*c {\r
+ panic("[]int data provided to matrix.New is great than the provided capacity of the matrix!'")\r
+ }\r
+ A := Zeros(r, c)\r
+ A.data = data\r
+ return A\r
+}\r
+\r
+// findIndex takes a row and column and returns the corresponding index\r
+// from the underlying data slice.\r
+\r
+func findIndex(r, c int, A *Matrix) int {\r
+ return (r-1)*A.columns + (c - 1)\r
+}\r
+\r
+// dotProduct calculates the algebraic dot product of two slices. This is just\r
+// the sum of the products of corresponding elements in the slices. We use\r
+// this when we multiply matrices together.\r
+\r
+func dotProduct(a, b []int8) int8 {\r
+ var total int32\r
+ for i := 0; i < len(a); i++ {\r
+ total += int32(a[i]) * int32(b[i])\r
+ }\r
+ return int8((total & 0xff) +\r
+ ((total >> 8) & 0xff) +\r
+ ((total >> 16) & 0xff) +\r
+ ((total >> 24) & 0xff))\r
+}\r
OSDN Git Service
