Initial import of libdpf.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
commit
e4e666f459
4563 changed files with 1690372 additions and 0 deletions
33
thirdparty/uint256_t/.github/workflows/uint256_t.yml
vendored
Executable file
33
thirdparty/uint256_t/.github/workflows/uint256_t.yml
vendored
Executable file
|
|
@ -0,0 +1,33 @@
|
|||
name: uint256_t
|
||||
|
||||
on: [push, pull_request]
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
defaults:
|
||||
run:
|
||||
shell: bash
|
||||
|
||||
strategy:
|
||||
matrix:
|
||||
standard: ["c++11", "c++14"]
|
||||
|
||||
env:
|
||||
GTEST_COLOR: 1
|
||||
STANDARD: "${{matrix.standard}}"
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
with:
|
||||
submodules: recursive
|
||||
|
||||
- name: GoogleTest
|
||||
run: tests/install_gtest.sh
|
||||
|
||||
- name: Build Tests
|
||||
run: make -C tests
|
||||
|
||||
- name: Run Tests
|
||||
run: tests/test
|
||||
1
thirdparty/uint256_t/.gitignore
vendored
Normal file
1
thirdparty/uint256_t/.gitignore
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
*.o
|
||||
0
thirdparty/uint256_t/.gitmodules
vendored
Normal file
0
thirdparty/uint256_t/.gitmodules
vendored
Normal file
21
thirdparty/uint256_t/LICENSE
vendored
Normal file
21
thirdparty/uint256_t/LICENSE
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2013 - 2017 Jason Lee @ calccrypto at gmail.com
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
49
thirdparty/uint256_t/README.md
vendored
Normal file
49
thirdparty/uint256_t/README.md
vendored
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
# uint256_t
|
||||
|
||||
An unsigned 256 bit integer type for C++
|
||||
|
||||
Copyright (c) 2013 - 2018 Jason Lee @ calccrypto at gmail.com
|
||||
|
||||
Please see LICENSE file for license.
|
||||
|
||||
[](https://github.com/calccrypto/uint256_t/actions/workflows/uint256_t.yml)
|
||||
|
||||
## Acknowledgements
|
||||
With much help from Auston Sterling
|
||||
|
||||
Thanks to Stefan Deigmüller for finding
|
||||
a bug in operator*.
|
||||
|
||||
Thanks to François Dessenne for convincing me
|
||||
to do a general rewrite of this class.
|
||||
|
||||
Thanks to John Skaller for making symbols visible
|
||||
when compiling as a shared library.
|
||||
|
||||
## Usage
|
||||
This is simple implementation of an unsigned 256 bit
|
||||
integer type in C++. It's meant to be used like a standard
|
||||
`uintX_t`, except with a larger bit size than those provided
|
||||
by C/C++.
|
||||
|
||||
`uint256_t` requires [`uint128_t`](https://github.com/calccrypto/uint128_t), which is included.
|
||||
|
||||
### In Code
|
||||
All that needs to be done in code is `#include "uint256_t.h"`
|
||||
|
||||
```c++
|
||||
#include <iostream>
|
||||
#include "uint256_t.h"
|
||||
|
||||
int main() {
|
||||
uint256_t a = 1;
|
||||
uint256_t b = 2;
|
||||
std::cout << (a | b) << std::endl;
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
### Compilation
|
||||
A C++ compiler supporting at least C++11 is required.
|
||||
|
||||
Compilation can be done by directly including `uint128_t.cpp` and `uint256_t.cpp` in your compile command, e.g. `g++ -std=c++11 main.cpp uint128_t.cpp uint256_t.cpp`, or other ways, such as linking the `uint128_t.o` and `uint256_t.o` files, or creating a library, and linking the library in.
|
||||
26
thirdparty/uint256_t/endianness.h
vendored
Normal file
26
thirdparty/uint256_t/endianness.h
vendored
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
#ifndef _ENDIANNESS_H_
|
||||
#define _ENDIANNESS_H_
|
||||
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || \
|
||||
defined(__BIG_ENDIAN__) || \
|
||||
defined(__ARMEB__) || \
|
||||
defined(__THUMBEB__) || \
|
||||
defined(__AARCH64EB__) || \
|
||||
defined(_MIBSEB) || defined(__MIBSEB) || defined(__MIBSEB__)
|
||||
#ifndef __BIG_ENDIAN__
|
||||
#define __BIG_ENDIAN__
|
||||
#endif
|
||||
#elif defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN || \
|
||||
defined(__LITTLE_ENDIAN__) || \
|
||||
defined(__ARMEL__) || \
|
||||
defined(__THUMBEL__) || \
|
||||
defined(__AARCH64EL__) || \
|
||||
defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__) || \
|
||||
defined(_WIN32) || defined(__i386__) || defined(__x86_64__) || \
|
||||
defined(_X86_) || defined(_IA64_)
|
||||
#ifndef __LITTLE_ENDIAN__
|
||||
#define __LITTLE_ENDIAN__
|
||||
#endif
|
||||
#else
|
||||
#error "I don't know what architecture this is!"
|
||||
#endif
|
||||
#endif
|
||||
61
thirdparty/uint256_t/tests/Makefile
vendored
Normal file
61
thirdparty/uint256_t/tests/Makefile
vendored
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
CXX?=g++
|
||||
STANDARD?=c++14
|
||||
CXXFLAGS=-std=$(STANDARD) -Wall -pedantic -g -I../../googletest/googletest/include -I.. -I../uint128_t
|
||||
LDFLAGS=-L../../googletest/build/install/lib -lgtest -lpthread
|
||||
TARGET=test
|
||||
|
||||
TESTCASES =
|
||||
TESTCASES += testcases/constructor.o
|
||||
TESTCASES += testcases/assignment.o
|
||||
TESTCASES += testcases/typecast.o
|
||||
TESTCASES += testcases/accessors.o
|
||||
TESTCASES += testcases/and.o
|
||||
TESTCASES += testcases/or.o
|
||||
TESTCASES += testcases/xor.o
|
||||
TESTCASES += testcases/invert.o
|
||||
TESTCASES += testcases/leftshift.o
|
||||
TESTCASES += testcases/rightshift.o
|
||||
TESTCASES += testcases/logical.o
|
||||
TESTCASES += testcases/gt.o
|
||||
TESTCASES += testcases/gte.o
|
||||
TESTCASES += testcases/lt.o
|
||||
TESTCASES += testcases/lte.o
|
||||
TESTCASES += testcases/equals.o
|
||||
TESTCASES += testcases/notequals.o
|
||||
TESTCASES += testcases/add.o
|
||||
TESTCASES += testcases/sub.o
|
||||
TESTCASES += testcases/mult.o
|
||||
TESTCASES += testcases/div.o
|
||||
TESTCASES += testcases/mod.o
|
||||
TESTCASES += testcases/fix.o
|
||||
TESTCASES += testcases/unary.o
|
||||
TESTCASES += testcases/functions.o
|
||||
TESTCASES += testcases/type_traits.o
|
||||
|
||||
all: $(TARGET)
|
||||
|
||||
.PHONY: clean clean-all
|
||||
|
||||
$(TESTCASES): %.o : %.cpp ../uint256_t.h ../uint128_t/uint128_t.h
|
||||
$(CXX) $(CXXFLAGS) -c $< -o $@
|
||||
|
||||
../uint128_t/uint128_t.o: ../uint128_t/uint128_t.h ../uint128_t/uint128_t.cpp ../uint128_t/uint128_t.include
|
||||
$(CXX) $(CXXFLAGS) -c ../uint128_t/uint128_t.cpp -o $@
|
||||
|
||||
../uint256_t.o: ../uint256_t.h ../uint256_t.cpp ../uint256_t.include
|
||||
$(CXX) $(CXXFLAGS) -c ../uint256_t.cpp -o $@
|
||||
|
||||
$(TARGET): test.cpp ../uint256_t.o ../uint128_t/uint128_t.o $(TESTCASES)
|
||||
$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $(TARGET)
|
||||
|
||||
run: $(TARGET)
|
||||
./$(TARGET)
|
||||
$(MAKE) -C ../uint128_t/tests run
|
||||
|
||||
clean:
|
||||
rm -f $(TARGET)
|
||||
$(MAKE) -C ../uint128_t/tests clean
|
||||
|
||||
clean-all:
|
||||
rm -f ../uint256_t.o $(TESTCASES)
|
||||
$(MAKE) -C ../uint128_t/tests clean-all
|
||||
11
thirdparty/uint256_t/tests/install_gtest.sh
vendored
Executable file
11
thirdparty/uint256_t/tests/install_gtest.sh
vendored
Executable file
|
|
@ -0,0 +1,11 @@
|
|||
#!/usr/bin/env bash
|
||||
|
||||
# not much better than git submodules, but there was never a need/want for the repo in this repo
|
||||
cd ..
|
||||
git clone https://github.com/google/googletest.git
|
||||
cd googletest
|
||||
mkdir build
|
||||
cd build
|
||||
cmake .. -DCMAKE_INSTALL_PREFIX=install
|
||||
make -j $(nproc --all)
|
||||
make -j install
|
||||
32
thirdparty/uint256_t/tests/test.cpp
vendored
Normal file
32
thirdparty/uint256_t/tests/test.cpp
vendored
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
/*
|
||||
Simple test program for uint256_t
|
||||
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2013 - 2017 Jason Lee @ calccrypto at gmail.com
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
int main(int argc, char * argv[]){
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
21
thirdparty/uint256_t/tests/testcases/accessors.cpp
vendored
Normal file
21
thirdparty/uint256_t/tests/testcases/accessors.cpp
vendored
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Accessor, bits){
|
||||
uint256_t value = 1;
|
||||
for(uint32_t i = 0; i < 127; i++){
|
||||
EXPECT_EQ(value.bits(), i + 1); // before shift
|
||||
value <<= 1;
|
||||
}
|
||||
|
||||
EXPECT_EQ(uint256_t(0).bits(), 0);
|
||||
}
|
||||
|
||||
TEST(Accessor, data){
|
||||
const uint256_t value(0xfedcba9876543210ULL, 0x0123456789abcdefULL, 0xfedcba9876543210ULL, 0x0123456789abcdefULL);
|
||||
EXPECT_EQ(value.upper().upper(), 0xfedcba9876543210ULL);
|
||||
EXPECT_EQ(value.upper().lower(), 0x0123456789abcdefULL);
|
||||
EXPECT_EQ(value.lower().upper(), 0xfedcba9876543210ULL);
|
||||
EXPECT_EQ(value.lower().lower(), 0x0123456789abcdefULL);
|
||||
}
|
||||
44
thirdparty/uint256_t/tests/testcases/add.cpp
vendored
Normal file
44
thirdparty/uint256_t/tests/testcases/add.cpp
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, add){
|
||||
uint256_t low (0, 1);
|
||||
uint256_t high(1, 0);
|
||||
|
||||
EXPECT_EQ(low + low, 2);
|
||||
EXPECT_EQ(low + high, uint256_t(1, 1));
|
||||
EXPECT_EQ(high + high, uint256_t(2, 0));
|
||||
|
||||
EXPECT_EQ(low += low, 2);
|
||||
EXPECT_EQ(low += high, uint256_t(1, 2));
|
||||
EXPECT_EQ(high += low, uint256_t(2, 2));
|
||||
}
|
||||
|
||||
TEST(External, add){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
uint128_t u128 (0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f19aULL));
|
||||
EXPECT_EQ(u16 + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f19b9aULL));
|
||||
EXPECT_EQ(u32 + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f19b9b9b9aULL));
|
||||
EXPECT_EQ(u64 + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL, 0x9b9b9b9b9b9b9b9aULL));
|
||||
EXPECT_EQ(u128 + val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL, 0x9b9b9b9b9b9b9b9bULL, 0x9b9b9b9b9b9b9b9aULL));
|
||||
|
||||
EXPECT_EQ(t += val, true);
|
||||
EXPECT_EQ(f += val, true);
|
||||
EXPECT_EQ(u8 += val, (uint8_t) 0x9aULL);
|
||||
EXPECT_EQ(u16 += val, (uint16_t) 0x9b9aULL);
|
||||
EXPECT_EQ(u32 += val, (uint32_t) 0x9b9b9b9aULL);
|
||||
EXPECT_EQ(u64 += val, (uint64_t) 0x9b9b9b9b9b9b9b9aULL);
|
||||
EXPECT_EQ(u128 += val, uint128_t (0x9b9b9b9b9b9b9b9bULL, 0x9b9b9b9b9b9b9b9aULL));
|
||||
}
|
||||
56
thirdparty/uint256_t/tests/testcases/and.cpp
vendored
Normal file
56
thirdparty/uint256_t/tests/testcases/and.cpp
vendored
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(BitWise, and){
|
||||
uint256_t t ((bool) true);
|
||||
uint256_t f ((bool) false);
|
||||
uint256_t u8 ((uint8_t) 0xaaULL);
|
||||
uint256_t u16((uint16_t) 0xaaaaULL);
|
||||
uint256_t u32((uint32_t) 0xaaaaaaaaULL);
|
||||
uint256_t u64((uint64_t) 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t & val, uint256_t(0));
|
||||
EXPECT_EQ(f & val, uint256_t(0));
|
||||
EXPECT_EQ(u8 & val, uint256_t(0xa0ULL));
|
||||
EXPECT_EQ(u16 & val, uint256_t(0xa0a0ULL));
|
||||
EXPECT_EQ(u32 & val, uint256_t(0xa0a0a0a0ULL));
|
||||
EXPECT_EQ(u64 & val, uint256_t(0xa0a0a0a0a0a0a0a0ULL));
|
||||
|
||||
EXPECT_EQ(t &= val, uint256_t(0x0ULL));
|
||||
EXPECT_EQ(f &= val, uint256_t(0x0ULL));
|
||||
EXPECT_EQ(u8 &= val, uint256_t(0xa0ULL));
|
||||
EXPECT_EQ(u16 &= val, uint256_t(0xa0a0ULL));
|
||||
EXPECT_EQ(u32 &= val, uint256_t(0xa0a0a0a0ULL));
|
||||
EXPECT_EQ(u64 &= val, uint256_t(0xa0a0a0a0a0a0a0a0ULL));
|
||||
}
|
||||
|
||||
TEST(External, and){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t & val, uint256_t(0x0ULL));
|
||||
EXPECT_EQ(f & val, uint256_t(0x0ULL));
|
||||
EXPECT_EQ(u8 & val, uint256_t(0xa0ULL));
|
||||
EXPECT_EQ(u16 & val, uint256_t(0xa0a0ULL));
|
||||
EXPECT_EQ(u32 & val, uint256_t(0xa0a0a0a0ULL));
|
||||
EXPECT_EQ(u64 & val, uint256_t(0xa0a0a0a0a0a0a0a0ULL));
|
||||
|
||||
EXPECT_EQ(t &= val, false);
|
||||
EXPECT_EQ(f &= val, false);
|
||||
EXPECT_EQ(u8 &= val, (uint8_t) 0xa0ULL);
|
||||
EXPECT_EQ(u16 &= val, (uint16_t) 0xa0a0ULL);
|
||||
EXPECT_EQ(u32 &= val, (uint32_t) 0xa0a0a0a0ULL);
|
||||
EXPECT_EQ(u64 &= val, (uint64_t) 0xa0a0a0a0a0a0a0a0ULL);
|
||||
|
||||
// zero
|
||||
EXPECT_EQ(uint256_t() & val, 0);
|
||||
}
|
||||
33
thirdparty/uint256_t/tests/testcases/assignment.cpp
vendored
Normal file
33
thirdparty/uint256_t/tests/testcases/assignment.cpp
vendored
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Assignment, all){
|
||||
const uint256_t t_1 = true;
|
||||
const uint256_t f_1 = false;
|
||||
const uint256_t u8_1 = 0x01;
|
||||
const uint256_t u16_1 = 0x0123;
|
||||
const uint256_t u32_1 = 0x01234567;
|
||||
const uint256_t u64_1 = 0x0123456789abcdef;
|
||||
|
||||
uint256_t t_2 = 0;
|
||||
uint256_t f_2 = 0;
|
||||
uint256_t u8_2 = 0;
|
||||
uint256_t u16_2 = 0;
|
||||
uint256_t u32_2 = 0;
|
||||
uint256_t u64_2 = 0;
|
||||
|
||||
t_2 = t_1;
|
||||
f_2 = f_1;
|
||||
u8_2 = u8_1;
|
||||
u16_2 = u16_1;
|
||||
u32_2 = u32_1;
|
||||
u64_2 = u64_1;
|
||||
|
||||
EXPECT_EQ(t_1, t_2);
|
||||
EXPECT_EQ(f_1, f_2);
|
||||
EXPECT_EQ(u8_1, u8_2);
|
||||
EXPECT_EQ(u16_1, u16_2);
|
||||
EXPECT_EQ(u32_1, u32_2);
|
||||
EXPECT_EQ(u64_1, u64_2);
|
||||
}
|
||||
76
thirdparty/uint256_t/tests/testcases/constructor.cpp
vendored
Normal file
76
thirdparty/uint256_t/tests/testcases/constructor.cpp
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Constructor, standard){
|
||||
uint256_t value(0x0123456789abcdefULL);
|
||||
const uint256_t original = value;
|
||||
|
||||
EXPECT_EQ(uint256_t(), 0);
|
||||
EXPECT_EQ(value, original);
|
||||
EXPECT_EQ(uint256_t(std::move(value)), original);
|
||||
EXPECT_EQ(value, 0x0123456789abcdefULL);
|
||||
}
|
||||
|
||||
TEST(Constructor, base_string){
|
||||
EXPECT_EQ(uint256_t("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16), uint256_max);
|
||||
EXPECT_EQ(uint256_t("115792089237316195423570985008687907853269984665640564039457584007913129639935", 10), uint256_max);
|
||||
EXPECT_EQ(uint256_t("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", 2), uint256_max);
|
||||
EXPECT_EQ(uint256_t("0", 10), 0);
|
||||
EXPECT_EQ(uint256_t("0123456789abcdef", 16), 0x0123456789abcdefULL);
|
||||
EXPECT_EQ(uint256_t("755", 8), 0x01ed);
|
||||
EXPECT_EQ(uint256_t("31415926", 10), 0x01df5e76ULL);
|
||||
}
|
||||
|
||||
TEST(Constructor, one){
|
||||
EXPECT_EQ(uint256_t(true).upper(), false);
|
||||
EXPECT_EQ(uint256_t(true).lower(), true);
|
||||
EXPECT_EQ(uint256_t(false).upper(), false);
|
||||
EXPECT_EQ(uint256_t(false).lower(), false);
|
||||
|
||||
EXPECT_EQ(uint256_t((uint8_t) 0x01ULL).upper(), 0ULL);
|
||||
EXPECT_EQ(uint256_t((uint16_t) 0x0123ULL).upper(), 0ULL);
|
||||
EXPECT_EQ(uint256_t((uint32_t) 0x01234567ULL).upper(), 0ULL);
|
||||
EXPECT_EQ(uint256_t((uint64_t) 0x0123456789abcdefULL).upper(), 0ULL);
|
||||
|
||||
EXPECT_EQ(uint256_t((uint8_t) 0x01ULL).lower(), (uint8_t) 0x01ULL);
|
||||
EXPECT_EQ(uint256_t((uint16_t) 0x0123ULL).lower(), (uint16_t) 0x0123ULL);
|
||||
EXPECT_EQ(uint256_t((uint32_t) 0x01234567ULL).lower(), (uint32_t) 0x01234567ULL);
|
||||
EXPECT_EQ(uint256_t((uint64_t) 0x0123456789abcdefULL).lower(), (uint64_t) 0x0123456789abcdefULL);
|
||||
}
|
||||
|
||||
TEST(Constructor, two){
|
||||
for(uint8_t hi = 0; hi < 2; hi++){
|
||||
for(uint8_t lo = 0; lo < 2; lo++){
|
||||
const uint256_t val(hi, lo);
|
||||
EXPECT_EQ(val.upper(), hi);
|
||||
EXPECT_EQ(val.lower(), lo);
|
||||
}
|
||||
}
|
||||
|
||||
EXPECT_EQ(uint256_t((uint8_t) 0x01ULL, (uint8_t) 0x01ULL).upper(), (uint8_t) 0x01ULL);
|
||||
EXPECT_EQ(uint256_t((uint16_t) 0x0123ULL, (uint16_t) 0x0123ULL).upper(), (uint16_t) 0x0123ULL);
|
||||
EXPECT_EQ(uint256_t((uint32_t) 0x01234567ULL, (uint32_t) 0x01234567ULL).upper(), (uint32_t) 0x01234567ULL);
|
||||
EXPECT_EQ(uint256_t((uint64_t) 0x0123456789abcdefULL, (uint64_t) 0x0123456789abcdefULL).upper(), (uint64_t) 0x0123456789abcdefULL);
|
||||
|
||||
EXPECT_EQ(uint256_t((uint8_t) 0x01ULL, (uint8_t) 0x01ULL).lower(), (uint8_t) 0x01ULL);
|
||||
EXPECT_EQ(uint256_t((uint16_t) 0x0123ULL, (uint16_t) 0x0123ULL).lower(), (uint16_t) 0x0123ULL);
|
||||
EXPECT_EQ(uint256_t((uint32_t) 0x01234567ULL, (uint32_t) 0x01234567ULL).lower(), (uint32_t) 0x01234567ULL);
|
||||
EXPECT_EQ(uint256_t((uint64_t) 0x0123456789abcdefULL, (uint64_t) 0x0123456789abcdefULL).lower(), (uint64_t) 0x0123456789abcdefULL);
|
||||
}
|
||||
|
||||
TEST(Constructor, four){
|
||||
for(uint8_t hi_hi = 0; hi_hi < 2; hi_hi++){
|
||||
for(uint8_t hi_lo = 0; hi_lo < 2; hi_lo++){
|
||||
for(uint8_t lo_hi = 0; lo_hi < 2; lo_hi++){
|
||||
for(uint8_t lo_lo = 0; lo_lo < 2; lo_lo++){
|
||||
const uint256_t val(hi_hi, hi_lo, lo_hi, lo_lo);
|
||||
EXPECT_EQ(val.upper().upper(), hi_hi);
|
||||
EXPECT_EQ(val.upper().lower(), hi_lo);
|
||||
EXPECT_EQ(val.lower().upper(), lo_hi);
|
||||
EXPECT_EQ(val.lower().lower(), lo_lo);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
44
thirdparty/uint256_t/tests/testcases/div.cpp
vendored
Normal file
44
thirdparty/uint256_t/tests/testcases/div.cpp
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, divide){
|
||||
const uint256_t big (0xfedbca9876543210ULL);
|
||||
const uint256_t small (0xffffULL);
|
||||
const uint256_t res_val(0xfedcc9753fc9ULL);
|
||||
|
||||
EXPECT_EQ(small / small, 1);
|
||||
EXPECT_EQ(small / big, 0);
|
||||
|
||||
EXPECT_EQ(big / big, 1);
|
||||
|
||||
EXPECT_THROW(uint256_t(1) / uint256_t(0), std::domain_error);
|
||||
}
|
||||
|
||||
TEST(External, divide){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
uint128_t u128 (0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0x7bULL);
|
||||
|
||||
EXPECT_EQ(t / val, false);
|
||||
EXPECT_EQ(f / val, false);
|
||||
EXPECT_EQ(u8 / val, uint256_t(0x1ULL));
|
||||
EXPECT_EQ(u16 / val, uint256_t(0x163ULL));
|
||||
EXPECT_EQ(u32 / val, uint256_t(0x163356bULL));
|
||||
EXPECT_EQ(u64 / val, uint256_t(0x163356b88ac0de0ULL));
|
||||
EXPECT_EQ(u128 / val, uint256_t(0x0000000000000000ULL, 0x0000000000000000ULL, 0x163356b88ac0de0ULL, 0x163356b88ac0de01ULL));
|
||||
|
||||
EXPECT_EQ(t /= val, false);
|
||||
EXPECT_EQ(f /= val, false);
|
||||
EXPECT_EQ(u8 /= val, (uint8_t) 0x1ULL);
|
||||
EXPECT_EQ(u16 /= val, (uint16_t) 0x163ULL);
|
||||
EXPECT_EQ(u32 /= val, (uint32_t) 0x163356bULL);
|
||||
EXPECT_EQ(u64 /= val, (uint64_t) 0x163356b88ac0de0ULL);
|
||||
EXPECT_EQ(u128 /= val, uint128_t(0x163356b88ac0de0ULL, 0x163356b88ac0de01ULL));
|
||||
}
|
||||
24
thirdparty/uint256_t/tests/testcases/equals.cpp
vendored
Normal file
24
thirdparty/uint256_t/tests/testcases/equals.cpp
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Comparison, equals){
|
||||
EXPECT_EQ( (uint256_t(0xdeadbeefULL) == uint256_t(0xdeadbeefULL)), true);
|
||||
EXPECT_EQ(!(uint256_t(0xdeadbeefULL) == uint256_t(0xfee1baadULL)), true);
|
||||
}
|
||||
|
||||
TEST(External, equals){
|
||||
const bool t = true;
|
||||
const bool f = false;
|
||||
const uint8_t u8 = 0xaaULL;
|
||||
const uint16_t u16 = 0xaaaaULL;
|
||||
const uint32_t u32 = 0xaaaaaaaaULL;
|
||||
const uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
|
||||
EXPECT_EQ(t, uint256_t(t));
|
||||
EXPECT_EQ(f, uint256_t(f));
|
||||
EXPECT_EQ(u8, uint256_t(u8));
|
||||
EXPECT_EQ(u16, uint256_t(u16));
|
||||
EXPECT_EQ(u32, uint256_t(u32));
|
||||
EXPECT_EQ(u64, uint256_t(u64));
|
||||
}
|
||||
17
thirdparty/uint256_t/tests/testcases/fix.cpp
vendored
Normal file
17
thirdparty/uint256_t/tests/testcases/fix.cpp
vendored
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, increment){
|
||||
uint256_t value(0);
|
||||
EXPECT_EQ(++value, 1);
|
||||
EXPECT_EQ(value++, 1);
|
||||
EXPECT_EQ(++value, 3);
|
||||
}
|
||||
|
||||
TEST(Arithmetic, decrement){
|
||||
uint256_t value(0);
|
||||
EXPECT_EQ(--value, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL));
|
||||
EXPECT_EQ(value--, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL));
|
||||
EXPECT_EQ(--value, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xfffffffffffffffdULL));
|
||||
}
|
||||
109
thirdparty/uint256_t/tests/testcases/functions.cpp
vendored
Normal file
109
thirdparty/uint256_t/tests/testcases/functions.cpp
vendored
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
#include <map>
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
static const std::map <uint32_t, std::string> tests = {
|
||||
std::make_pair(2, "10000100000101011000010101101100"),
|
||||
std::make_pair(3, "12201102210121112101"),
|
||||
std::make_pair(4, "2010011120111230"),
|
||||
std::make_pair(5, "14014244043144"),
|
||||
std::make_pair(6, "1003520344444"),
|
||||
std::make_pair(7, "105625466632"),
|
||||
std::make_pair(8, "20405302554"),
|
||||
std::make_pair(9, "5642717471"),
|
||||
std::make_pair(10, "2216002924"),
|
||||
std::make_pair(11, "a3796a883"),
|
||||
std::make_pair(12, "51a175124"),
|
||||
std::make_pair(13, "294145645"),
|
||||
std::make_pair(14, "170445352"),
|
||||
std::make_pair(15, "ce82d6d4"),
|
||||
std::make_pair(16, "8415856c"),
|
||||
std::make_pair(17, "56dc4e33"),
|
||||
std::make_pair(18, "3b2db13a"),
|
||||
std::make_pair(19, "291i3b4g"),
|
||||
std::make_pair(20, "1eca0764"),
|
||||
std::make_pair(21, "14hc96jg"),
|
||||
std::make_pair(22, "jblga9e"),
|
||||
std::make_pair(23, "em6i5a5"),
|
||||
std::make_pair(24, "be75374"),
|
||||
std::make_pair(25, "91mo4go"),
|
||||
std::make_pair(26, "74d74li"),
|
||||
std::make_pair(27, "5jblgea"),
|
||||
std::make_pair(28, "4gl7i9g"),
|
||||
std::make_pair(29, "3l13lor"),
|
||||
std::make_pair(30, "315o5e4"),
|
||||
std::make_pair(31, "2fcfub9"),
|
||||
std::make_pair(32, "221b1bc"),
|
||||
std::make_pair(33, "1nkji2p"),
|
||||
std::make_pair(34, "1eq93ik"),
|
||||
std::make_pair(35, "176p6y9"),
|
||||
std::make_pair(36, "10ncmss")
|
||||
// std::make_pair(256, "uint256_t"),
|
||||
};
|
||||
|
||||
TEST(Function, str){
|
||||
// number of leading 0s
|
||||
const std::string::size_type leading = 5;
|
||||
|
||||
// make sure all of the test strings create the ASCII version of the string
|
||||
const uint256_t original(2216002924);
|
||||
for(std::pair <uint32_t const, std::string> t : tests){
|
||||
EXPECT_EQ(original.str(t.first), t.second);
|
||||
}
|
||||
|
||||
// add leading zeros
|
||||
for(uint32_t base = 2; base <= 36; base++){
|
||||
EXPECT_EQ(original.str(base, tests.at(base).size() + leading), std::string(leading, '0') + tests.at(base));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Function, export_bits){
|
||||
const uint64_t u64 = 0x0123456789abcdefULL;
|
||||
const uint256_t value = u64;
|
||||
|
||||
EXPECT_EQ(value, u64);
|
||||
|
||||
const std::vector<uint8_t> full = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
|
||||
};
|
||||
|
||||
EXPECT_EQ(value.export_bits(), full);
|
||||
}
|
||||
|
||||
TEST(Function, export_bits_truncated){
|
||||
const uint64_t u64 = 0x0123456789abcdefULL;
|
||||
const uint256_t value = u64;
|
||||
|
||||
EXPECT_EQ(value, u64);
|
||||
|
||||
const std::vector<uint8_t> truncated = {
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
|
||||
};
|
||||
|
||||
EXPECT_EQ(value.export_bits_truncate(), truncated);
|
||||
}
|
||||
|
||||
TEST(External, ostream){
|
||||
const uint256_t value(0xfedcba9876543210ULL);
|
||||
|
||||
// write out octal uint256_t
|
||||
std::stringstream oct; oct << std::oct << value;
|
||||
EXPECT_EQ(oct.str(), "1773345651416625031020");
|
||||
|
||||
// write out decimal uint256_t
|
||||
std::stringstream dec; dec << std::dec << value;
|
||||
EXPECT_EQ(dec.str(), "18364758544493064720");
|
||||
|
||||
// write out hexadecimal uint256_t
|
||||
std::stringstream hex; hex << std::hex << value;
|
||||
EXPECT_EQ(hex.str(), "fedcba9876543210");
|
||||
|
||||
// zero
|
||||
std::stringstream zero; zero << uint256_t();
|
||||
EXPECT_EQ(zero.str(), "0");
|
||||
}
|
||||
64
thirdparty/uint256_t/tests/testcases/gt.cpp
vendored
Normal file
64
thirdparty/uint256_t/tests/testcases/gt.cpp
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Comparison, greater_than){
|
||||
const uint256_t big (0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
const uint256_t small(0x0000000000000000ULL, 0x0000000000000000ULL);
|
||||
|
||||
EXPECT_EQ(small > small, false);
|
||||
EXPECT_EQ(small > big, false);
|
||||
|
||||
EXPECT_EQ(big > small, true);
|
||||
EXPECT_EQ(big > big, false);
|
||||
}
|
||||
|
||||
#define unsigned_compare_gt(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_unsigned <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = std::numeric_limits <Z>::min(); \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small > int_small, false); \
|
||||
EXPECT_EQ(small > int_big, false); \
|
||||
\
|
||||
EXPECT_EQ(big > int_small, true); \
|
||||
EXPECT_EQ(big > int_big, false); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#define signed_compare_gt(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_signed <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = 1; \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small > int_small, false); \
|
||||
EXPECT_EQ(small > int_big, false); \
|
||||
\
|
||||
EXPECT_EQ(big > int_small, true); \
|
||||
EXPECT_EQ(big > int_big, false); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
TEST(External, greater_than){
|
||||
unsigned_compare_gt(bool);
|
||||
unsigned_compare_gt(uint8_t);
|
||||
unsigned_compare_gt(uint16_t);
|
||||
unsigned_compare_gt(uint32_t);
|
||||
unsigned_compare_gt(uint64_t);
|
||||
signed_compare_gt(int8_t);
|
||||
signed_compare_gt(int16_t);
|
||||
signed_compare_gt(int32_t);
|
||||
signed_compare_gt(int64_t);
|
||||
}
|
||||
64
thirdparty/uint256_t/tests/testcases/gte.cpp
vendored
Normal file
64
thirdparty/uint256_t/tests/testcases/gte.cpp
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Comparison, greater_than_or_equals){
|
||||
const uint256_t big (0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
const uint256_t small(0x0000000000000000ULL, 0x0000000000000000ULL);
|
||||
|
||||
EXPECT_EQ(small >= small, true);
|
||||
EXPECT_EQ(small >= big, false);
|
||||
|
||||
EXPECT_EQ(big >= small, true);
|
||||
EXPECT_EQ(big >= big, true);
|
||||
}
|
||||
|
||||
#define unsigned_compare_gte(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_unsigned <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = std::numeric_limits <Z>::min(); \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small >= int_small, true); \
|
||||
EXPECT_EQ(small >= int_big, false); \
|
||||
\
|
||||
EXPECT_EQ(big >= int_small, true); \
|
||||
EXPECT_EQ(big >= int_big, true); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#define signed_compare_gte(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_signed <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = 1; \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small >= int_small, true) ; \
|
||||
EXPECT_EQ(small >= int_big, false); \
|
||||
\
|
||||
EXPECT_EQ(big >= int_small, true); \
|
||||
EXPECT_EQ(big >= int_big, true); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
TEST(External, greater_than_or_equals){
|
||||
unsigned_compare_gte(bool);
|
||||
unsigned_compare_gte(uint8_t);
|
||||
unsigned_compare_gte(uint16_t);
|
||||
unsigned_compare_gte(uint32_t);
|
||||
unsigned_compare_gte(uint64_t);
|
||||
signed_compare_gte(int8_t);
|
||||
signed_compare_gte(int16_t);
|
||||
signed_compare_gte(int32_t);
|
||||
signed_compare_gte(int64_t);
|
||||
}
|
||||
23
thirdparty/uint256_t/tests/testcases/invert.cpp
vendored
Normal file
23
thirdparty/uint256_t/tests/testcases/invert.cpp
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(BitWise, invert){
|
||||
for(uint8_t hi_hi = 0; hi_hi < 2; hi_hi++){
|
||||
for(uint8_t hi_lo = 0; hi_lo < 2; hi_lo++){
|
||||
for(uint8_t lo_hi = 0; lo_hi < 2; lo_hi++){
|
||||
for(uint8_t lo_lo = 0; lo_lo < 2; lo_lo++){
|
||||
const uint256_t val = ~uint256_t(hi_hi?0xffffffffffffffffULL:0x0000000000000000ULL,
|
||||
hi_lo?0xffffffffffffffffULL:0x0000000000000000ULL,
|
||||
lo_hi?0xffffffffffffffffULL:0x0000000000000000ULL,
|
||||
lo_lo?0xffffffffffffffffULL:0x0000000000000000ULL);
|
||||
|
||||
EXPECT_EQ(val.upper().upper(), hi_hi?0x0000000000000000ULL:0xffffffffffffffffULL);
|
||||
EXPECT_EQ(val.upper().lower(), hi_lo?0x0000000000000000ULL:0xffffffffffffffffULL);
|
||||
EXPECT_EQ(val.lower().upper(), lo_hi?0x0000000000000000ULL:0xffffffffffffffffULL);
|
||||
EXPECT_EQ(val.lower().lower(), lo_lo?0x0000000000000000ULL:0xffffffffffffffffULL);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
83
thirdparty/uint256_t/tests/testcases/leftshift.cpp
vendored
Normal file
83
thirdparty/uint256_t/tests/testcases/leftshift.cpp
vendored
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(BitShift, left){
|
||||
// operator<<
|
||||
uint256_t val(0x1);
|
||||
uint64_t exp_val = 1;
|
||||
for(uint8_t i = 0; i < 64; i++){
|
||||
EXPECT_EQ(val << i, exp_val << i);
|
||||
}
|
||||
|
||||
uint256_t zero(0);
|
||||
for(uint8_t i = 0; i < 64; i++){
|
||||
EXPECT_EQ(zero << i, 0);
|
||||
}
|
||||
|
||||
// operator<<=
|
||||
for(uint8_t i = 0; i < 63; i++){ // 1 is already a bit
|
||||
EXPECT_EQ(val <<= 1, exp_val <<= 1);
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < 63; i++){
|
||||
EXPECT_EQ(zero <<= 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(External, shift_left){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xffULL;
|
||||
uint16_t u16 = 0xffffULL;
|
||||
uint32_t u32 = 0xffffffffULL;
|
||||
uint64_t u64 = 0xffffffffffffffffULL;
|
||||
uint128_t u128 (0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
|
||||
const uint256_t zero(0);
|
||||
const uint256_t one(1);
|
||||
|
||||
EXPECT_EQ(t << zero, t);
|
||||
EXPECT_EQ(f << zero, f);
|
||||
EXPECT_EQ(u8 << zero, u8);
|
||||
EXPECT_EQ(u16 << zero, u16);
|
||||
EXPECT_EQ(u32 << zero, u32);
|
||||
EXPECT_EQ(u64 << zero, u64);
|
||||
EXPECT_EQ(u128 << zero, u128);
|
||||
|
||||
EXPECT_EQ(t <<= zero, t);
|
||||
EXPECT_EQ(f <<= zero, f);
|
||||
EXPECT_EQ(u8 <<= zero, u8);
|
||||
EXPECT_EQ(u16 <<= zero, u16);
|
||||
EXPECT_EQ(u32 <<= zero, u32);
|
||||
EXPECT_EQ(u64 <<= zero, u64);
|
||||
EXPECT_EQ(u128 <<= zero, u128);
|
||||
|
||||
EXPECT_EQ(t << one, uint256_t(t) << 1);
|
||||
EXPECT_EQ(f << one, uint256_t(f) << 1);
|
||||
EXPECT_EQ(u8 << one, uint256_t(u8) << 1);
|
||||
EXPECT_EQ(u16 << one, uint256_t(u16) << 1);
|
||||
EXPECT_EQ(u32 << one, uint256_t(u32) << 1);
|
||||
EXPECT_EQ(u64 << one, uint256_t(u64) << 1);
|
||||
EXPECT_EQ(u128 << one, uint256_t(u128) << 1);
|
||||
|
||||
EXPECT_EQ(t <<= one, true);
|
||||
EXPECT_EQ(f <<= one, false);
|
||||
EXPECT_EQ(u8 <<= one, (uint8_t) 0xfeULL);
|
||||
EXPECT_EQ(u16 <<= one, (uint16_t) 0xfffeULL);
|
||||
EXPECT_EQ(u32 <<= one, (uint32_t) 0xfffffffeULL);
|
||||
EXPECT_EQ(u64 <<= one, (uint64_t) 0xfffffffffffffffeULL);
|
||||
EXPECT_EQ(u128 <<= one, uint128_t (0xffffffffffffffffULL, 0xfffffffffffffffeULL));
|
||||
|
||||
EXPECT_EQ(u8 << uint256_t(7), uint256_t(0x7f00ULL));
|
||||
EXPECT_EQ(u16 << uint256_t(15), uint256_t(0x7fff0000ULL));
|
||||
EXPECT_EQ(u32 << uint256_t(31), uint256_t(0x7fffffff00000000ULL));
|
||||
EXPECT_EQ(u64 << uint256_t(63), uint256_t(0x0000000000000000ULL, 0x0000000000000000ULL, 0x7fffffffffffffffULL, 0x0000000000000000ULL));
|
||||
EXPECT_EQ(u128 << uint256_t(127), uint256_t(0x7fffffffffffffffULL, 0xffffffffffffffffULL, 0x0000000000000000ULL, 0x0000000000000000ULL));
|
||||
|
||||
EXPECT_EQ(u8 <<= uint256_t(7), (uint8_t) 0);
|
||||
EXPECT_EQ(u16 <<= uint256_t(15), (uint16_t) 0);
|
||||
EXPECT_EQ(u32 <<= uint256_t(31), (uint32_t) 0);
|
||||
EXPECT_EQ(u64 <<= uint256_t(63), (uint64_t) 0);
|
||||
EXPECT_EQ(u128 <<= uint256_t(127), (uint128_t) 0);
|
||||
}
|
||||
23
thirdparty/uint256_t/tests/testcases/logical.cpp
vendored
Normal file
23
thirdparty/uint256_t/tests/testcases/logical.cpp
vendored
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Logical, and){
|
||||
const uint256_t A(0xffffffff);
|
||||
const uint256_t B(0x00000000);
|
||||
|
||||
EXPECT_EQ(A && A, true);
|
||||
EXPECT_EQ(A && B, false);
|
||||
}
|
||||
|
||||
TEST(Logical, or){
|
||||
const uint256_t A(0xffffffff);
|
||||
const uint256_t B(0x00000000);
|
||||
|
||||
EXPECT_EQ(A || A, true);
|
||||
EXPECT_EQ(A || B, true);
|
||||
}
|
||||
|
||||
TEST(Logical, not){
|
||||
EXPECT_EQ(!uint256_t(0xffffffff), 0);
|
||||
}
|
||||
64
thirdparty/uint256_t/tests/testcases/lt.cpp
vendored
Normal file
64
thirdparty/uint256_t/tests/testcases/lt.cpp
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Comparison, less_than){
|
||||
const uint256_t big (0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
const uint256_t small(0x0000000000000000ULL, 0x0000000000000000ULL);
|
||||
|
||||
EXPECT_EQ(small < small, false);
|
||||
EXPECT_EQ(small < big, true);
|
||||
|
||||
EXPECT_EQ(big < small, false);
|
||||
EXPECT_EQ(big < big, false);
|
||||
}
|
||||
|
||||
#define unsigned_compare_lt(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_unsigned <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = std::numeric_limits <Z>::min(); \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small < int_small, false); \
|
||||
EXPECT_EQ(small < int_big, true); \
|
||||
\
|
||||
EXPECT_EQ(big < int_small, false); \
|
||||
EXPECT_EQ(big < int_big, false); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#define signed_compare_lt(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_signed <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = 1; \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small < int_small, false); \
|
||||
EXPECT_EQ(small < int_big, true); \
|
||||
\
|
||||
EXPECT_EQ(big < int_small, false); \
|
||||
EXPECT_EQ(big < int_big, false); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
TEST(External, less_than){
|
||||
unsigned_compare_lt(bool);
|
||||
unsigned_compare_lt(uint8_t);
|
||||
unsigned_compare_lt(uint16_t);
|
||||
unsigned_compare_lt(uint32_t);
|
||||
unsigned_compare_lt(uint64_t);
|
||||
signed_compare_lt(int8_t);
|
||||
signed_compare_lt(int16_t);
|
||||
signed_compare_lt(int32_t);
|
||||
signed_compare_lt(int64_t);
|
||||
}
|
||||
64
thirdparty/uint256_t/tests/testcases/lte.cpp
vendored
Normal file
64
thirdparty/uint256_t/tests/testcases/lte.cpp
vendored
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Comparison, less_than_or_equals){
|
||||
const uint256_t big (0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
const uint256_t small(0x0000000000000000ULL, 0x0000000000000000ULL);
|
||||
|
||||
EXPECT_EQ(small <= small, true);
|
||||
EXPECT_EQ(small <= big, true);
|
||||
|
||||
EXPECT_EQ(big <= small, false);
|
||||
EXPECT_EQ(big <= big, true);
|
||||
}
|
||||
|
||||
#define unsigned_compare_lte(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_unsigned <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = std::numeric_limits <Z>::min(); \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small <= int_small, true); \
|
||||
EXPECT_EQ(small <= int_big, true); \
|
||||
\
|
||||
EXPECT_EQ(big <= int_small, false); \
|
||||
EXPECT_EQ(big <= int_big, true); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
#define signed_compare_lte(Z) \
|
||||
do \
|
||||
{ \
|
||||
static_assert(std::is_signed <Z>::value, "Type must be signed"); \
|
||||
\
|
||||
const Z small = 1; \
|
||||
const Z big = std::numeric_limits <Z>::max(); \
|
||||
\
|
||||
const uint256_t int_small(small); \
|
||||
const uint256_t int_big(big); \
|
||||
\
|
||||
EXPECT_EQ(small <= int_small, true); \
|
||||
EXPECT_EQ(small <= int_big, true); \
|
||||
\
|
||||
EXPECT_EQ(big <= int_small, false); \
|
||||
EXPECT_EQ(big <= int_big, true); \
|
||||
} \
|
||||
while (0)
|
||||
|
||||
TEST(External, less_than_or_equals){
|
||||
unsigned_compare_lte(bool);
|
||||
unsigned_compare_lte(uint8_t);
|
||||
unsigned_compare_lte(uint16_t);
|
||||
unsigned_compare_lte(uint32_t);
|
||||
unsigned_compare_lte(uint64_t);
|
||||
signed_compare_lte(int8_t);
|
||||
signed_compare_lte(int16_t);
|
||||
signed_compare_lte(int32_t);
|
||||
signed_compare_lte(int64_t);
|
||||
}
|
||||
46
thirdparty/uint256_t/tests/testcases/mod.cpp
vendored
Normal file
46
thirdparty/uint256_t/tests/testcases/mod.cpp
vendored
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, modulo){
|
||||
// has remainder
|
||||
const uint256_t val (0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
const uint256_t val_mod(0xfedcba9876543210ULL);
|
||||
|
||||
EXPECT_EQ(val % val_mod, uint256_t(0x63794f9d55c8d29f));
|
||||
|
||||
// no remainder
|
||||
const uint256_t val_0 (0xfedcba9876543210, 0, 0, 0);
|
||||
EXPECT_EQ(val_0 % val_mod, 0);
|
||||
|
||||
// mod 0
|
||||
EXPECT_THROW(uint256_t(1) % uint256_t(0), std::domain_error);
|
||||
}
|
||||
|
||||
TEST(External, modulo){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
uint128_t u128 (0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0xd03ULL); // prime
|
||||
|
||||
EXPECT_EQ(t % val, true);
|
||||
EXPECT_EQ(f % val, false);
|
||||
EXPECT_EQ(u8 % val, uint256_t(0xaaULL));
|
||||
EXPECT_EQ(u16 % val, uint256_t(0x183ULL));
|
||||
EXPECT_EQ(u32 % val, uint256_t(0x249ULL));
|
||||
EXPECT_EQ(u64 % val, uint256_t(0xc7fULL));
|
||||
EXPECT_EQ(u128 % val, uint256_t(0x9fbULL));
|
||||
|
||||
EXPECT_EQ(t %= val, true);
|
||||
EXPECT_EQ(f %= val, false);
|
||||
EXPECT_EQ(u8 %= val, (uint8_t) 0xaaULL);
|
||||
EXPECT_EQ(u16 %= val, (uint16_t) 0x183ULL);
|
||||
EXPECT_EQ(u32 %= val, (uint32_t) 0x249ULL);
|
||||
EXPECT_EQ(u64 %= val, (uint64_t) 0xc7fULL);
|
||||
EXPECT_EQ(u128 %= val, (uint256_t) 0x9fbULL);
|
||||
}
|
||||
45
thirdparty/uint256_t/tests/testcases/mult.cpp
vendored
Normal file
45
thirdparty/uint256_t/tests/testcases/mult.cpp
vendored
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, multiply){
|
||||
uint256_t val(0xfedbca9876543210ULL);
|
||||
|
||||
EXPECT_EQ(val * val, uint256_t(0x0000000000000000ULL, 0x0000000000000000ULL, 0xfdb8e2bacbfe7cefULL, 0x010e6cd7a44a4100ULL));
|
||||
|
||||
const uint256_t zero = 0;
|
||||
EXPECT_EQ(val * zero, zero);
|
||||
EXPECT_EQ(zero * val, zero);
|
||||
|
||||
const uint256_t one = 1;
|
||||
EXPECT_EQ(val * one, val);
|
||||
EXPECT_EQ(one * val, val);
|
||||
}
|
||||
|
||||
TEST(External, multiply){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
uint128_t u128 (0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t * val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(f * val, uint256_t(0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL));
|
||||
EXPECT_EQ(u8 * val, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffff60ULL));
|
||||
EXPECT_EQ(u16 * val, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffff5f60ULL));
|
||||
EXPECT_EQ(u32 * val, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffff5f5f5f60ULL));
|
||||
EXPECT_EQ(u64 * val, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x5f5f5f5f5f5f5f60ULL));
|
||||
EXPECT_EQ(u128 * val, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0x5f5f5f5f5f5f5f5fULL, 0x5f5f5f5f5f5f5f60ULL));
|
||||
|
||||
EXPECT_EQ(t *= val, true);
|
||||
EXPECT_EQ(f *= val, false);
|
||||
EXPECT_EQ(u8 *= val, (uint8_t) 0x60ULL);
|
||||
EXPECT_EQ(u16 *= val, (uint16_t) 0x5f60ULL);
|
||||
EXPECT_EQ(u32 *= val, (uint32_t) 0x5f5f5f60ULL);
|
||||
EXPECT_EQ(u64 *= val, (uint64_t) 0x5f5f5f5f5f5f5f60ULL);
|
||||
EXPECT_EQ(u128 *= val, uint128_t(0x5f5f5f5f5f5f5f5fULL, 0x5f5f5f5f5f5f5f60ULL));
|
||||
}
|
||||
31
thirdparty/uint256_t/tests/testcases/notequals.cpp
vendored
Normal file
31
thirdparty/uint256_t/tests/testcases/notequals.cpp
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Comparison, not_equals){
|
||||
EXPECT_EQ(!(uint256_t(0xdeadbeefULL) != uint256_t(0xdeadbeefULL)), true);
|
||||
EXPECT_EQ( (uint256_t(0xdeadbeefULL) != uint256_t(0xfee1baadULL)), true);
|
||||
}
|
||||
|
||||
TEST(External, not_equals){
|
||||
const bool t = true;
|
||||
const bool f = false;
|
||||
const uint8_t u8 = 0xaaULL;
|
||||
const uint16_t u16 = 0xaaaaULL;
|
||||
const uint32_t u32 = 0xaaaaaaaaULL;
|
||||
const uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
|
||||
EXPECT_EQ((t != uint256_t(f)), true);
|
||||
EXPECT_EQ((f != uint256_t(t)), true);
|
||||
EXPECT_EQ((u8 != uint256_t(u64)), true);
|
||||
EXPECT_EQ((u16 != uint256_t(u32)), true);
|
||||
EXPECT_EQ((u32 != uint256_t(u16)), true);
|
||||
EXPECT_EQ((u64 != uint256_t(u8)), true);
|
||||
|
||||
EXPECT_EQ((t != uint256_t(t)), false);
|
||||
EXPECT_EQ((f != uint256_t(f)), false);
|
||||
EXPECT_EQ((u8 != uint256_t(u8)), false);
|
||||
EXPECT_EQ((u16 != uint256_t(u16)), false);
|
||||
EXPECT_EQ((u32 != uint256_t(u32)), false);
|
||||
EXPECT_EQ((u64 != uint256_t(u64)), false);
|
||||
}
|
||||
59
thirdparty/uint256_t/tests/testcases/or.cpp
vendored
Normal file
59
thirdparty/uint256_t/tests/testcases/or.cpp
vendored
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(BitWise, or){
|
||||
uint256_t t ((bool) true);
|
||||
uint256_t f ((bool) false);
|
||||
uint256_t u8 ((uint8_t) 0xaaULL);
|
||||
uint256_t u16((uint16_t) 0xaaaaULL);
|
||||
uint256_t u32((uint32_t) 0xaaaaaaaaULL);
|
||||
uint256_t u64((uint64_t) 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0faULL));
|
||||
EXPECT_EQ(u16 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0fafaULL));
|
||||
EXPECT_EQ(u32 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0fafafafaULL));
|
||||
EXPECT_EQ(u64 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xfafafafafafafafaULL));
|
||||
|
||||
EXPECT_EQ(t |= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f |= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 |= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0faULL));
|
||||
EXPECT_EQ(u16 |= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0fafaULL));
|
||||
EXPECT_EQ(u32 |= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0fafafafaULL));
|
||||
EXPECT_EQ(u64 |= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xfafafafafafafafaULL));
|
||||
|
||||
// zero
|
||||
EXPECT_EQ(uint256_t() | val, val);
|
||||
}
|
||||
|
||||
TEST(External, or){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaa;
|
||||
uint16_t u16 = 0xaaaa;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0faULL));
|
||||
EXPECT_EQ(u16 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0fafaULL));
|
||||
EXPECT_EQ(u32 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0fafafafaULL));
|
||||
EXPECT_EQ(u64 | val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xfafafafafafafafaULL));
|
||||
|
||||
EXPECT_EQ(t |= val, true);
|
||||
EXPECT_EQ(f |= val, true);
|
||||
EXPECT_EQ(u8 |= val, (uint8_t) 0xfaULL);
|
||||
EXPECT_EQ(u16 |= val, (uint16_t) 0xfafaULL);
|
||||
EXPECT_EQ(u32 |= val, (uint32_t) 0xfafafafaULL);
|
||||
EXPECT_EQ(u64 |= val, (uint64_t) 0xfafafafafafafafaULL);
|
||||
|
||||
// zero
|
||||
EXPECT_EQ(uint256_t() | val, val);
|
||||
}
|
||||
76
thirdparty/uint256_t/tests/testcases/rightshift.cpp
vendored
Normal file
76
thirdparty/uint256_t/tests/testcases/rightshift.cpp
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(BitShift, right){
|
||||
// operator>>
|
||||
uint256_t val(0xffffffffffffffffULL);
|
||||
uint64_t exp = 0xffffffffffffffffULL;
|
||||
for(uint8_t i = 0; i < 64; i++){
|
||||
EXPECT_EQ(val >> i, exp >> i);
|
||||
}
|
||||
|
||||
uint256_t zero(0);
|
||||
for(uint8_t i = 0; i < 64; i++){
|
||||
EXPECT_EQ(zero >> i, 0);
|
||||
}
|
||||
|
||||
// operator>>=
|
||||
for(uint8_t i = 0; i < 64; i++){
|
||||
EXPECT_EQ(val >>= 1, exp >>= 1);
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < 64; i++){
|
||||
EXPECT_EQ(zero >>= 1, 0);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(External, shift_right){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xffULL;
|
||||
uint16_t u16 = 0xffffULL;
|
||||
uint32_t u32 = 0xffffffffULL;
|
||||
uint64_t u64 = 0xffffffffffffffffULL;
|
||||
|
||||
const uint256_t zero(0);
|
||||
const uint256_t one(1);
|
||||
|
||||
EXPECT_EQ(t >> zero, one);
|
||||
EXPECT_EQ(f >> zero, zero);
|
||||
EXPECT_EQ(u8 >> zero, u8);
|
||||
EXPECT_EQ(u16 >> zero, u16);
|
||||
EXPECT_EQ(u32 >> zero, u32);
|
||||
EXPECT_EQ(u64 >> zero, u64);
|
||||
|
||||
EXPECT_EQ(t >>= zero, t);
|
||||
EXPECT_EQ(f >>= zero, f);
|
||||
EXPECT_EQ(u8 >>= zero, u8);
|
||||
EXPECT_EQ(u16 >>= zero, u16);
|
||||
EXPECT_EQ(u32 >>= zero, u32);
|
||||
EXPECT_EQ(u64 >>= zero, u64);
|
||||
|
||||
EXPECT_EQ(t >> one, uint256_t(t) >> 1);
|
||||
EXPECT_EQ(f >> one, uint256_t(f) >> 1);
|
||||
EXPECT_EQ(u8 >> one, uint256_t(u8) >> 1);
|
||||
EXPECT_EQ(u16 >> one, uint256_t(u16) >> 1);
|
||||
EXPECT_EQ(u32 >> one, uint256_t(u32) >> 1);
|
||||
EXPECT_EQ(u64 >> one, uint256_t(u64) >> 1);
|
||||
|
||||
EXPECT_EQ(t >>= one, false);
|
||||
EXPECT_EQ(f >>= one, false);
|
||||
EXPECT_EQ(u8 >>= one, (uint8_t) 0x7fULL);
|
||||
EXPECT_EQ(u16 >>= one, (uint16_t) 0x7fffULL);
|
||||
EXPECT_EQ(u32 >>= one, (uint32_t) 0x7fffffffULL);
|
||||
EXPECT_EQ(u64 >>= one, (uint64_t) 0x7fffffffffffffffULL);
|
||||
|
||||
EXPECT_EQ(u8 >> uint256_t(7), zero);
|
||||
EXPECT_EQ(u16 >> uint256_t(15), zero);
|
||||
EXPECT_EQ(u32 >> uint256_t(31), zero);
|
||||
EXPECT_EQ(u64 >> uint256_t(63), zero);
|
||||
|
||||
EXPECT_EQ(u8 >>= uint256_t(7), (uint8_t) 0);
|
||||
EXPECT_EQ(u16 >>= uint256_t(15), (uint16_t) 0);
|
||||
EXPECT_EQ(u32 >>= uint256_t(31), (uint32_t) 0);
|
||||
EXPECT_EQ(u64 >>= uint256_t(63), (uint64_t) 0);
|
||||
}
|
||||
41
thirdparty/uint256_t/tests/testcases/sub.cpp
vendored
Normal file
41
thirdparty/uint256_t/tests/testcases/sub.cpp
vendored
Normal file
|
|
@ -0,0 +1,41 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, subtract){
|
||||
uint256_t big (0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL);
|
||||
const uint256_t small(0x0000000000000000ULL, 0x0000000000000001ULL);
|
||||
|
||||
EXPECT_EQ(small - small, 0);
|
||||
EXPECT_EQ(small - big, uint256_t(0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000000000000002ULL));
|
||||
EXPECT_EQ(big - small, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xfffffffffffffffeULL));
|
||||
EXPECT_EQ(big - big, 0);
|
||||
}
|
||||
|
||||
TEST(External, subtract){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
uint128_t u128 (0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f11ULL));
|
||||
EXPECT_EQ(f - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f10ULL));
|
||||
EXPECT_EQ(u8 - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0fbaULL));
|
||||
EXPECT_EQ(u16 - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0fb9baULL));
|
||||
EXPECT_EQ(u32 - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0fb9b9b9baULL));
|
||||
EXPECT_EQ(u64 - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0xb9b9b9b9b9b9b9baULL));
|
||||
EXPECT_EQ(u128 - val, uint256_t(0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL, 0xb9b9b9b9b9b9b9b9ULL, 0xb9b9b9b9b9b9b9baULL));
|
||||
|
||||
EXPECT_EQ(t -= val, true);
|
||||
EXPECT_EQ(f -= val, true);
|
||||
EXPECT_EQ(u8 -= val, (uint8_t) 0xbaULL);
|
||||
EXPECT_EQ(u16 -= val, (uint16_t) 0xb9baULL);
|
||||
EXPECT_EQ(u32 -= val, (uint32_t) 0xb9b9b9baULL);
|
||||
EXPECT_EQ(u64 -= val, (uint64_t) 0xb9b9b9b9b9b9b9baULL);
|
||||
EXPECT_EQ(u128 -= val, uint128_t(0xb9b9b9b9b9b9b9b9ULL, 0xb9b9b9b9b9b9b9baULL));
|
||||
}
|
||||
17
thirdparty/uint256_t/tests/testcases/type_traits.cpp
vendored
Normal file
17
thirdparty/uint256_t/tests/testcases/type_traits.cpp
vendored
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
#include <type_traits>
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Type_Traits, is_arithmetic){
|
||||
EXPECT_EQ(std::is_arithmetic <uint256_t>::value, true);
|
||||
}
|
||||
|
||||
TEST(Type_Traits, is_integral){
|
||||
EXPECT_EQ(std::is_integral <uint256_t>::value, true);
|
||||
}
|
||||
|
||||
TEST(Type_Traits, is_unsigned){
|
||||
EXPECT_EQ(std::is_unsigned <uint256_t>::value, true);
|
||||
}
|
||||
14
thirdparty/uint256_t/tests/testcases/typecast.cpp
vendored
Normal file
14
thirdparty/uint256_t/tests/testcases/typecast.cpp
vendored
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Typecast, all){
|
||||
const uint256_t val(0xaaaaaaaaaaaaaaaaULL, 0xaaaaaaaaaaaaaaaaULL);
|
||||
|
||||
EXPECT_EQ(static_cast <bool> (uint256_t(true)), true);
|
||||
EXPECT_EQ(static_cast <bool> (uint256_t(false)), false);
|
||||
EXPECT_EQ(static_cast <uint8_t> (val), (uint8_t) 0xaaULL);
|
||||
EXPECT_EQ(static_cast <uint16_t> (val), (uint16_t) 0xaaaaULL);
|
||||
EXPECT_EQ(static_cast <uint32_t> (val), (uint32_t) 0xaaaaaaaaULL);
|
||||
EXPECT_EQ(static_cast <uint64_t> (val), (uint64_t) 0xaaaaaaaaaaaaaaaaULL);
|
||||
}
|
||||
16
thirdparty/uint256_t/tests/testcases/unary.cpp
vendored
Normal file
16
thirdparty/uint256_t/tests/testcases/unary.cpp
vendored
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(Arithmetic, unary_plus){
|
||||
const uint256_t value(0x12345ULL);
|
||||
EXPECT_EQ(+value, value);
|
||||
}
|
||||
|
||||
TEST(Arithmetic, unary_minus){
|
||||
const uint256_t val(1);
|
||||
const uint256_t neg = -val;
|
||||
EXPECT_EQ(-val, neg);
|
||||
EXPECT_EQ(-neg, val);
|
||||
EXPECT_EQ(neg, uint256_t(0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL, 0xffffffffffffffffULL));
|
||||
}
|
||||
59
thirdparty/uint256_t/tests/testcases/xor.cpp
vendored
Normal file
59
thirdparty/uint256_t/tests/testcases/xor.cpp
vendored
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "uint256_t.h"
|
||||
|
||||
TEST(BitWise, xor){
|
||||
uint256_t t ((bool) true);
|
||||
uint256_t f ((bool) false);
|
||||
uint256_t u8 ((uint8_t) 0xaaULL);
|
||||
uint256_t u16((uint16_t) 0xaaaaULL);
|
||||
uint256_t u32((uint32_t) 0xaaaaaaaaULL);
|
||||
uint256_t u64((uint64_t) 0xaaaaaaaaaaaaaaaa);
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f05aULL));
|
||||
EXPECT_EQ(u16 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f05a5aULL));
|
||||
EXPECT_EQ(u32 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f05a5a5a5aULL));
|
||||
EXPECT_EQ(u64 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0x5a5a5a5a5a5a5a5aULL));
|
||||
|
||||
EXPECT_EQ(t ^= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f ^= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 ^= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f05aULL));
|
||||
EXPECT_EQ(u16 ^= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f05a5aULL));
|
||||
EXPECT_EQ(u32 ^= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f05a5a5a5aULL));
|
||||
EXPECT_EQ(u64 ^= val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0x5a5a5a5a5a5a5a5aULL));
|
||||
|
||||
// zero
|
||||
EXPECT_EQ(uint256_t() ^ val, val);
|
||||
}
|
||||
|
||||
TEST(External, xor){
|
||||
bool t = true;
|
||||
bool f = false;
|
||||
uint8_t u8 = 0xaaULL;
|
||||
uint16_t u16 = 0xaaaaULL;
|
||||
uint32_t u32 = 0xaaaaaaaaULL;
|
||||
uint64_t u64 = 0xaaaaaaaaaaaaaaaaULL;
|
||||
|
||||
const uint256_t val(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL);
|
||||
|
||||
EXPECT_EQ(t ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f1ULL));
|
||||
EXPECT_EQ(f ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f0f0ULL));
|
||||
EXPECT_EQ(u8 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f0f05aULL));
|
||||
EXPECT_EQ(u16 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f0f0f05a5aULL));
|
||||
EXPECT_EQ(u32 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0xf0f0f0f05a5a5a5aULL));
|
||||
EXPECT_EQ(u64 ^ val, uint256_t(0xf0f0f0f0f0f0f0f0ULL, 0x5a5a5a5a5a5a5a5aULL));
|
||||
|
||||
EXPECT_EQ(t ^= val, true);
|
||||
EXPECT_EQ(f ^= val, true);
|
||||
EXPECT_EQ(u8 ^= val, (uint8_t) 0x5aULL);
|
||||
EXPECT_EQ(u16 ^= val, (uint16_t) 0x5a5aULL);
|
||||
EXPECT_EQ(u32 ^= val, (uint32_t) 0x5a5a5a5aULL);
|
||||
EXPECT_EQ(u64 ^= val, (uint64_t) 0x5a5a5a5a5a5a5a5aULL);
|
||||
|
||||
// zero
|
||||
EXPECT_EQ(uint256_t() ^ val, val);
|
||||
}
|
||||
1162
thirdparty/uint256_t/uint128_t.hpp
vendored
Normal file
1162
thirdparty/uint256_t/uint128_t.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
15
thirdparty/uint256_t/uint256_t.build
vendored
Normal file
15
thirdparty/uint256_t/uint256_t.build
vendored
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
// IMPLEMENTATION BUILD HEADER
|
||||
|
||||
// We need uint128_t symbols as plain "extern", neither import nor export
|
||||
// because we're linking the 128 and 256 object files into a single library
|
||||
// So we can only have one export for symbol in any translation unit
|
||||
#define UINT256_T_EXTERN
|
||||
#include "uint128_t.h"
|
||||
#undef UINT256_T_EXTERN
|
||||
|
||||
#ifndef _UNIT256_T_BUILD
|
||||
#define _UINT256_T_BUILD
|
||||
#include "uint256_t_config.include"
|
||||
#define UINT256_T_EXTERN _UINT256_T_EXPORT
|
||||
#endif
|
||||
#include "uint256_t.include"
|
||||
735
thirdparty/uint256_t/uint256_t.cpp
vendored
Normal file
735
thirdparty/uint256_t/uint256_t.cpp
vendored
Normal file
|
|
@ -0,0 +1,735 @@
|
|||
#include "uint256_t.build"
|
||||
#include <vector>
|
||||
#include <cstring>
|
||||
|
||||
const uint128_t uint128_64(64);
|
||||
const uint128_t uint128_128(128);
|
||||
const uint128_t uint128_256(256);
|
||||
const uint256_t uint256_0(0);
|
||||
const uint256_t uint256_1(1);
|
||||
const uint256_t uint256_max(uint128_t((uint64_t) -1, (uint64_t) -1), uint128_t((uint64_t) -1, (uint64_t) -1));
|
||||
|
||||
uint256_t::uint256_t(const std::string & s, uint8_t base) {
|
||||
init_from_base(s.c_str(), base);
|
||||
}
|
||||
|
||||
uint256_t::uint256_t(const char * s, uint8_t base) {
|
||||
init_from_base(s, base);
|
||||
}
|
||||
|
||||
uint256_t::uint256_t(const bool & b)
|
||||
: uint256_t((uint8_t) b)
|
||||
{}
|
||||
|
||||
void uint256_t::init_from_base(const char * s, uint8_t base) {
|
||||
*this = 0;
|
||||
|
||||
uint256_t power(1);
|
||||
uint8_t digit;
|
||||
int pos = strlen(s) - 1;
|
||||
while(pos >= 0) {
|
||||
digit = 0;
|
||||
if('0' <= s[pos] && s[pos] <= '9') {
|
||||
digit = s[pos] - '0';
|
||||
} else if('a' <= s[pos] && s[pos] <= 'z') {
|
||||
digit = s[pos] - 'a' + 10;
|
||||
}
|
||||
*this += digit * power;
|
||||
pos--;
|
||||
power *= base;
|
||||
}
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator=(const bool & rhs) {
|
||||
UPPER = 0;
|
||||
LOWER = rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t::operator bool() const{
|
||||
return (bool) (UPPER | LOWER);
|
||||
}
|
||||
|
||||
uint256_t::operator uint8_t() const{
|
||||
return (uint8_t) LOWER;
|
||||
}
|
||||
|
||||
uint256_t::operator uint16_t() const{
|
||||
return (uint16_t) LOWER;
|
||||
}
|
||||
|
||||
uint256_t::operator uint32_t() const{
|
||||
return (uint32_t) LOWER;
|
||||
}
|
||||
|
||||
uint256_t::operator uint64_t() const{
|
||||
return (uint64_t) LOWER;
|
||||
}
|
||||
|
||||
uint256_t::operator uint128_t() const{
|
||||
return LOWER;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator&(const uint128_t & rhs) const{
|
||||
return uint256_t(uint128_0, LOWER & rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator&(const uint256_t & rhs) const{
|
||||
return uint256_t(UPPER & rhs.UPPER, LOWER & rhs.LOWER);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator&=(const uint128_t & rhs){
|
||||
UPPER = uint128_0;
|
||||
LOWER &= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator&=(const uint256_t & rhs){
|
||||
UPPER &= rhs.UPPER;
|
||||
LOWER &= rhs.LOWER;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator|(const uint128_t & rhs) const{
|
||||
return uint256_t(UPPER , LOWER | rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator|(const uint256_t & rhs) const{
|
||||
return uint256_t(UPPER | rhs.UPPER, LOWER | rhs.LOWER);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator|=(const uint128_t & rhs){
|
||||
LOWER |= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator|=(const uint256_t & rhs){
|
||||
UPPER |= rhs.UPPER;
|
||||
LOWER |= rhs.LOWER;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator^(const uint128_t & rhs) const{
|
||||
return uint256_t(UPPER, LOWER ^ rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator^(const uint256_t & rhs) const{
|
||||
return uint256_t(UPPER ^ rhs.UPPER, LOWER ^ rhs.LOWER);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator^=(const uint128_t & rhs){
|
||||
LOWER ^= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator^=(const uint256_t & rhs){
|
||||
UPPER ^= rhs.UPPER;
|
||||
LOWER ^= rhs.LOWER;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator~() const{
|
||||
return uint256_t(~UPPER, ~LOWER);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator<<(const uint128_t & rhs) const{
|
||||
return *this << uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator<<(const uint256_t & rhs) const{
|
||||
const uint128_t shift = rhs.LOWER;
|
||||
if (((bool) rhs.UPPER) || (shift >= uint128_256)){
|
||||
return uint256_0;
|
||||
}
|
||||
else if (shift == uint128_128){
|
||||
return uint256_t(LOWER, uint128_0);
|
||||
}
|
||||
else if (shift == uint128_0){
|
||||
return *this;
|
||||
}
|
||||
else if (shift < uint128_128){
|
||||
return uint256_t((UPPER << shift) + (LOWER >> (uint128_128 - shift)), LOWER << shift);
|
||||
}
|
||||
else if ((uint128_256 > shift) && (shift > uint128_128)){
|
||||
return uint256_t(LOWER << (shift - uint128_128), uint128_0);
|
||||
}
|
||||
else{
|
||||
return uint256_0;
|
||||
}
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator<<=(const uint128_t & shift){
|
||||
return *this <<= uint256_t(shift);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator<<=(const uint256_t & shift){
|
||||
*this = *this << shift;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator>>(const uint128_t & rhs) const{
|
||||
return *this >> uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator>>(const uint256_t & rhs) const{
|
||||
const uint128_t shift = rhs.LOWER;
|
||||
if (((bool) rhs.UPPER) | (shift >= uint128_256)){
|
||||
return uint256_0;
|
||||
}
|
||||
else if (shift == uint128_128){
|
||||
return uint256_t(UPPER);
|
||||
}
|
||||
else if (shift == uint128_0){
|
||||
return *this;
|
||||
}
|
||||
else if (shift < uint128_128){
|
||||
return uint256_t(UPPER >> shift, (UPPER << (uint128_128 - shift)) + (LOWER >> shift));
|
||||
}
|
||||
else if ((uint128_256 > shift) && (shift > uint128_128)){
|
||||
return uint256_t(UPPER >> (shift - uint128_128));
|
||||
}
|
||||
else{
|
||||
return uint256_0;
|
||||
}
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator>>=(const uint128_t & shift){
|
||||
return *this >>= uint256_t(shift);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator>>=(const uint256_t & shift){
|
||||
*this = *this >> shift;
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool uint256_t::operator!() const{
|
||||
return ! (bool) *this;
|
||||
}
|
||||
|
||||
bool uint256_t::operator&&(const uint128_t & rhs) const{
|
||||
return (*this && uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator&&(const uint256_t & rhs) const{
|
||||
return ((bool) *this && (bool) rhs);
|
||||
}
|
||||
|
||||
bool uint256_t::operator||(const uint128_t & rhs) const{
|
||||
return (*this || uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator||(const uint256_t & rhs) const{
|
||||
return ((bool) *this || (bool) rhs);
|
||||
}
|
||||
|
||||
bool uint256_t::operator==(const uint128_t & rhs) const{
|
||||
return (*this == uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator==(const uint256_t & rhs) const{
|
||||
return ((UPPER == rhs.UPPER) && (LOWER == rhs.LOWER));
|
||||
}
|
||||
|
||||
bool uint256_t::operator!=(const uint128_t & rhs) const{
|
||||
return (*this != uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator!=(const uint256_t & rhs) const{
|
||||
return ((UPPER != rhs.UPPER) | (LOWER != rhs.LOWER));
|
||||
}
|
||||
|
||||
bool uint256_t::operator>(const uint128_t & rhs) const{
|
||||
return (*this > uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator>(const uint256_t & rhs) const{
|
||||
if (UPPER == rhs.UPPER){
|
||||
return (LOWER > rhs.LOWER);
|
||||
}
|
||||
if (UPPER > rhs.UPPER){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool uint256_t::operator<(const uint128_t & rhs) const{
|
||||
return (*this < uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator<(const uint256_t & rhs) const{
|
||||
if (UPPER == rhs.UPPER){
|
||||
return (LOWER < rhs.LOWER);
|
||||
}
|
||||
if (UPPER < rhs.UPPER){
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool uint256_t::operator>=(const uint128_t & rhs) const{
|
||||
return (*this >= uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator>=(const uint256_t & rhs) const{
|
||||
return ((*this > rhs) | (*this == rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator<=(const uint128_t & rhs) const{
|
||||
return (*this <= uint256_t(rhs));
|
||||
}
|
||||
|
||||
bool uint256_t::operator<=(const uint256_t & rhs) const{
|
||||
return ((*this < rhs) | (*this == rhs));
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator+(const uint128_t & rhs) const{
|
||||
return *this + uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator+(const uint256_t & rhs) const{
|
||||
return uint256_t(UPPER + rhs.UPPER + (((LOWER + rhs.LOWER) < LOWER)?uint128_1:uint128_0), LOWER + rhs.LOWER);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator+=(const uint128_t & rhs){
|
||||
return *this += uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator+=(const uint256_t & rhs){
|
||||
UPPER = rhs.UPPER + UPPER + ((LOWER + rhs.LOWER) < LOWER);
|
||||
LOWER = LOWER + rhs.LOWER;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator-(const uint128_t & rhs) const{
|
||||
return *this - uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator-(const uint256_t & rhs) const{
|
||||
return uint256_t(UPPER - rhs.UPPER - ((LOWER - rhs.LOWER) > LOWER), LOWER - rhs.LOWER);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator-=(const uint128_t & rhs){
|
||||
return *this -= uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator-=(const uint256_t & rhs){
|
||||
*this = *this - rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator*(const uint128_t & rhs) const{
|
||||
return *this * uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator*(const uint256_t & rhs) const{
|
||||
// split values into 4 64-bit parts
|
||||
uint128_t top[4] = {UPPER.upper(), UPPER.lower(), LOWER.upper(), LOWER.lower()};
|
||||
uint128_t bottom[4] = {rhs.upper().upper(), rhs.upper().lower(), rhs.lower().upper(), rhs.lower().lower()};
|
||||
uint128_t products[4][4];
|
||||
|
||||
// multiply each component of the values
|
||||
for(int y = 3; y > -1; y--){
|
||||
for(int x = 3; x > -1; x--){
|
||||
products[3 - y][x] = top[x] * bottom[y];
|
||||
}
|
||||
}
|
||||
|
||||
// first row
|
||||
uint128_t fourth64 = uint128_t(products[0][3].lower());
|
||||
uint128_t third64 = uint128_t(products[0][2].lower()) + uint128_t(products[0][3].upper());
|
||||
uint128_t second64 = uint128_t(products[0][1].lower()) + uint128_t(products[0][2].upper());
|
||||
uint128_t first64 = uint128_t(products[0][0].lower()) + uint128_t(products[0][1].upper());
|
||||
|
||||
// second row
|
||||
third64 += uint128_t(products[1][3].lower());
|
||||
second64 += uint128_t(products[1][2].lower()) + uint128_t(products[1][3].upper());
|
||||
first64 += uint128_t(products[1][1].lower()) + uint128_t(products[1][2].upper());
|
||||
|
||||
// third row
|
||||
second64 += uint128_t(products[2][3].lower());
|
||||
first64 += uint128_t(products[2][2].lower()) + uint128_t(products[2][3].upper());
|
||||
|
||||
// fourth row
|
||||
first64 += uint128_t(products[3][3].lower());
|
||||
|
||||
// combines the values, taking care of carry over
|
||||
return uint256_t(first64 << uint128_64, uint128_0) +
|
||||
uint256_t(third64.upper(), third64 << uint128_64) +
|
||||
uint256_t(second64, uint128_0) +
|
||||
uint256_t(fourth64);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator*=(const uint128_t & rhs){
|
||||
return *this *= uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator*=(const uint256_t & rhs){
|
||||
*this = *this * rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
std::pair <uint256_t, uint256_t> uint256_t::divmod(const uint256_t & lhs, const uint256_t & rhs) const{
|
||||
// Save some calculations /////////////////////
|
||||
if (rhs == uint256_0){
|
||||
throw std::domain_error("Error: division or modulus by 0");
|
||||
}
|
||||
else if (rhs == uint256_1){
|
||||
return std::pair <uint256_t, uint256_t> (lhs, uint256_0);
|
||||
}
|
||||
else if (lhs == rhs){
|
||||
return std::pair <uint256_t, uint256_t> (uint256_1, uint256_0);
|
||||
}
|
||||
else if ((lhs == uint256_0) || (lhs < rhs)){
|
||||
return std::pair <uint256_t, uint256_t> (uint256_0, lhs);
|
||||
}
|
||||
|
||||
std::pair <uint256_t, uint256_t> qr(uint256_0, lhs);
|
||||
uint256_t copyd = rhs << (lhs.bits() - rhs.bits());
|
||||
uint256_t adder = uint256_1 << (lhs.bits() - rhs.bits());
|
||||
if (copyd > qr.second){
|
||||
copyd >>= uint256_1;
|
||||
adder >>= uint256_1;
|
||||
}
|
||||
while (qr.second >= rhs){
|
||||
if (qr.second >= copyd){
|
||||
qr.second -= copyd;
|
||||
qr.first |= adder;
|
||||
}
|
||||
copyd >>= uint256_1;
|
||||
adder >>= uint256_1;
|
||||
}
|
||||
return qr;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator/(const uint128_t & rhs) const{
|
||||
return *this / uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator/(const uint256_t & rhs) const{
|
||||
return divmod(*this, rhs).first;
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator/=(const uint128_t & rhs){
|
||||
return *this /= uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator/=(const uint256_t & rhs){
|
||||
*this = *this / rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator%(const uint128_t & rhs) const{
|
||||
return *this % uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator%(const uint256_t & rhs) const{
|
||||
return *this - (rhs * (*this / rhs));
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator%=(const uint128_t & rhs){
|
||||
return *this %= uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator%=(const uint256_t & rhs){
|
||||
*this = *this % rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator++(){
|
||||
*this += uint256_1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator++(int){
|
||||
uint256_t temp(*this);
|
||||
++*this;
|
||||
return temp;
|
||||
}
|
||||
|
||||
uint256_t & uint256_t::operator--(){
|
||||
*this -= uint256_1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator--(int){
|
||||
uint256_t temp(*this);
|
||||
--*this;
|
||||
return temp;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator+() const{
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t uint256_t::operator-() const{
|
||||
return ~*this + uint256_1;
|
||||
}
|
||||
|
||||
const uint128_t & uint256_t::upper() const {
|
||||
return UPPER;
|
||||
}
|
||||
|
||||
const uint128_t & uint256_t::lower() const {
|
||||
return LOWER;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> uint256_t::export_bits() const {
|
||||
std::vector<uint8_t> ret;
|
||||
ret.reserve(32);
|
||||
UPPER.export_bits(ret);
|
||||
LOWER.export_bits(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::vector<uint8_t> uint256_t::export_bits_truncate() const {
|
||||
std::vector<uint8_t> ret = export_bits();
|
||||
|
||||
//prune the zeroes
|
||||
int i = 0;
|
||||
while (ret[i] == 0 && i < 64) i++;
|
||||
ret.erase(ret.begin(), ret.begin() + i);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
uint16_t uint256_t::bits() const{
|
||||
uint16_t out = 0;
|
||||
if (UPPER){
|
||||
out = 128;
|
||||
uint128_t up = UPPER;
|
||||
while (up){
|
||||
up >>= uint128_1;
|
||||
out++;
|
||||
}
|
||||
}
|
||||
else{
|
||||
uint128_t low = LOWER;
|
||||
while (low){
|
||||
low >>= uint128_1;
|
||||
out++;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
std::string uint256_t::str(uint8_t base, const unsigned int & len) const{
|
||||
if ((base < 2) || (base > 36)){
|
||||
throw std::invalid_argument("Base must be in the range 2-36");
|
||||
}
|
||||
std::string out = "";
|
||||
if (!(*this)){
|
||||
out = "0";
|
||||
}
|
||||
else{
|
||||
std::pair <uint256_t, uint256_t> qr(*this, uint256_0);
|
||||
do{
|
||||
qr = divmod(qr.first, base);
|
||||
out = "0123456789abcdefghijklmnopqrstuvwxyz"[(uint8_t) qr.second] + out;
|
||||
} while (qr.first);
|
||||
}
|
||||
if (out.size() < len){
|
||||
out = std::string(len - out.size(), '0') + out;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
uint256_t operator&(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs & lhs;
|
||||
}
|
||||
|
||||
uint128_t & operator&=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (rhs & lhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator|(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs | lhs;
|
||||
}
|
||||
|
||||
uint128_t & operator|=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (rhs | lhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator^(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs ^ lhs;
|
||||
}
|
||||
|
||||
uint128_t & operator^=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (rhs ^ lhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const bool & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const uint8_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const uint16_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const uint32_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const uint64_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const int8_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const int16_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const int32_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint256_t operator<<(const int64_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) << rhs;
|
||||
}
|
||||
|
||||
uint128_t & operator<<=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (uint256_t(lhs) << rhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const bool & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const uint8_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const uint16_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const uint32_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const uint64_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const int8_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const int16_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const int32_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const int64_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) >> rhs;
|
||||
}
|
||||
|
||||
uint128_t & operator>>=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (uint256_t(lhs) >> rhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
// Comparison Operators
|
||||
bool operator==(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs == lhs;
|
||||
}
|
||||
|
||||
bool operator!=(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs != lhs;
|
||||
}
|
||||
|
||||
bool operator>(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs < lhs;
|
||||
}
|
||||
|
||||
bool operator<(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs > lhs;
|
||||
}
|
||||
|
||||
bool operator>=(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs <= lhs;
|
||||
}
|
||||
|
||||
bool operator<=(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs >= lhs;
|
||||
}
|
||||
|
||||
// Arithmetic Operators
|
||||
uint256_t operator+(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs + lhs;
|
||||
}
|
||||
|
||||
uint128_t & operator+=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (rhs + lhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator-(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return -(rhs - lhs);
|
||||
}
|
||||
|
||||
uint128_t & operator-=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (-(rhs - lhs)).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator*(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return rhs * lhs;
|
||||
}
|
||||
|
||||
uint128_t & operator*=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (rhs * lhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator/(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) / rhs;
|
||||
}
|
||||
|
||||
uint128_t & operator/=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (uint256_t(lhs) / rhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
uint256_t operator%(const uint128_t & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) % rhs;
|
||||
}
|
||||
|
||||
uint128_t & operator%=(uint128_t & lhs, const uint256_t & rhs){
|
||||
lhs = (uint256_t(lhs) % rhs).lower();
|
||||
return lhs;
|
||||
}
|
||||
|
||||
std::ostream & operator<<(std::ostream & stream, const uint256_t & rhs){
|
||||
if (stream.flags() & stream.oct){
|
||||
stream << rhs.str(8);
|
||||
}
|
||||
else if (stream.flags() & stream.dec){
|
||||
stream << rhs.str(10);
|
||||
}
|
||||
else if (stream.flags() & stream.hex){
|
||||
stream << rhs.str(16);
|
||||
}
|
||||
return stream;
|
||||
}
|
||||
8
thirdparty/uint256_t/uint256_t.h
vendored
Normal file
8
thirdparty/uint256_t/uint256_t.h
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
// PUBLIC IMPORT HEADER
|
||||
#ifndef _UINT256_H_
|
||||
#define _UINT256_H_
|
||||
#include "uint256_t_config.include"
|
||||
#define UINT256_T_EXTERN _UINT256_T_IMPORT
|
||||
#include "uint128_t.h"
|
||||
#include "uint256_t.include"
|
||||
#endif
|
||||
1367
thirdparty/uint256_t/uint256_t.hpp
vendored
Normal file
1367
thirdparty/uint256_t/uint256_t.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
634
thirdparty/uint256_t/uint256_t.include
vendored
Normal file
634
thirdparty/uint256_t/uint256_t.include
vendored
Normal file
|
|
@ -0,0 +1,634 @@
|
|||
/*
|
||||
uint256_t.h
|
||||
An unsigned 256 bit integer library for C++
|
||||
|
||||
Copyright (c) 2013 - 2017 Jason Lee @ calccrypto at gmail.com
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
With much help from Auston Sterling
|
||||
|
||||
Thanks to François Dessenne for convincing me
|
||||
to do a general rewrite of this class.
|
||||
*/
|
||||
|
||||
#ifndef __UINT256_T__
|
||||
#define __UINT256_T__
|
||||
|
||||
#include <cstdint>
|
||||
#include <ostream>
|
||||
#include <stdexcept>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
class UINT256_T_EXTERN uint256_t;
|
||||
|
||||
// Give uint256_t type traits
|
||||
namespace std { // This is probably not a good idea
|
||||
template <> struct is_arithmetic <uint256_t> : std::true_type {};
|
||||
template <> struct is_integral <uint256_t> : std::true_type {};
|
||||
template <> struct is_unsigned <uint256_t> : std::true_type {};
|
||||
}
|
||||
|
||||
class uint256_t{
|
||||
private:
|
||||
#ifdef __BIG_ENDIAN__
|
||||
uint128_t UPPER, LOWER;
|
||||
#endif
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
uint128_t LOWER, UPPER;
|
||||
#endif
|
||||
|
||||
public:
|
||||
// Constructors
|
||||
uint256_t() = default;
|
||||
uint256_t(const uint256_t & rhs) = default;
|
||||
uint256_t(uint256_t && rhs) = default;
|
||||
uint256_t(const std::string & s);
|
||||
uint256_t(const char *val);
|
||||
uint256_t(const std::string & s, uint8_t base);
|
||||
uint256_t(const char *val, uint8_t base);
|
||||
uint256_t(const bool & b);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t(const T & rhs)
|
||||
#ifdef __BIG_ENDIAN__
|
||||
: UPPER(uint128_0), LOWER(rhs)
|
||||
#endif
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
: LOWER(rhs), UPPER(uint128_0)
|
||||
#endif
|
||||
{
|
||||
if (std::is_signed<T>::value) {
|
||||
if (rhs < 0) {
|
||||
UPPER = uint128_t(-1, -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename S, typename T, typename = typename std::enable_if <std::is_integral<S>::value && std::is_integral<T>::value, void>::type>
|
||||
uint256_t(const S & upper_rhs, const T & lower_rhs)
|
||||
#ifdef __BIG_ENDIAN__
|
||||
: UPPER(upper_rhs), LOWER(lower_rhs)
|
||||
#endif
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
: LOWER(lower_rhs), UPPER(upper_rhs)
|
||||
#endif
|
||||
{}
|
||||
|
||||
uint256_t(const uint128_t & upper_rhs, const uint128_t & lower_rhs)
|
||||
#ifdef __BIG_ENDIAN__
|
||||
: UPPER(upper_rhs), LOWER(lower_rhs)
|
||||
#endif
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
: LOWER(lower_rhs), UPPER(upper_rhs)
|
||||
#endif
|
||||
{}
|
||||
uint256_t(const uint128_t & lower_rhs)
|
||||
#ifdef __BIG_ENDIAN__
|
||||
: UPPER(uint128_0), LOWER(lower_rhs)
|
||||
#endif
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
: LOWER(lower_rhs), UPPER(uint128_0)
|
||||
#endif
|
||||
{}
|
||||
|
||||
template <typename R, typename S, typename T, typename U,
|
||||
typename = typename std::enable_if<std::is_integral<R>::value &&
|
||||
std::is_integral<S>::value &&
|
||||
std::is_integral<T>::value &&
|
||||
std::is_integral<U>::value, void>::type>
|
||||
uint256_t(const R & upper_lhs, const S & lower_lhs, const T & upper_rhs, const U & lower_rhs)
|
||||
#ifdef __BIG_ENDIAN__
|
||||
: UPPER(upper_lhs, lower_lhs), LOWER(upper_rhs, lower_rhs)
|
||||
#endif
|
||||
#ifdef __LITTLE_ENDIAN__
|
||||
: LOWER(upper_rhs, lower_rhs), UPPER(upper_lhs, lower_lhs)
|
||||
#endif
|
||||
{}
|
||||
|
||||
// RHS input args only
|
||||
std::vector<uint8_t> export_bits() const;
|
||||
std::vector<uint8_t> export_bits_truncate() const;
|
||||
|
||||
// Assignment Operator
|
||||
uint256_t & operator=(const uint256_t & rhs) = default;
|
||||
uint256_t & operator=(uint256_t && rhs) = default;
|
||||
|
||||
template <typename T, typename = typename std::enable_if <std::is_integral<T>::value, T>::type>
|
||||
uint256_t & operator=(const T & rhs){
|
||||
UPPER = uint128_0;
|
||||
|
||||
if (std::is_signed<T>::value) {
|
||||
if (rhs < 0) {
|
||||
UPPER = uint128_t(-1, -1);
|
||||
}
|
||||
}
|
||||
|
||||
LOWER = rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t & operator=(const bool & rhs);
|
||||
|
||||
// Typecast Operators
|
||||
operator bool () const;
|
||||
operator uint8_t () const;
|
||||
operator uint16_t () const;
|
||||
operator uint32_t () const;
|
||||
operator uint64_t () const;
|
||||
operator uint128_t () const;
|
||||
|
||||
// Bitwise Operators
|
||||
uint256_t operator&(const uint128_t & rhs) const;
|
||||
uint256_t operator&(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator&(const T & rhs) const{
|
||||
return uint256_t(uint128_0, LOWER & (uint128_t) rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator&=(const uint128_t & rhs);
|
||||
uint256_t & operator&=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator&=(const T & rhs){
|
||||
UPPER = uint128_0;
|
||||
LOWER &= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t operator|(const uint128_t & rhs) const;
|
||||
uint256_t operator|(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator|(const T & rhs) const{
|
||||
return uint256_t(UPPER, LOWER | uint128_t(rhs));
|
||||
}
|
||||
|
||||
uint256_t & operator|=(const uint128_t & rhs);
|
||||
uint256_t & operator|=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator|=(const T & rhs){
|
||||
LOWER |= (uint128_t) rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t operator^(const uint128_t & rhs) const;
|
||||
uint256_t operator^(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator^(const T & rhs) const{
|
||||
return uint256_t(UPPER, LOWER ^ (uint128_t) rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator^=(const uint128_t & rhs);
|
||||
uint256_t & operator^=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator^=(const T & rhs){
|
||||
LOWER ^= (uint128_t) rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t operator~() const;
|
||||
|
||||
// Bit Shift Operators
|
||||
uint256_t operator<<(const uint128_t & shift) const;
|
||||
uint256_t operator<<(const uint256_t & shift) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator<<(const T & rhs) const{
|
||||
return *this << uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator<<=(const uint128_t & shift);
|
||||
uint256_t & operator<<=(const uint256_t & shift);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator<<=(const T & rhs){
|
||||
*this = *this << uint256_t(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
uint256_t operator>>(const uint128_t & shift) const;
|
||||
uint256_t operator>>(const uint256_t & shift) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator>>(const T & rhs) const{
|
||||
return *this >> uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator>>=(const uint128_t & shift);
|
||||
uint256_t & operator>>=(const uint256_t & shift);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator>>=(const T & rhs){
|
||||
*this = *this >> uint256_t(rhs);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// Logical Operators
|
||||
bool operator!() const;
|
||||
|
||||
bool operator&&(const uint128_t & rhs) const;
|
||||
bool operator&&(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator&&(const T & rhs) const{
|
||||
return ((bool) *this && rhs);
|
||||
}
|
||||
|
||||
bool operator||(const uint128_t & rhs) const;
|
||||
bool operator||(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator||(const T & rhs) const{
|
||||
return ((bool) *this || rhs);
|
||||
}
|
||||
|
||||
// Comparison Operators
|
||||
bool operator==(const uint128_t & rhs) const;
|
||||
bool operator==(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator==(const T & rhs) const{
|
||||
return (!UPPER && (LOWER == uint128_t(rhs)));
|
||||
}
|
||||
|
||||
bool operator!=(const uint128_t & rhs) const;
|
||||
bool operator!=(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator!=(const T & rhs) const{
|
||||
return ((bool) UPPER | (LOWER != uint128_t(rhs)));
|
||||
}
|
||||
|
||||
bool operator>(const uint128_t & rhs) const;
|
||||
bool operator>(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator>(const T & rhs) const{
|
||||
return ((bool) UPPER | (LOWER > uint128_t(rhs)));
|
||||
}
|
||||
|
||||
bool operator<(const uint128_t & rhs) const;
|
||||
bool operator<(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator<(const T & rhs) const{
|
||||
return (!UPPER)?(LOWER < uint128_t(rhs)):false;
|
||||
}
|
||||
|
||||
bool operator>=(const uint128_t & rhs) const;
|
||||
bool operator>=(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator>=(const T & rhs) const{
|
||||
return ((*this > rhs) | (*this == rhs));
|
||||
}
|
||||
|
||||
bool operator<=(const uint128_t & rhs) const;
|
||||
bool operator<=(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator<=(const T & rhs) const{
|
||||
return ((*this < rhs) | (*this == rhs));
|
||||
}
|
||||
|
||||
// Arithmetic Operators
|
||||
uint256_t operator+(const uint128_t & rhs) const;
|
||||
uint256_t operator+(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator+(const T & rhs) const{
|
||||
return uint256_t(UPPER + ((LOWER + (uint128_t) rhs) < LOWER), LOWER + (uint128_t) rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator+=(const uint128_t & rhs);
|
||||
uint256_t & operator+=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator+=(const T & rhs){
|
||||
return *this += uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t operator-(const uint128_t & rhs) const;
|
||||
uint256_t operator-(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator-(const T & rhs) const{
|
||||
return uint256_t(UPPER - ((LOWER - rhs) > LOWER), LOWER - rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator-=(const uint128_t & rhs);
|
||||
uint256_t & operator-=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator-=(const T & rhs){
|
||||
return *this = *this - uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t operator*(const uint128_t & rhs) const;
|
||||
uint256_t operator*(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator*(const T & rhs) const{
|
||||
return *this * uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator*=(const uint128_t & rhs);
|
||||
uint256_t & operator*=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator*=(const T & rhs){
|
||||
return *this = *this * uint256_t(rhs);
|
||||
}
|
||||
|
||||
private:
|
||||
std::pair <uint256_t, uint256_t> divmod(const uint256_t & lhs, const uint256_t & rhs) const;
|
||||
void init(const char * s);
|
||||
void init_from_base(const char * s, uint8_t base);
|
||||
|
||||
public:
|
||||
uint256_t operator/(const uint128_t & rhs) const;
|
||||
uint256_t operator/(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator/(const T & rhs) const{
|
||||
return *this / uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator/=(const uint128_t & rhs);
|
||||
uint256_t & operator/=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator/=(const T & rhs){
|
||||
return *this = *this / uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t operator%(const uint128_t & rhs) const;
|
||||
uint256_t operator%(const uint256_t & rhs) const;
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator%(const T & rhs) const{
|
||||
return *this % uint256_t(rhs);
|
||||
}
|
||||
|
||||
uint256_t & operator%=(const uint128_t & rhs);
|
||||
uint256_t & operator%=(const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t & operator%=(const T & rhs){
|
||||
return *this = *this % uint256_t(rhs);
|
||||
}
|
||||
|
||||
// Increment Operators
|
||||
uint256_t & operator++();
|
||||
uint256_t operator++(int);
|
||||
|
||||
// Decrement Operators
|
||||
uint256_t & operator--();
|
||||
uint256_t operator--(int);
|
||||
|
||||
// Nothing done since promotion doesn't work here
|
||||
uint256_t operator+() const;
|
||||
|
||||
// two's complement
|
||||
uint256_t operator-() const;
|
||||
|
||||
// Get private values
|
||||
const uint128_t & upper() const;
|
||||
const uint128_t & lower() const;
|
||||
|
||||
// Get bitsize of value
|
||||
uint16_t bits() const;
|
||||
|
||||
// Get string representation of value
|
||||
std::string str(uint8_t base = 10, const unsigned int & len = 0) const;
|
||||
};
|
||||
|
||||
// useful values
|
||||
UINT256_T_EXTERN extern const uint128_t uint128_64;
|
||||
UINT256_T_EXTERN extern const uint128_t uint128_128;
|
||||
UINT256_T_EXTERN extern const uint128_t uint128_256;
|
||||
UINT256_T_EXTERN extern const uint256_t uint256_0;
|
||||
UINT256_T_EXTERN extern const uint256_t uint256_1;
|
||||
UINT256_T_EXTERN extern const uint256_t uint256_max;
|
||||
|
||||
// Bitwise Operators
|
||||
UINT256_T_EXTERN uint256_t operator&(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator&(const T & lhs, const uint256_t & rhs){
|
||||
return rhs & lhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator&=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator&=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (rhs & lhs);
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator|(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator|(const T & lhs, const uint256_t & rhs){
|
||||
return rhs | lhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator|=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator|=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (rhs | lhs);
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator^(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator^(const T & lhs, const uint256_t & rhs){
|
||||
return rhs ^ lhs;
|
||||
}
|
||||
|
||||
uint128_t & operator^=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator^=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (rhs ^ lhs);
|
||||
}
|
||||
|
||||
// Bitshift operators
|
||||
UINT256_T_EXTERN uint256_t operator<<(const bool & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const uint8_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const uint16_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const uint32_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const uint64_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const uint128_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const int8_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const int16_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const int32_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator<<(const int64_t & lhs, const uint256_t & rhs);
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator<<=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator<<=(T & lhs, const uint256_t & rhs){
|
||||
lhs = static_cast <T> (uint256_t(lhs) << rhs);
|
||||
return lhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator>>(const bool & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const uint8_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const uint16_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const uint32_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const uint64_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const uint128_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const int8_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const int16_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const int32_t & lhs, const uint256_t & rhs);
|
||||
UINT256_T_EXTERN uint256_t operator>>(const int64_t & lhs, const uint256_t & rhs);
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator>>=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator>>=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (uint256_t(lhs) >> rhs);
|
||||
}
|
||||
|
||||
// Comparison Operators
|
||||
UINT256_T_EXTERN bool operator==(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator==(const T & lhs, const uint256_t & rhs){
|
||||
return (!rhs.upper() && ((uint64_t) lhs == rhs.lower()));
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN bool operator!=(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator!=(const T & lhs, const uint256_t & rhs){
|
||||
return (rhs.upper() | ((uint64_t) lhs != rhs.lower()));
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN bool operator>(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator>(const T & lhs, const uint256_t & rhs){
|
||||
return rhs.upper()?false:((uint128_t) lhs > rhs.lower());
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN bool operator<(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator<(const T & lhs, const uint256_t & rhs){
|
||||
return rhs.upper()?true:((uint128_t) lhs < rhs.lower());
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN bool operator>=(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator>=(const T & lhs, const uint256_t & rhs){
|
||||
return rhs.upper()?false:((uint128_t) lhs >= rhs.lower());
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN bool operator<=(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
bool operator<=(const T & lhs, const uint256_t & rhs){
|
||||
return rhs.upper()?true:((uint128_t) lhs <= rhs.lower());
|
||||
}
|
||||
|
||||
// Arithmetic Operators
|
||||
UINT256_T_EXTERN uint256_t operator+(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator+(const T & lhs, const uint256_t & rhs){
|
||||
return rhs + lhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator+=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator+=(T & lhs, const uint256_t & rhs){
|
||||
lhs = static_cast <T> (rhs + lhs);
|
||||
return lhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator-(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator-(const T & lhs, const uint256_t & rhs){
|
||||
return -(rhs - lhs);
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator-=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator-=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (-(rhs - lhs));
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator*(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator*(const T & lhs, const uint256_t & rhs){
|
||||
return rhs * lhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator*=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator*=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (rhs * lhs);
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator/(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator/(const T & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) / rhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator/=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator/=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (uint256_t(lhs) / rhs);
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint256_t operator%(const uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
uint256_t operator%(const T & lhs, const uint256_t & rhs){
|
||||
return uint256_t(lhs) % rhs;
|
||||
}
|
||||
|
||||
UINT256_T_EXTERN uint128_t & operator%=(uint128_t & lhs, const uint256_t & rhs);
|
||||
|
||||
template <typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type >
|
||||
T & operator%=(T & lhs, const uint256_t & rhs){
|
||||
return lhs = static_cast <T> (uint256_t(lhs) % rhs);
|
||||
}
|
||||
|
||||
// IO Operator
|
||||
UINT256_T_EXTERN std::ostream & operator<<(std::ostream & stream, const uint256_t & rhs);
|
||||
#endif
|
||||
19
thirdparty/uint256_t/uint256_t_config.include
vendored
Normal file
19
thirdparty/uint256_t/uint256_t_config.include
vendored
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
#ifndef _UINT256_T_CONFIG_
|
||||
#define _UINT256_T_CONFIG_
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_DLL)
|
||||
#define _UINT256_T_EXPORT __declspec(dllexport)
|
||||
#define _UINT256_T_IMPORT __declspec(dllimport)
|
||||
#else
|
||||
#define _UINT256_T_EXPORT
|
||||
#define _UINT256_T_IMPORT
|
||||
#endif
|
||||
#else
|
||||
// All modules on Unix are compiled with -fvisibility=hidden
|
||||
// All API symbols get visibility default
|
||||
// whether or not we're static linking or dynamic linking (with -fPIC)
|
||||
#define _UINT256_T_EXPORT __attribute__((visibility("default")))
|
||||
#define _UINT256_T_IMPORT __attribute__((visibility("default")))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue