Merge branch 'master' of gitlab.ethz.ch:mawinkle/socket

BigInt.hpp

@@ -1,111 +1,221 @@
-#ifndef BIG_INT_HPP
-#define BIG_INT_HPP
-#include "semi_bitset.hpp"
-#include <cstdlib>
+#ifndef BIGINT_HPP
+#define BIGINT_HPP
+#include <cstdint>
+#include <deque>
 #include <string>
-template<size_t size>
-class BigInt{
-private:
-	int signum = 1;
-	semi_bitset<size, size >= 1000> bits;
-public:
-	inline BigInt(){
+#include <cmath>
+#include <bitset>
+using std::size_t;
+inline std::uint32_t u(uint64_t a){
+	return (uint32_t)(a >> 32);
+}
+inline std::uint32_t l(uint64_t a){
+	return (uint32_t)(a & 0x00000000FFFFFFFF);
+}
+
+template<typename T>
+inline int signum(T t){
+	if(t > 0)return 1;
+	if(t < 0)return -1;
+	return 0;
+}
+struct BigInt{
+	using uint64_t = std::uint64_t;
+	using uint32_t = std::uint32_t;
+	int signum;
+	std::deque<std::uint64_t> data;
+	inline BigInt(size_t size, bool dummy) : data(size, 0){
 		
 	}
-	inline BigInt(int o){
-		if(o < 0){signum = -1;o *= -1;}
-		bits.data[bits.length() - 1] = (unsigned int)o;
+
+	inline BigInt(unsigned int n) : data(1, 0){
+		data[0] = n;
 	}
-	inline BigInt(unsigned int o){
-		bits.data[bits.length() - 1] = o;
+	inline BigInt(unsigned long long n) : data(2, 0){
+		data[1] = l(n);
+		data[0] = u(n);
 	}
-	inline BigInt(long long o){
-		if(o < 0){signum = -1;o = 0ULL - o;}
-		bits.data[bits.length() - 1] = (o & lower_half);
-		bits.data[bits.length() - 2] = (o >> 32);
+	inline BigInt(unsigned long long n, size_t _size) : data(_size, 0){
+		data[_size - 1] = l(n);
+		data[_size - 2] = u(n);
 	}
-	inline BigInt(unsigned long long o){
-		bits.data[bits.length() - 1] = (o & lower_half);
-		bits.data[bits.length() - 2] = (o >> 32);
+	inline BigInt(int n) : data(1, 0){
+		data[0] = std::abs(n);
+		signum = ::signum(n);
 	}
-	template<std::size_t osize>
-	inline BigInt<size> add(const BigInt<osize>& o)const{
-		static_assert(size == osize);
-		BigInt<size> ret;
+	inline BigInt(long long n) : data(2, 0){
+		data[1] = l(std::abs(n));
+		data[0] = u(std::abs(n));
+		signum = ::signum(n);
+	}
+	inline uint64_t mod(uint64_t o){
+		uint64_t carry = 0;
+		for(size_t i = 0;i < data.size();i++){
+			carry = ((carry << 32) + data[i]) % o;
+		}
+		return carry;
+	}
+	inline BigInt div(uint32_t o){
+		uint64_t carry = 0;
+		BigInt ret = *this;
+		for(size_t i = 0;i < data.size();i++){
+			ret.data[i] = (data[i] + (carry << 32)) / o;
+			carry = (data[i] + (carry << 32)) % o;
+		}
+		return ret;
+	}
+	
+	
+	inline BigInt add(const BigInt& other){
+		BigInt ret((size_t)std::max((size_t)data.size(), (size_t)other.data.size()), false);
 		uint64_t carry = 0;
-		for(size_t i = size - 1;i >= 0;i--){
-			uint64_t res = (*this)[i] + o[i] + carry;
-			carry = (res >> 32);
-			ret[i] = res & lower_half;
-			if(i == 0)break;
+		for(size_t s = 0;s < std::max(data.size(), other.data.size());s++){
+			uint64_t s1 = (s >= data.size() ? 0 : data[data.size() - s - 1]);
+			uint64_t s2 = (s >= other.size() ? 0 : other.data[other.size() - s - 1]);
+			uint64_t sum = s1 + s2 + carry;
+			ret.data[ret.size() - s - 1] = l(sum);
+			carry = u(sum);
 		}
 		return ret;
 	}
-	template<size_t osize>
-	inline BigInt<size> mult(const BigInt<osize>& o)const{
-		BigInt<size + osize> ret;
-		uint64_t mat[size][size] = {0};
+	void trim(){
+		while(!(data[1] | data[0]))data.pop_front();
+	}
+	inline BigInt mult(const BigInt& other){
+		std::deque<std::deque<uint64_t>> matrix(size(), std::deque<uint64_t>(other.size() + 1, 0));
 		uint64_t carry = 0;
-		for(size_t i = 0;i < size;i++){
-			for(size_t ih = size - 1;ih != ~(0ULL);ih--){
-				mat[i][ih] = (*this)[i] * o[ih] + carry;
-				carry = mat[i][ih] >> 32;
-				mat[i][ih] &= lower_half;
-				if(ih == 0)break;
+		
+		BigInt ret(size() + other.size(), false);
+		for(size_t i = 0;i < size();i++){
+			carry = 0;
+			for(size_t ih = 0;ih < other.size();ih++){
+				uint64_t res = data[size() - i - 1] * other.data[other.size() - ih - 1];
+				res += carry;
+				matrix[i][ih] = l(res);
+				carry = u(res);
 			}
 		}
 		carry = 0;
-		for(size_t i = size - 1;i != ~(0ULL);i--){
+		if(false)
+		for(size_t i = 0;i < matrix.size();i++){
+			for(size_t ih = 0;ih < matrix.size();ih++){
+				std::cout << matrix[i][ih] << " ";
+			}
+			std::cout << std::endl;
+		}
+		for(size_t column = 0;column < (matrix.size() + other.size());column++){
 			uint64_t accum = 0;
-			for(size_t ih = 0;ih < size;ih++){
-				accum += ((i + ih) >= size) ?  0 : mat[i + ih][ih];
+			for(size_t row = 0;row < matrix.size();row++){
+				if(row > column)goto end;
+				else if(column - row < matrix[row].size()){
+					accum += matrix[row][column - row];
+				}
 			}
+			end:
 			accum += carry;
-			ret[i] = accum & lower_half;
-			carry = accum >> 32;
+			carry = u(accum);
+			ret.data[ret.size() - column - 1] = l(accum);
 		}
+		ret.trim();
 		return ret;
 	}
 	
-	inline BigInt<size> div(unsigned int o)const{
-		uint64_t carry = 0;
-		BigInt<size> ret;
-		for(size_t i = 0;i < size;i++){
-			uint64_t res = ((*this)[i] + (carry << 32)) / o;
-			carry = (*this)[i] % o;
-			ret[i] = res;
+	inline BigInt& bitshiftLeft(int c){
+		if(c < 0)return bitshiftRight(-c);
+		int jump = c / 32;
+		int sh = c % 32;
+		for(int i = 0;i < (int)(size()) - jump;i++){
+			data[i] = l(data[i + jump] << sh);
+			if(i < size() - jump - 1){
+				data[i] |= data[i + jump + 1] >> (32 - sh);
+			}
 		}
-		return ret;
+		for(int i = std::max(0,(int)(size()) - jump);i < size();i++){
+			data[i] = 0;
+		}
+		return *this;
 	}
-	inline unsigned int mod(unsigned int o)const{
-		uint64_t carry = 0;
-		for(size_t i = 0;i < size;i++){
-			carry = (this->operator[](i) + (carry << 32)) % o;
+	
+	inline BigInt& bitshiftRight(int c){
+		if(c < 0)return bitshiftLeft(-c);
+		unsigned int jump = c / 32;
+		unsigned int sh = c % 32;
+		for(unsigned int i = size() - 1;i >= jump;i--){
+			data[i] = data[i - jump] >> sh;
+			if(i > jump){
+				data[i] |= l(data[i - jump - 1] << (32 - sh));
+			}
 		}
-		return (unsigned int)(carry & lower_half);
+		for(int i = jump - 1;i >= 0;i--){
+			data[i] = 0;
+		}
+		return *this;
 	}
-	inline std::uint64_t& operator[](size_t i){
-		return bits.data[i];
+	inline BigInt& chunkshiftLeft(int c){
+		if(c < 0)return chunkshiftRight(-c);
+		for(int i = 0;i < (int)(size()) - c;i++){
+			data[i] = data[i + c];
+		}
+		for(int i = std::max(0,(int)(size()) - c);i < size();i++){
+			data[i] = 0;
+		}
+		return *this;
 	}
 	
-	inline const std::uint64_t& operator[](size_t i)const{
-		return bits.data[i];
+	inline BigInt& chunkshiftRight(int c){
+		if(c < 0)return chunkshiftLeft(-c);
+		for(int i = size() - 1;i >= c;i--){
+			data[i] = data[i - c];
+		}
+		for(int i = c - 1;i >= 0;i--){
+			data[i] = 0;
+		}
+		return *this;
 	}
-	inline bool isZero()const{
-		for(size_t i = 0;i < size;i++){
-			if(this->operator[](i))return false;
+	
+	inline size_t size()const{
+		return data.size();
+	}
+	inline bool operator==(const BigInt& o)const{
+		auto it1 = data.rbegin();
+		auto it2 = o.data.rbegin();
+		while(true){
+			if(*(it1++) != *(it2++))return false;
+			if(it1 == data.rend())return true;
+			if(it2 == o.data.rend())return true;
+		}
+	}
+	inline bool isZero(){
+		for(uint64_t d : data){
+			if(d)return false;
 		}
 		return true;
 	}
-	template<typename stream, size_t osize>
-	inline friend stream& operator<<(stream& s, const BigInt<osize>& o){
+	inline std::string bitString(){
+		std::vector<char> _bits;
+		_bits.reserve(data.size() * 32);
+		for(uint64_t i : data){
+			std::bitset<64> bits(i);
+			for(int ih = 0;ih < 32;ih++)
+			_bits.push_back((bits[32 - ih - 1] == 1) ? '1' : '0');
+		}
+		return std::string(_bits.begin(), _bits.end());
+	}
+	inline std::string rawString(){
+		std::string a = "";
+		for(uint64_t d : data){
+			a += (std::to_string(d) + "|");
+		}
+		return a;
+	}
+	inline std::string toString(){
 		std::string a = "";
-		BigInt dis = o;
-		while(!dis.isZero()){
-			a = std::to_string(dis.mod(10)) + a;
-			dis = dis.div(10);
+		BigInt dec(*this);
+		while(!dec.isZero()){
+			a = std::to_string(dec.mod(10)) + a;
+			dec = dec.div(10);
 		}
-		return s << a;
+		return a;
 	}
 };
-#endif
+#endif //BIGINT_HPP

BigInt64.hpp

@@ -0,0 +1,176 @@
+#ifndef BIGINT64_HPP
+#define BIGINT64_HPP
+#include <cstdint>
+#include <cstdlib>
+#include <algorithm>
+#include <iterator>
+#include <initializer_list>
+#include <deque>
+#include <vector>
+#include <string>
+#include <cmath>
+#include <bitset>
+#include <iostream>
+const std::vector<char> chars = {'0','1','2','3','4','5','6','7','8','9'};
+const __uint128_t _m = ((__uint128_t)1) << 64;
+template<typename T>
+inline int signum(T t){
+	if(t < 0)return -1;
+	if(t >= 0)return 1;
+}
+inline std::ostream& operator<<(std::ostream& out, __uint128_t o){
+	if(o == 0)return out << "0";
+	while(o > 0){
+		out << std::to_string((int)(o % 10));
+		o /= 10;
+	}
+	return out;
+}
+struct BigInt{
+	using size_t = std::size_t;
+	using ssize_t = std::int64_t;
+	using uint64_t = std::uint64_t;
+	using uint32_t = std::uint32_t;
+	using lui = ::__uint128_t;
+	std::deque<uint64_t> data;
+	int signum;
+	inline BigInt() : data(1,0),signum(1){}
+	inline BigInt(size_t _s, uint64_t fill) : data(_s,fill), signum(1){}
+	inline BigInt(int a) : signum(::signum(a)), data(1, std::abs(a)){}
+	inline BigInt(unsigned int a) : signum(1), data(1, a){}
+	inline BigInt(unsigned long long a) : signum(1), data(1, a){}
+	inline BigInt(long long a) : signum(::signum(a)), data(1, std::abs(a)){}
+	inline BigInt(const std::initializer_list<uint64_t>& l) : data(l), signum(1){}
+	inline BigInt(std::initializer_list<uint64_t>&& l) : data(std::move(l)), signum(1){}
+	template<typename InputIterator>
+	inline BigInt(InputIterator begin, InputIterator end) : data(begin, end), signum(1){}
+	std::deque<uint64_t>::iterator begin(){return data.begin();}
+	std::deque<uint64_t>::iterator end(){return data.end();}
+	std::deque<uint64_t>::reverse_iterator rbegin(){return data.rbegin();}
+	std::deque<uint64_t>::reverse_iterator rend(){return data.rend();}
+	std::deque<uint64_t>::const_iterator begin()const{return data.begin();}
+	std::deque<uint64_t>::const_iterator end()const{return data.end();}
+	std::deque<uint64_t>::const_reverse_iterator rbegin()const{return data.rbegin();}
+	std::deque<uint64_t>::const_reverse_iterator rend()const{return data.rend();}
+	size_t size()const{return data.size();}
+	auto cbegin(){return data.cbegin();}
+	auto cend(){return data.cend();}
+	auto crbegin(){return data.crbegin();}
+	auto crend(){return data.crend();}
+	auto cbegin()const{return data.cbegin();}
+	auto cend()const{return data.cend();}
+	auto crbegin()const{return data.crbegin();}
+	auto crend()const{return data.crend();}
+	inline bool isZero()const{
+		for(auto it = data.begin();it != data.end();it++){
+			if(*it)return false;
+		}
+		return true;
+	}
+	inline void setZero(){
+		for(auto it = begin();it != end();it++)*it = 0;
+	}
+	inline void trim(){
+		while(data[0] == 0 && data.size() != 0){
+			data.pop_front();
+		}
+	}
+	inline BigInt div(uint64_t d)const{
+		BigInt ret = *this;
+		lui carry = 0;
+		for(auto it = ret.data.begin();it != ret.data.end();it++){
+			lui temp = (lui)*it;
+			temp += carry;
+			carry = temp % d;
+			*it = (uint64_t)(temp / d);
+			carry <<= 64;
+		}
+	}
+	inline BigInt& div(uint64_t d){
+		lui carry = 0;
+		for(auto it = data.begin();it != data.end();it++){
+			lui temp = (lui)*it;
+			temp += carry;
+			carry = temp % d;
+			*it = (uint64_t)(temp / d);
+			carry <<= 64;
+		}
+	}
+	inline uint64_t mod(uint64_t m)const{
+		lui carry = 0;
+		for(auto it = data.begin();it != data.end();it++){
+			carry <<= 64;
+			carry = (*it + carry) % m;
+		}
+		return carry;
+	}
+	inline BigInt& chunkshiftLeft(int c){
+		if(c < 0)return chunkshiftRight(-c);
+		if(c >= size()){std::fill(begin(),end(),0);return *this;}
+		auto it1 = data.begin(); 
+		auto it2 = it1 + c;
+		while(it2 != data.end())*(it1++) = *(it2++);
+		while(it1 != data.end())*(it1++) = 0;
+		return *this;
+	}
+	inline BigInt& chunkshiftRight(int c){
+		if(c < 0)return chunkshiftLeft(-c);
+		if(c >= size()){std::fill(begin(),end(),0);return *this;}
+		auto it1 = data.rbegin(); 
+		auto it2 = it1 + c;
+		while(it2 != data.rend())*(it1++) = *(it2++);
+		while(it1 != data.rend())*(it1++) = 0;
+		return *this;
+	}
+	inline BigInt& adda(const BigInt& o){
+		while(size() < o.size())data.push_front(0);
+		bool carry = 0;
+		auto it1 = rbegin();
+		auto it2 = o.rbegin();
+		while(it1 != rend() && it2 != o.rend()){
+			carry = __builtin_uaddll_overflow(*it1, *it2 + carry, (unsigned long long*)(&(*it1)));
+			carry |= (*it2 + carry) == 0 && *it2;
+			it1++;
+			it2++;
+		}
+		while(it1 != rend() && carry){
+			carry = __builtin_uaddll_overflow(*it1, carry, (unsigned long long*)(&(*it1)));
+		}
+		if(carry)data.push_front(1);
+		return *this;
+	}
+	
+	inline BigInt mult(const BigInt& o){
+		BigInt result(size() + o.size(),0);
+		BigInt temp(size() + o.size(),0);
+		int p = 0;
+		for(auto it1 = rbegin();it1 != rend();it1++){
+			auto it = temp.rbegin();
+			lui carry = 0;
+			for(auto it2 = o.rbegin();it2 != o.rend();it2++){
+				lui prod = ((lui)*it1) * (*it2);
+				prod += carry;
+				*(it++) = (uint64_t)prod;
+				carry = (prod >> 64);
+			}
+			if(carry)(*it)++;
+			temp.chunkshiftLeft(p++);
+			result.adda(temp);
+			temp.setZero();
+		}
+		result.trim();
+		return result;
+	}
+	
+	inline std::string toString(){
+		std::vector<char> c_str;
+		c_str.reserve(data.size() * 19);
+		BigInt diver = *this;
+		while(!diver.isZero()){
+			c_str.push_back(chars.at(diver.mod(10)));
+			diver.div(10);
+		}
+		return std::string(c_str.rbegin(), c_str.rend());
+	}
+};
+#endif //BIGINT64_HPP

semi_bitset.hpp

@@ -1,276 +0,0 @@
-#ifndef SEMI_BITSET_HPP
-#define SEMI_BITSET_HPP
-#include <cstdint>
-#include <vector>
-#include <bitset>
-using std::size_t;
-static const std::uint64_t lower_half = 0x00000000FFFFFFFF;
-template<size_t size, bool containertype>
-struct semi_bitset{
-	using uint64_t = std::uint64_t;
-	using uint32_t = std::uint32_t;
-	std::vector<uint64_t> data;
-	inline semi_bitset() : data(size, 0){}
-	inline size_t length()const{
-		return size;
-	}
-	inline semi_bitset<size, containertype> operator<<(int o)const{
-		if(o < 0){return this->operator>>(-o);}
-		if(o == 0){return *this;}
-		semi_bitset<size, containertype> ret;
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = jump;i < size;i++){
-			if(i < (size - 1))
-				ret.data[i - jump] = ((data[i] << mod) & lower_half) | (data[i + 1] >> counter);
-			else
-				ret.data[i - jump] = ((data[i] << mod) & lower_half);
-		}
-		return ret;
-	}
-	inline semi_bitset<size, containertype> operator>>(int o)const{
-		if(o < 0){return this->operator<<(-o);}
-		if(o == 0){return *this;}
-		semi_bitset<size, containertype> ret;
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = jump;i < size;i++){
-			if(i > jump)
-				ret.data[i] = (data[i - jump] >> mod) | ((data[i - jump - 1] << counter) & lower_half);
-			else
-				ret.data[i] = (data[i - jump] >> mod);
-		}
-		return ret;
-	}
-	inline semi_bitset<size, containertype>& operator<<=(int o){
-		if(o < 0){return this->operator>>=(-o);}
-		if(o == 0){return *this;}
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = jump;i < size;i++){
-			if(i < (size - 1))
-				data[i - jump] = ((data[i] << mod) & lower_half) | (data[i + 1] >> counter);
-			else
-				data[i - jump] = ((data[i] << mod) & lower_half);
-		}
-		for(size_t i = size - jump;i < size;i++){
-			data[i] = 0;
-		}
-		return *this;
-	}
-	inline semi_bitset<size, containertype>& operator>>=(int o){
-		if(o < 0){return this->operator<<=(-o);}
-		if(o == 0){return *this;}
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = size - 1;i >= jump;i--){
-			if(i > jump)
-				data[i] = (data[i - jump] >> mod) | ((data[i - jump - 1] << counter) & lower_half);
-			else
-				data[i] = (data[i - jump] >> mod);
-		}
-		if(jump > 0)
-		for(size_t i = jump - 1;i >= 0;i--){
-			data[i] = 0;
-			if(i == 0)break;
-		}
-		return *this;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype> operator&(const semi_bitset<osize, ocontainertype>& o)const{
-		static_assert(size == osize);
-		semi_bitset<size, containertype> ret;
-		for(size_t i = 0;i < size;i++){
-			ret.data[i] = (data[i] & o.data[i]);
-		}
-		return ret;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype> operator^(const semi_bitset<osize, ocontainertype>& o)const{
-		static_assert(size == osize);
-		semi_bitset<size, containertype> ret;
-		for(size_t i = 0;i < size;i++){
-			ret.data[i] = (data[i] ^ o.data[i]);
-		}
-		return ret;
-		
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype> operator|(const semi_bitset<osize, ocontainertype>& o)const{
-		static_assert(size == osize);
-		semi_bitset<size, containertype> ret;
-		for(size_t i = 0;i < size;i++){
-			ret.data[i] = (data[i] | o.data[i]);
-		}
-		return ret;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype>& operator&=(const semi_bitset<osize, ocontainertype>& o){
-		static_assert(size == osize);
-		for(size_t i = 0;i < size;i++){
-			data &= o.data[i];
-		}
-		return *this;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype>& operator^=(const semi_bitset<osize, ocontainertype>& o){
-		static_assert(size == osize);
-		for(size_t i = 0;i < size;i++){
-			data ^= o.data[i];
-		}
-		return *this;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype>& operator|=(const semi_bitset<osize, ocontainertype>& o){
-		static_assert(size == osize);
-		for(size_t i = 0;i < size;i++){
-			data |= o.data[i];
-		}
-		return *this;
-	}
-	template<typename stream, size_t osize,bool ocontainertype>
-	inline friend stream& operator<<(stream& s, const semi_bitset<osize, ocontainertype>& o){
-		for(size_t i = 0;i < o.data.size();i++)
-			s << std::bitset<32>((uint32_t)(o.data[i] & lower_half));
-		return s;
-	}
-};
-template<std::size_t size>
-struct semi_bitset<size, 0>{
-    using uint64_t = std::uint64_t;
-	using uint32_t = std::uint32_t;
-    uint64_t data[size] = {0};
-	static const bool containertype = 0;
-	inline semi_bitset<size, containertype> operator<<(int o)const{
-		if(o < 0){return this->operator>>(-o);}
-		if(o == 0){return *this;}
-		semi_bitset<size, containertype> ret;
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = jump;i < size;i++){
-			if(i < (size - 1))
-				ret.data[i - jump] = ((data[i] << mod) & lower_half) | (data[i + 1] >> counter);
-			else
-				ret.data[i - jump] = ((data[i] << mod) & lower_half);
-		}
-		return ret;
-	}
-	inline size_t length()const{
-		return size;
-	}
-	inline semi_bitset<size, containertype> operator>>(int o)const{
-		if(o < 0){return this->operator<<(-o);}
-		if(o == 0){return *this;}
-		semi_bitset<size, containertype> ret;
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = jump;i < size;i++){
-			if(i > jump)
-				ret.data[i] = (data[i - jump] >> mod) | ((data[i - jump - 1] << counter) & lower_half);
-			else
-				ret.data[i] = (data[i - jump] >> mod);
-		}
-		return ret;
-	}
-	inline semi_bitset<size, containertype>& operator<<=(int o){
-		if(o < 0){return this->operator>>=(-o);}
-		if(o == 0){return *this;}
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = jump;i < size;i++){
-			if(i < (size - 1))
-				data[i - jump] = ((data[i] << mod) & lower_half) | (data[i + 1] >> counter);
-			else
-				data[i - jump] = ((data[i] << mod) & lower_half);
-		}
-		for(size_t i = size - jump;i < size;i++){
-			data[i] = 0;
-		}
-		return *this;
-	}
-	inline semi_bitset<size, containertype>& operator>>=(int o){
-		if(o < 0){return this->operator<<=(-o);}
-		if(o == 0){return *this;}
-		unsigned int jump = o / 32;
-		unsigned int mod = o % 32;
-		unsigned int counter = 32 - (o % 32);
-		for(size_t i = size - 1;i >= jump;i--){
-			if(i > jump)
-				data[i] = (data[i - jump] >> mod) | ((data[i - jump - 1] << counter) & lower_half);
-			else
-				data[i] = (data[i - jump] >> mod);
-		}
-		if(jump > 0)
-		for(size_t i = jump - 1;i >= 0;i--){
-			data[i] = 0;
-			if(i == 0)break;
-		}
-		return *this;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype | ocontainertype> operator&(const semi_bitset<osize, ocontainertype>& o)const{
-		static_assert(size == osize);
-		semi_bitset<size, containertype | ocontainertype> ret;
-		for(size_t i = 0;i < size;i++){
-			ret.data[i] = (data[i] & o.data[i]);
-		}
-		return ret;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype | ocontainertype> operator^(const semi_bitset<osize, ocontainertype>& o)const{
-		static_assert(size == osize);
-		semi_bitset<size, containertype | ocontainertype> ret;
-		for(size_t i = 0;i < size;i++){
-			ret.data[i] = (data[i] ^ o.data[i]);
-		}
-		return ret;
-		
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype | ocontainertype> operator|(const semi_bitset<osize, ocontainertype>& o)const{
-		static_assert(size == osize);
-		semi_bitset<size, containertype | ocontainertype> ret;
-		for(size_t i = 0;i < size;i++){
-			ret.data[i] = (data[i] | o.data[i]);
-		}
-		return ret;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype>& operator&=(const semi_bitset<osize, ocontainertype>& o){
-		static_assert(size == osize);
-		for(size_t i = 0;i < size;i++){
-			data &= o.data[i];
-		}
-		return *this;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype>& operator^=(const semi_bitset<osize, ocontainertype>& o){
-		static_assert(size == osize);
-		for(size_t i = 0;i < size;i++){
-			data ^= o.data[i];
-		}
-		return *this;
-	}
-	template<size_t osize, bool ocontainertype>
-	inline semi_bitset<size, containertype>& operator|=(const semi_bitset<osize, ocontainertype>& o){
-		static_assert(size == osize);
-		for(size_t i = 0;i < size;i++){
-			data |= o.data[i];
-		}
-		return *this;
-	}
-	template<typename stream, size_t osize,bool ocontainertype>
-	inline friend stream& operator<<(stream& s, const semi_bitset<osize, ocontainertype>& o){
-		for(size_t i = 0;i < osize;i++)
-			s << std::bitset<32>((uint32_t)(o.data[i] & lower_half));
-		return s;
-	}
-};
-#endif

test.cpp

@@ -1,7 +1,13 @@
 #include "socketio.hpp"
-#include "BigInt.hpp"
+#include "BigInt64.hpp"
+
 #include <iostream>
 #include <chrono>
+unsigned long long nanoTime(){
+	using namespace std;
+	using namespace std::chrono;
+	return duration_cast<nanoseconds>(high_resolution_clock::now().time_since_epoch()).count();
+}
 template<typename T>
 std::ostream& operator<<(std::ostream& out, std::vector<T> o){
 	out << "[";
@@ -21,11 +27,15 @@ std::ostream& operator<< <char>(std::ostream& out, std::vector<char> o){
 	return out;
 }
 int main(){
-	BigInt<100> a ((1ULL << 40) + 1);
-	std::cout << a << std::endl;
-	for(int i = 0;i < 1000;i++)
-	a = a.add(a);
-	std::cout << a << std::endl;
+	BigInt a = {1LL << 32};
+	for(int i = 0;i < 12;i++){
+		std::cout << a.toString().size() << " - stellig: " << std::flush;
+		auto t1 = nanoTime();
+		a = a.mult(a);
+		auto t2 = nanoTime();
+		std::cout << (t2 - t1) << " ns" << std::endl;
+	}
+	
 }
 int mian(){
 	cppsocket sock("192.168.178.79", 80);