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
Split 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_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 {
bool CommonCode::operator==(const CommonCode &common_code) const noexcept {
return this->code == common_code.code;
}
bool CommonCode::operator!=(const CommonCode &common_code) const noexcept {
return this->code != common_code.code;
}
using Common::range_reverse;
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 {
return CommonCode::check(code);
return CommonCode::check(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
auto tmp = CommonCode(); // init directly
tmp.code = common_code;
tmp.code_ = common_code;
return tmp;
}
@ -55,36 +23,43 @@ namespace klotski {
if (!CommonCode::check(common_code)) { // check input common code
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
/// M_1x1 M_1x2 M_2x1 M_2x2
/// 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
/// ... ... ... ...
/// M_1x1 | M_1x2 | M_2x1 | M_2x2
/// 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
/// ... | ... | ... | ...
constexpr uint32_t M_1x1 = 0b1;
constexpr uint32_t M_1x2 = 0b11;
constexpr uint32_t M_2x1 = 0b10001;
constexpr uint32_t M_2x2 = 0b110011;
/// 2x2 address check (high 32-bits)
/// 2x2 address check (high 32-bit)
uint32_t head = common_code >> 32;
if (head >= 16 || (head & 0b11) == 0b11) { // check 2x2 block address
return false; // invalid common code
}
/// check range status (low 32-bits)
/// check range status (low 32-bit)
int space_num = 0;
uint32_t mask = M_2x2 << head; // fill 2x2 block
auto range = Common::range_reverse((uint32_t)common_code);
for (int addr = 0;; range >>= 2) { // traverse every 2-bits
auto range = range_reverse((uint32_t)common_code); // extract range
for (int addr = 0;; range >>= 2) { // traverse every 2-bit
while ((mask >> addr) & 0b1) {
++addr; // search next unfilled block
}
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) {
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
/// 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
/// 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
/// 04 05 06 07 00 01 02
@ -14,22 +14,22 @@
/// 16 17 18 19 12 13 14
/// 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
/// size, and we can get a binary sequence.
/// 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
/// is set to 32-bits. In addition, for the convenience of reading, it is
/// stipulated that the sequence starts from the high bit, and the remaining bits
/// should be filled with `0`.
/// is set to 32-bit. In addition, for the convenience of reading, it is stipulated
/// that the sequence starts from the high bit, and the remaining bits should be
/// filled with `0`.
/// Putting the content of the `head` in the upper 4-bits, and the lower 32-bits
/// to store the sequence content, a 36-bits length code can be obtained, which
/// Putting the content of the `head` in the upper 4-bit, and the lower 32-bit
/// 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
/// 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
/// 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
@ -59,7 +59,8 @@
#include "short_code.h"
namespace klotski {
class RawCode; // import for convert interface
class RawCode;
class ShortCode;
class CommonCodeException : public std::runtime_error {
@ -70,28 +71,26 @@ namespace klotski {
};
class CommonCode {
uint64_t code;
uint64_t code_;
CommonCode() = default; // unsafe initialize
static inline uint64_t string_decode(const std::string &common_code);
static inline std::string string_encode(uint64_t common_code, bool shorten) noexcept;
public:
/// CommonCode validity check
/// Validity check
bool valid() const noexcept;
static bool check(uint64_t common_code) noexcept;
/// Operators of CommonCode
bool operator==(const CommonCode &common_code) const noexcept;
bool operator!=(const CommonCode &common_code) const noexcept;
constexpr explicit operator uint64_t() const noexcept { return code; }
constexpr explicit operator uint64_t() const noexcept { return code_; }
friend std::ostream& operator<<(std::ostream &out, const CommonCode &self);
/// Export functions
RawCode to_raw_code() const noexcept;
ShortCode to_short_code() const noexcept;
std::string to_string(bool shorten = false) const;
constexpr uint64_t unwrap() const noexcept { return code; }
std::string to_string(bool shorten = false) const noexcept;
constexpr uint64_t unwrap() const noexcept { return code_; }
/// CommonCode constructors
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==(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 {
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 {
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 -------------------------
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 {
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) {

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

@ -5,18 +5,18 @@ using klotski::CommonCodeException;
/// -------------------------- CommonCode to String ---------------------------
std::string CommonCode::to_string(bool shorten) const {
return string_encode(code, shorten);
std::string CommonCode::to_string(bool shorten) const noexcept {
return string_encode(code_, shorten);
}
/// -------------------------- String to CommonCode ---------------------------
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) {
code = string_decode(common_code); // load from string
code_ = string_decode(common_code); // load from string
}
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);
}
std::string CommonCode::string_encode(uint64_t common_code, bool shorten) noexcept { // convert uint64_t code to string
char result[10]; // max length 9-bits
std::string CommonCode::string_encode(uint64_t common_code, bool shorten) noexcept { // convert from uint64_t
char result[10]; // max length 9-bit
sprintf(result, "%09lX", 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
return result;
}
@ -57,7 +57,7 @@ std::string CommonCode::string_encode(uint64_t common_code, bool shorten) noexce
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
if (common_code.length() > 9 || common_code.empty()) { // check string length
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];
/// speed up to normal mode
EXPECT_EQ(BasicRanges::status(), BasicRanges::NO_INIT);
EXPECT_EQ(BasicRanges::status(), BasicRanges::NOT_INIT);
for (auto &t : threads) {
t = std::thread(ShortCode::speed_up, ShortCode::NORMAL);
}
@ -46,7 +46,7 @@ TEST(ShortCode, speed_up) {
EXPECT_EQ(BasicRanges::status(), BasicRanges::AVAILABLE);
/// speed up to fast mode
EXPECT_EQ(AllCases::status(), AllCases::NO_INIT);
EXPECT_EQ(AllCases::status(), AllCases::NOT_INIT);
for (auto &t : threads) {
t = std::thread(ShortCode::speed_up, ShortCode::FAST);
}

Write Preview
Loading…
Cancel
Save