Ka

include/crypt/BigInt64.hpp

@@ -666,14 +666,13 @@ struct BigInt{
 		return result;
 	}
 	
-	inline std::string rawString()const{
+	inline std::string rawString(bool flag = false)const{
 		std::string s = "";
-		bool flag;
 		for(unsigned int i = 0;i < size();i++){
 			if(data[i])flag = true;
 			if(flag)
-				s += std::to_string(data[i]);
-			if(i < size() - 1)s += "|";
+				s += data[i] == 0 ? "0" : std::to_string(data[i]);
+			if(flag)if(i < size() - 1)s += "|";
 		}
 		return s;
 	}

include/hash.hpp

@@ -4,6 +4,7 @@
 #include <vector>
 #include <array>
 #include <string>
+#include <iterator>
 #include <cstdlib>
 #include <cstring>
 #include <crypt/BigInt64.hpp>
@@ -19,9 +20,11 @@ void hash_checksum(std::uint64_t* dest, const std::vector<char>& input);
 template<typename ForwardIterator>
 BigInt sha256(ForwardIterator begin, ForwardIterator end){
 	std::array<std::uint64_t, 4> ret;
+    std::vector<typename std::iterator_traits<ForwardIterator>::value_type> rcopy(end - begin);
+    std::copy(begin, end, rcopy.begin());
 	std::size_t bytes = (end - begin) * sizeof(*begin);
 	std::vector<char> kak(bytes);
-	std::memcpy(kak.data(), (char*)&(*begin), bytes);
+	std::memcpy(kak.data(), (char*)rcopy.data(), bytes);
 	sha256_(ret.data(), kak);
 	for(std::uint64_t& x : ret)x = reverse(x);
 	return BigInt(ret.begin(), ret.end());
@@ -29,9 +32,11 @@ BigInt sha256(ForwardIterator begin, ForwardIterator end){
 template<typename ForwardIterator>
 BigInt sha512(ForwardIterator begin, ForwardIterator end){
 	std::array<std::uint64_t, 8> ret;
+    std::vector<typename std::iterator_traits<ForwardIterator>::value_type> rcopy(end - begin);
+    std::copy(begin, end, rcopy.begin());
 	std::size_t bytes = (end - begin) * sizeof(*begin);
 	std::vector<char> kak(bytes);
-	std::memcpy(kak.data(), (char*)&(*begin), bytes);
+	std::memcpy(kak.data(), (char*)rcopy.data(), bytes);
 	sha512_(ret.data(), kak);
 	for(std::uint64_t& x : ret)x = reverse(x);
 	return BigInt(ret.begin(), ret.end());

include/util.hpp

@@ -0,0 +1,76 @@
+#ifndef MY_H_G
+#define MY_H_G
+#include <chrono>
+#include <cmath>
+#include <cassert>
+#include <string>
+#include <cstring>
+#include <random>
+#include <pcg_random.hpp>
+#include <algorithm>
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <vector>
+#include <stack>
+#include <set>
+#include <list>
+#include <deque>
+#include <queue>
+#include <complex>
+#include <map>
+#include <unordered_map>
+#include <atomic>
+#include <limits>
+#include <thread>
+namespace std{
+    inline unsigned long long nanoTime(){
+        return std::chrono::high_resolution_clock::now().time_since_epoch().count();
+    }
+}
+static pcg64_fast h_gen(std::nanoTime());
+static std::uniform_int_distribution<unsigned long long> h_dis_ulong(std::numeric_limits<unsigned long long>::min(),std::numeric_limits<unsigned long long>::max());
+static std::uniform_int_distribution<unsigned int> h_dis_uint(std::numeric_limits<unsigned int>::min(),std::numeric_limits<unsigned int>::max());
+static std::uniform_real_distribution<double> h_dis_double(0.0,1.0);
+template<typename T>
+inline std::ostream& operator<<(std::ostream& o,const std::vector<T>& vec){
+    o << "[";
+    for(unsigned int i = 0;i < vec.size();i++){
+        o << vec[i];
+        if(i < vec.size() - 1)o << ", ";
+    }
+    o << "]";
+    return o;
+}
+template<>
+inline std::ostream& operator<<<char>(std::ostream& o,const std::vector<char>& vec){
+    o << "[";
+    for(unsigned int i = 0;i < vec.size();i++){
+        o << (int)vec[i];
+        if(i < vec.size() - 1)o << ", ";
+    }
+    o << "]";
+    return o;
+}
+namespace std{
+    inline double random(){
+        return h_dis_double(h_gen);
+    }
+    template<typename T>
+    inline T random(){
+        return (T)0;
+    }
+    template<>
+    inline double random<double>(){
+        return h_dis_double(h_gen);
+    }
+    template<>
+    inline unsigned long long random<unsigned long long>(){
+        return h_dis_ulong(h_gen);
+    }
+    template<>
+    inline unsigned int random<unsigned int>() {
+        return h_dis_uint(h_gen);
+    }
+}
+#endif

test.cpp

@@ -2,13 +2,16 @@
 #include <hash.hpp>
 #include <random>
 #include <iostream>
+#include <util.hpp>
 int main(){
+    const int runs = 1000;
     std::mt19937_64 gen(54);
-    BigInt n(2);
-    unsigned int i = 1;
-    //auto t1 = std::nanoTime();
-    n = n.modPow(BigInt(gen, 31), secure_prime);
-    std::cout << n.toString() << std::endl;
-    //auto t2 = std::nanoTime();
-    std::cout << sha512(n).hexString() << std::endl;
+    std::vector<BigInt> vec(runs, BigInt(gen, 65536));
+    std::vector<BigInt> hashes(runs);
+    auto a = std::nanoTime();
+    for(int i = 0;i < runs;i++){
+        hashes[i] = sha512(vec[i]);
+    }
+    auto b = std::nanoTime();
+    std::cout << (b - a) / 1000 / 1000.0 << " ms" << std::endl;
 }