dnomd343
/
klotski
mirror of https://github.com/dnomd343/klotski.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

update: enhance CommonCode module

legacy
Dnomd343 2 years ago
parent
6f67d649cf
commit
cc2042f9cf
5 changed files with 125 additions and 146 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 67
      src/klotski_core/common_code/common_code.cc
  2. 40
      src/klotski_core/common_code/common_code.h
  3. 8
      src/klotski_core/common_code/convert.cc
  4. 16
      src/klotski_core/common_code/serialize.cc
  5. 4
      test/codec/short_code.cc

67
src/klotski_core/common_code/common_code.cc
View File

@ -1,44 +1,12 @@
#include "common.h" #include "common.h"
#include "common_code.h" #include "common_code.h"
using klotski::CommonCode;
namespace std {
template<>
struct hash<klotski::CommonCode> {
std::size_t operator()(const klotski::CommonCode &c) const {
return std::hash<uint64_t>()(c.unwrap());
}
};
template<>
struct equal_to<klotski::CommonCode> {
bool operator()(const klotski::CommonCode &c1, const klotski::CommonCode &c2) const {
return c1.unwrap() == c2.unwrap();
}
};
}
namespace klotski { namespace klotski {
bool CommonCode::operator==(const CommonCode &common_code) const noexcept {
return this->code == common_code.code;
}
bool CommonCode::operator!=(const CommonCode &common_code) const noexcept { using Common::range_reverse;
return this->code != common_code.code;
}
std::ostream& operator<<(std::ostream &out, const CommonCode &self) {
char str[10];
sprintf(str, "%09lX", self.code);
out << str;
return out;
}
}
namespace klotski {
bool CommonCode::valid() const noexcept { bool CommonCode::valid() const noexcept {
return CommonCode::check(code); return CommonCode::check(code_);
} }
CommonCode CommonCode::create(uint64_t common_code) { CommonCode CommonCode::create(uint64_t common_code) {
@ -47,7 +15,7 @@ namespace klotski {
CommonCode CommonCode::unsafe_create(uint64_t common_code) noexcept { // create without check CommonCode CommonCode::unsafe_create(uint64_t common_code) noexcept { // create without check
auto tmp = CommonCode(); // init directly auto tmp = CommonCode(); // init directly
tmp.code = common_code; tmp.code_ = common_code;
return tmp; return tmp;
} }
@ -55,36 +23,43 @@ namespace klotski {
if (!CommonCode::check(common_code)) { // check input common code if (!CommonCode::check(common_code)) { // check input common code
throw klotski::CommonCodeException("common code invalid"); throw klotski::CommonCodeException("common code invalid");
} }
code = common_code; code_ = common_code;
} }
std::ostream& operator<<(std::ostream &out, const CommonCode &self) {
char str[10];
sprintf(str, "%09lX", self.code_);
out << str;
return out;
} }
bool CommonCode::check(uint64_t common_code) noexcept { // whether common code is valid bool CommonCode::check(uint64_t common_code) noexcept { // whether common code is valid
/// M_1x1 M_1x2 M_2x1 M_2x2 /// M_1x1 | M_1x2 | M_2x1 | M_2x2
/// 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 /// 1 0 0 0 | 1 1 0 0 | 1 0 0 0 | 1 1 0 0
/// 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 /// 0 0 0 0 | 0 0 0 0 | 1 0 0 0 | 1 1 0 0
/// ... ... ... ... /// ... | ... | ... | ...
constexpr uint32_t M_1x1 = 0b1; constexpr uint32_t M_1x1 = 0b1;
constexpr uint32_t M_1x2 = 0b11; constexpr uint32_t M_1x2 = 0b11;
constexpr uint32_t M_2x1 = 0b10001; constexpr uint32_t M_2x1 = 0b10001;
constexpr uint32_t M_2x2 = 0b110011; constexpr uint32_t M_2x2 = 0b110011;
/// 2x2 address check (high 32-bits) /// 2x2 address check (high 32-bit)
uint32_t head = common_code >> 32; uint32_t head = common_code >> 32;
if (head >= 16 || (head & 0b11) == 0b11) { // check 2x2 block address if (head >= 16 || (head & 0b11) == 0b11) { // check 2x2 block address
return false; // invalid common code return false; // invalid common code
} }
/// check range status (low 32-bits) /// check range status (low 32-bit)
int space_num = 0; int space_num = 0;
uint32_t mask = M_2x2 << head; // fill 2x2 block uint32_t mask = M_2x2 << head; // fill 2x2 block
auto range = Common::range_reverse((uint32_t)common_code); auto range = range_reverse((uint32_t)common_code); // extract range
for (int addr = 0;; range >>= 2) { // traverse every 2-bits
for (int addr = 0;; range >>= 2) { // traverse every 2-bit
while ((mask >> addr) & 0b1) { while ((mask >> addr) & 0b1) {
++addr; // search next unfilled block ++addr; // search next unfilled block
} }
if (addr >= 20) { if (addr >= 20) {
return !range && space_num > 1; // empty range and >= 2 space return !range && space_num > 1; // range is empty and space num >= 2
} }
switch (range & 0b11) { switch (range & 0b11) {
case 0b00: /// space case 0b00: /// space
@ -109,3 +84,5 @@ bool CommonCode::check(uint64_t common_code) noexcept { // whether common code i
} }
} }
} }
} // namespace klotski

40
src/klotski_core/common_code/common_code.h
View File

@ -1,11 +1,11 @@
#pragma once #pragma once
/// CommonCode is a generic klotski encoding that records an valid case using /// CommonCode is a generic klotski encoding that records an valid case using
/// 36-bits lengths, and stored in a `uint64_t`. /// 36-bit lengths, and stored in a `uint64_t`.
/// Since there is only one `2x2` block, it is encoded separately. Its upper /// Since there is only one `2x2` block, it is encoded separately. Its upper
/// left corner is called `head`, it has 12 possible positions and is encoded /// left corner is called `head`, it has 12 possible positions and is encoded
/// using 4-bits length (0 ~ 15). /// using 4-bit length (0 ~ 15).
/// ///
/// 00 01 02 03 /// 00 01 02 03
/// 04 05 06 07 00 01 02 /// 04 05 06 07 00 01 02
@ -14,22 +14,22 @@
/// 16 17 18 19 12 13 14 /// 16 17 18 19 12 13 14
/// Treat spaces as special blocks, there can be four kinds of blocks in total, /// Treat spaces as special blocks, there can be four kinds of blocks in total,
/// namely `space`, `1x2`, `2x1`, `1x1`. Each of them is represented by 2-bits, /// namely `space`, `1x2`, `2x1`, `1x1`. Each of them is represented by 2-bit,
/// which are `00` `01` `10` `11`. Arrange them according to their position and /// which are `00` `01` `10` `11`. Arrange them according to their position and
/// size, and we can get a binary sequence. /// size, and we can get a binary sequence.
/// 2x2 -> # # | 2x1 -> # | 1x2 -> # # | 1x1 -> # /// 2x2 -> # # | 2x1 -> # | 1x2 -> # # | 1x1 -> #
/// # # | # | | /// # # | # | |
/// This sequence can have up to 16 blocks, aka 32-bits in length. Therefore, in /// This sequence can have up to 16 blocks, aka 32-bit in length. Therefore, in
/// order to be compatible with all cases, the length of this part of the code /// order to be compatible with all cases, the length of this part of the code
/// is set to 32-bits. In addition, for the convenience of reading, it is /// is set to 32-bit. In addition, for the convenience of reading, it is stipulated
/// stipulated that the sequence starts from the high bit, and the remaining bits /// that the sequence starts from the high bit, and the remaining bits should be
/// should be filled with `0`. /// filled with `0`.
/// Putting the content of the `head` in the upper 4-bits, and the lower 32-bits /// Putting the content of the `head` in the upper 4-bit, and the lower 32-bit
/// to store the sequence content, a 36-bits length code can be obtained, which /// to store the sequence content, a 36-bit length code can be obtained, which
/// corresponds to any valid layout one-to-one. When CommonCode is converted into /// corresponds to any valid layout one-to-one. When CommonCode is converted into
/// a string, just directly export the hexadecimal data, and get a 9-bits string /// a string, just directly export the hexadecimal data, and get a 9-bit string
/// encoding. Characters are not case-sensitive, but it is recommended to use /// encoding. Characters are not case-sensitive, but it is recommended to use
/// uppercase letters. In addition, the last `0` of the string is allowed to be /// uppercase letters. In addition, the last `0` of the string is allowed to be
/// omitted, and it can be completed to 9 digits when decoding, but note that if /// omitted, and it can be completed to 9 digits when decoding, but note that if
@ -59,7 +59,8 @@
#include "short_code.h" #include "short_code.h"
namespace klotski { namespace klotski {
class RawCode; // import for convert interface
class RawCode;
class ShortCode; class ShortCode;
class CommonCodeException : public std::runtime_error { class CommonCodeException : public std::runtime_error {
@ -70,28 +71,26 @@ namespace klotski {
}; };
class CommonCode { class CommonCode {
uint64_t code; uint64_t code_;
CommonCode() = default; // unsafe initialize CommonCode() = default; // unsafe initialize
static inline uint64_t string_decode(const std::string &common_code); static inline uint64_t string_decode(const std::string &common_code);
static inline std::string string_encode(uint64_t common_code, bool shorten) noexcept; static inline std::string string_encode(uint64_t common_code, bool shorten) noexcept;
public: public:
/// CommonCode validity check /// Validity check
bool valid() const noexcept; bool valid() const noexcept;
static bool check(uint64_t common_code) noexcept; static bool check(uint64_t common_code) noexcept;
/// Operators of CommonCode /// Operators of CommonCode
bool operator==(const CommonCode &common_code) const noexcept; constexpr explicit operator uint64_t() const noexcept { return code_; }
bool operator!=(const CommonCode &common_code) const noexcept;
constexpr explicit operator uint64_t() const noexcept { return code; }
friend std::ostream& operator<<(std::ostream &out, const CommonCode &self); friend std::ostream& operator<<(std::ostream &out, const CommonCode &self);
/// Export functions /// Export functions
RawCode to_raw_code() const noexcept; RawCode to_raw_code() const noexcept;
ShortCode to_short_code() const noexcept; ShortCode to_short_code() const noexcept;
std::string to_string(bool shorten = false) const; std::string to_string(bool shorten = false) const noexcept;
constexpr uint64_t unwrap() const noexcept { return code; } constexpr uint64_t unwrap() const noexcept { return code_; }
/// CommonCode constructors /// CommonCode constructors
explicit CommonCode(uint64_t common_code); explicit CommonCode(uint64_t common_code);
@ -124,4 +123,7 @@ namespace klotski {
inline bool operator!=(uint64_t c1, const CommonCode &c2) noexcept { return c1 != c2.unwrap(); } inline bool operator!=(uint64_t c1, const CommonCode &c2) noexcept { return c1 != c2.unwrap(); }
inline bool operator==(const CommonCode &c1, uint64_t c2) noexcept { return c1.unwrap() == c2; } inline bool operator==(const CommonCode &c1, uint64_t c2) noexcept { return c1.unwrap() == c2; }
inline bool operator!=(const CommonCode &c1, uint64_t c2) noexcept { return c1.unwrap() != c2; } inline bool operator!=(const CommonCode &c1, uint64_t c2) noexcept { return c1.unwrap() != c2; }
} inline bool operator==(const CommonCode &c1, const CommonCode &c2) noexcept { return c1.unwrap() == c2.unwrap(); }
inline bool operator!=(const CommonCode &c1, const CommonCode &c2) noexcept { return c1.unwrap() != c2.unwrap(); }
} // namespace klotski

8
src/klotski_core/common_code/convert.cc
View File

@ -31,21 +31,21 @@ CommonCode CommonCode::from_raw_code(const RawCode &raw_code) noexcept {
} }
CommonCode::CommonCode(RawCode &&raw_code) noexcept { CommonCode::CommonCode(RawCode &&raw_code) noexcept {
code = raw_code.to_common_code().code; // convert from raw code code_ = raw_code.to_common_code().code_; // convert from raw code
} }
CommonCode::CommonCode(const RawCode &raw_code) noexcept { CommonCode::CommonCode(const RawCode &raw_code) noexcept {
code = raw_code.to_common_code().code; // convert from raw code code_ = raw_code.to_common_code().code_; // convert from raw code
} }
/// ------------------------- ShortCode to CommonCode ------------------------- /// ------------------------- ShortCode to CommonCode -------------------------
CommonCode::CommonCode(ShortCode &&short_code) noexcept { CommonCode::CommonCode(ShortCode &&short_code) noexcept {
code = short_code.to_common_code().code; // convert from short code code_ = short_code.to_common_code().code_; // convert from short code
} }
CommonCode::CommonCode(const ShortCode &short_code) noexcept { CommonCode::CommonCode(const ShortCode &short_code) noexcept {
code = short_code.to_common_code().code; // convert from short code code_ = short_code.to_common_code().code_; // convert from short code
} }
CommonCode CommonCode::from_short_code(uint32_t short_code) { CommonCode CommonCode::from_short_code(uint32_t short_code) {

16
src/klotski_core/common_code/serialize.cc
View File

@ -5,18 +5,18 @@ using klotski::CommonCodeException;
/// -------------------------- CommonCode to String --------------------------- /// -------------------------- CommonCode to String ---------------------------
std::string CommonCode::to_string(bool shorten) const { std::string CommonCode::to_string(bool shorten) const noexcept {
return string_encode(code, shorten); return string_encode(code_, shorten);
} }
/// -------------------------- String to CommonCode --------------------------- /// -------------------------- String to CommonCode ---------------------------
CommonCode::CommonCode(std::string &&common_code) { CommonCode::CommonCode(std::string &&common_code) {
code = string_decode(common_code); // load from string code_ = string_decode(common_code); // load from string
} }
CommonCode::CommonCode(const std::string &common_code) { CommonCode::CommonCode(const std::string &common_code) {
code = string_decode(common_code); // load from string code_ = string_decode(common_code); // load from string
} }
CommonCode CommonCode::from_string(std::string &&common_code) { CommonCode CommonCode::from_string(std::string &&common_code) {
@ -44,11 +44,11 @@ inline uint8_t last_zero_num(uint32_t bin) { // get last zero number
return binary_count(bin >> 1); return binary_count(bin >> 1);
} }
std::string CommonCode::string_encode(uint64_t common_code, bool shorten) noexcept { // convert uint64_t code to string std::string CommonCode::string_encode(uint64_t common_code, bool shorten) noexcept { // convert from uint64_t
char result[10]; // max length 9-bits char result[10]; // max length 9-bit
sprintf(result, "%09lX", common_code); sprintf(result, "%09lX", common_code);
if (shorten) { // remove `0` after common code if (shorten) { // remove `0` after common code
if ((uint32_t)common_code == 0x00'00'00'00) { // low 32-bits are zero if ((uint32_t)common_code == 0x00'00'00'00) { // low 32-bit are zero
result[1] = '\0'; // only keep first character result[1] = '\0'; // only keep first character
return result; return result;
} }
@ -57,7 +57,7 @@ std::string CommonCode::string_encode(uint64_t common_code, bool shorten) noexce
return result; // char* -> std::string return result; // char* -> std::string
} }
uint64_t CommonCode::string_decode(const std::string &common_code) { // convert from 1 ~ 9 bits string uint64_t CommonCode::string_decode(const std::string &common_code) { // convert from (1 ~ 9)-bit string
/// check string length /// check string length
if (common_code.length() > 9 || common_code.empty()) { // check string length if (common_code.length() > 9 || common_code.empty()) { // check string length
throw CommonCodeException("common code should length 1 ~ 9"); throw CommonCodeException("common code should length 1 ~ 9");

4
test/codec/short_code.cc
View File

@ -34,7 +34,7 @@ TEST(ShortCode, speed_up) {
std::thread threads[4]; std::thread threads[4];
/// speed up to normal mode /// speed up to normal mode
EXPECT_EQ(BasicRanges::status(), BasicRanges::NO_INIT); EXPECT_EQ(BasicRanges::status(), BasicRanges::NOT_INIT);
for (auto &t : threads) { for (auto &t : threads) {
t = std::thread(ShortCode::speed_up, ShortCode::NORMAL); t = std::thread(ShortCode::speed_up, ShortCode::NORMAL);
} }
@ -46,7 +46,7 @@ TEST(ShortCode, speed_up) {
EXPECT_EQ(BasicRanges::status(), BasicRanges::AVAILABLE); EXPECT_EQ(BasicRanges::status(), BasicRanges::AVAILABLE);
/// speed up to fast mode /// speed up to fast mode
EXPECT_EQ(AllCases::status(), AllCases::NO_INIT); EXPECT_EQ(AllCases::status(), AllCases::NOT_INIT);
for (auto &t : threads) { for (auto &t : threads) {
t = std::thread(ShortCode::speed_up, ShortCode::FAST); t = std::thread(ShortCode::speed_up, ShortCode::FAST);
} }

Write Preview
Loading…
Cancel
Save