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

feat: locate group info

legacy
Dnomd343 2 years ago
parent
f977925fa4
commit
91cb4df89c
6 changed files with 89 additions and 93 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. 41
      src/klotski_core/ffi/tmain.cc
  2. 30
      src/klotski_core/group/basic_id.cc
  3. 12
      src/klotski_core/group/build_cases.cc
  4. 34
      src/klotski_core/group/group.h
  5. 49
      src/klotski_core/group/group_info.cc
  6. 16
      src/klotski_core/group/seeds.cc

41
src/klotski_core/ffi/tmain.cc
View File

@ -19,8 +19,9 @@
#include "group.h"
using klotski::Group;
using klotski::TypeId;
using klotski::AllCases;
using klotski::GroupCase;
using klotski::GroupType;
using klotski::RawCode;
using klotski::ShortCode;
@ -34,40 +35,16 @@ using klotski::TYPE_ID_LIMIT;
void tmain() {
// printf("tmain start\n");
auto start = clock();
// auto start = clock();
// Group::build_group(123, 233);
// auto ret = GroupCase::encode(CommonCode(0x1A9BF0C00));
auto ret = GroupCase::encode(CommonCode(0x4FEA13400));
Group::build_groups(TypeId(123));
std::cout << "type id: " << ret.type_id << std::endl;
std::cout << "group id: " << ret.group_id << std::endl;
std::cout << "group index: " << ret.group_index << std::endl;
std::cerr << (clock() - start) * 1000 / CLOCKS_PER_SEC << "ms" << std::endl;
// auto seed = Group::group_seed(123, 233);
// std::cout << seed << std::endl;
// Group::group_info(CommonCode(0x1A9BF0C00));
// std::vector<uint32_t> group_num;
// group_num.reserve(TYPE_ID_LIMIT);
// for (uint32_t type_id = 0; type_id < TYPE_ID_LIMIT; ++type_id) {
// group_num.emplace_back(Group::build_groups(type_id).size());
// std::cerr << type_id << std::endl;
// }
//
// uint32_t offset = 0;
// std::vector<uint32_t> group_offset;
// group_offset.reserve(TYPE_ID_LIMIT);
// for (auto &&tmp : group_num) {
// group_offset.emplace_back(offset);
// offset += tmp;
// }
//
// for (uint32_t i = 0; i < group_offset.size(); ++i) {
// printf("%5d, ", group_offset[i]);
// if (i % 12 == 11) {
// printf("\n");
// }
// }
// std::cerr << (clock() - start) * 1000 / CLOCKS_PER_SEC << "ms" << std::endl;
// printf("tmain exit\n");
}

30
src/klotski_core/group/basic_id.cc
View File

@ -8,24 +8,24 @@ namespace klotski {
using Common::range_reverse;
/// ----------------------------------------- Type ID -----------------------------------------
/// --------------------------------------- Group Type ----------------------------------------
TypeId::TypeId(uint32_t type_id) {
GroupType::GroupType(uint32_t type_id) {
if (type_id >= TYPE_ID_LIMIT) { // invalid type id
throw std::invalid_argument("type id overflow");
}
type_id_ = type_id;
}
TypeId::TypeId(const RawCode &raw_code) noexcept {
GroupType::GroupType(const RawCode &raw_code) noexcept {
type_id_ = type_id(block_num(raw_code));
}
TypeId::TypeId(const CommonCode &common_code) noexcept {
GroupType::GroupType(const CommonCode &common_code) noexcept {
type_id_ = type_id(block_num(common_code));
}
uint32_t TypeId::type_id(block_num_t &&block_num) noexcept { // block_num_t -> type_id
uint32_t GroupType::type_id(block_num_t &&block_num) noexcept { // block_num_t -> type_id
/// flag -> ... 0000 0xxx 0xxx xxxx
/// n_x2x n_2x1 n_1x1
auto n_x2x = block_num.n_1x2 + block_num.n_2x1;
@ -35,7 +35,7 @@ uint32_t TypeId::type_id(block_num_t &&block_num) noexcept { // block_num_t -> t
/// -------------------------------------- Block Number ---------------------------------------
TypeId::block_num_t TypeId::block_num() const noexcept { // type_id -> block_num_t
GroupType::block_num_t GroupType::block_num() const noexcept { // type_id -> block_num_t
auto flag = TYPE_ID_INDEX[type_id_];
auto n_2x1 = (flag >> 4) & 0b111;
return block_num_t {
@ -45,7 +45,7 @@ TypeId::block_num_t TypeId::block_num() const noexcept { // type_id -> block_num
};
}
TypeId::block_num_t TypeId::block_num(const RawCode &raw_code) noexcept {
GroupType::block_num_t GroupType::block_num(const RawCode &raw_code) noexcept {
block_num_t result;
auto tmp = raw_code.unwrap();
for (int addr = 0; addr < 20; ++addr, tmp >>= 3) {
@ -64,7 +64,7 @@ TypeId::block_num_t TypeId::block_num(const RawCode &raw_code) noexcept {
return result;
}
TypeId::block_num_t TypeId::block_num(const CommonCode &common_code) noexcept {
GroupType::block_num_t GroupType::block_num(const CommonCode &common_code) noexcept {
block_num_t result;
auto range = range_reverse(static_cast<uint32_t>(common_code.unwrap()));
for (; range; range >>= 2) {
@ -85,26 +85,26 @@ TypeId::block_num_t TypeId::block_num(const CommonCode &common_code) noexcept {
/// ------------------------------------------ Group ------------------------------------------
Group::Group(uint32_t type_id, uint32_t group_id) : type_id_(type_id) {
Group::Group(uint32_t type_id, uint32_t group_id) : type_(type_id) {
if (group_id >= TYPE_ID_GROUP_NUM[type_id]) {
throw std::invalid_argument("group id overflow");
}
group_id_ = group_id;
}
Group::Group(const TypeId &type_id, uint32_t group_id) : type_id_(type_id) {
if (group_id >= TYPE_ID_GROUP_NUM[type_id.unwrap()]) {
Group::Group(const GroupType &group_type, uint32_t group_id) : type_(group_type) {
if (group_id >= TYPE_ID_GROUP_NUM[group_type.unwrap()]) {
throw std::invalid_argument("group id overflow");
}
group_id_ = group_id;
}
Group::Group(const RawCode &raw_code) noexcept : type_id_(TypeId(raw_code)) {
group_id_ = group_id(type_id_.unwrap(), Group::seed(raw_code));
Group::Group(const RawCode &raw_code) noexcept : type_(GroupType(raw_code)) {
group_id_ = group_id(type_, Group::seed(raw_code));
}
Group::Group(const CommonCode &common_code) noexcept : type_id_(TypeId(common_code)) {
group_id_ = group_id(type_id_.unwrap(), Group::seed(common_code));
Group::Group(const CommonCode &common_code) noexcept : type_(GroupType(common_code)) {
group_id_ = group_id(type_, Group::seed(common_code));
}
} // namespace klotski

12
src/klotski_core/group/build_cases.cc
View File

@ -12,9 +12,9 @@ namespace klotski {
using Common::check_range;
using Common::range_reverse;
/// ----------------------------------------- Type ID -----------------------------------------
/// --------------------------------------- Group Type ----------------------------------------
std::vector<CommonCode> TypeId::cases() const noexcept {
std::vector<CommonCode> GroupType::cases() const noexcept {
std::vector<uint32_t> ranges; // basic ranges of type_id
ranges.reserve(TYPE_ID_SIZE[type_id_]); // over-allocation
@ -48,8 +48,8 @@ std::vector<CommonCode> TypeId::cases() const noexcept {
return all_cases;
}
std::vector<std::vector<CommonCode>> TypeId::groups() const noexcept {
auto all_cases = TypeId::cases();
std::vector<std::vector<CommonCode>> GroupType::groups() const noexcept {
auto all_cases = GroupType::cases();
std::vector<std::vector<CommonCode>> groups;
auto min = std::min_element(all_cases.begin(), all_cases.end()); // search min CommonCode
@ -91,7 +91,7 @@ uint32_t Group::size(const CommonCode &common_code) noexcept {
uint32_t Group::size(const RawCode &raw_code) noexcept {
std::queue<uint64_t> cache({raw_code.unwrap()});
absl::flat_hash_map<uint64_t, uint64_t> cases; // <code, mask>
cases.reserve(TypeId::group_max_size(raw_code));
cases.reserve(GroupType::max_size(raw_code));
cases.emplace(raw_code.unwrap(), 0b0); // without mask
auto core = Core(
@ -125,7 +125,7 @@ std::vector<RawCode> Group::cases(const CommonCode &common_code) noexcept {
std::vector<RawCode> Group::cases(const RawCode &raw_code) noexcept {
std::queue<uint64_t> cache({raw_code.unwrap()});
absl::flat_hash_map<uint64_t, uint64_t> cases; // <code, mask>
cases.reserve(TypeId::group_max_size(raw_code));
cases.reserve(GroupType::max_size(raw_code));
cases.emplace(raw_code.unwrap(), 0b0); // without mask
auto core = Core(

34
src/klotski_core/group/group.h
View File

@ -9,9 +9,9 @@ namespace klotski {
const uint32_t TYPE_ID_LIMIT = 203;
const uint32_t ALL_GROUP_NUM = 25422;
/// ----------------------------------------- Type ID -----------------------------------------
/// --------------------------------------- Group Type ----------------------------------------
class TypeId {
class GroupType {
public:
/// 1. n_1x1 + (n_1x2 + n_2x1) * 2 <= 14
/// 2. (n_1x1 != 0) && (n_2x1 != 7)
@ -27,9 +27,9 @@ private:
static inline uint32_t type_id(block_num_t &&block_num) noexcept;
public:
explicit TypeId(uint32_t type_id);
explicit TypeId(const RawCode &raw_code) noexcept;
explicit TypeId(const CommonCode &common_code) noexcept;
explicit GroupType(uint32_t type_id);
explicit GroupType(const RawCode &raw_code) noexcept;
explicit GroupType(const CommonCode &common_code) noexcept;
/// Release raw type_id value.
constexpr uint32_t unwrap() const noexcept { return type_id_; }
@ -45,9 +45,9 @@ public:
static uint32_t group_num(const CommonCode &common_code) noexcept;
/// Get the max group size.
uint32_t group_max_size() const noexcept;
static uint32_t group_max_size(const RawCode &raw_code) noexcept;
static uint32_t group_max_size(const CommonCode &common_code) noexcept;
uint32_t max_size() const noexcept;
static uint32_t max_size(const RawCode &raw_code) noexcept;
static uint32_t max_size(const CommonCode &common_code) noexcept;
/// Get all seeds of the current type_id.
std::vector<CommonCode> seeds() const noexcept;
@ -62,20 +62,20 @@ public:
/// ------------------------------------------ Group ------------------------------------------
class Group {
TypeId type_id_;
GroupType type_;
uint32_t group_id_;
static uint32_t group_id(uint32_t type_id, const CommonCode &seed) noexcept;
static uint32_t group_id(GroupType group_type, CommonCode seed) noexcept;
public:
Group(uint32_t type_id, uint32_t group_id);
Group(const TypeId &type_id, uint32_t group_id);
Group(const GroupType &group_type, uint32_t group_id);
explicit Group(const RawCode &raw_code) noexcept;
explicit Group(const CommonCode &common_code) noexcept;
/// Release raw type_id / group_id value.
constexpr uint32_t unwrap() const noexcept { return group_id_; }
constexpr uint32_t type_id() const noexcept { return type_id_.unwrap(); }
constexpr uint32_t type_id() const noexcept { return type_.unwrap(); }
/// Get the size of the current group.
uint32_t size() const noexcept;
@ -96,6 +96,8 @@ public:
/// --------------------------------------- Group Case ----------------------------------------
class GroupCase {
static uint32_t group_id(GroupType group_type, CommonCode seed) noexcept;
public:
struct info_t {
uint16_t type_id;
@ -113,7 +115,7 @@ public:
/// ---------------------------------------- Operators ----------------------------------------
inline bool operator==(const TypeId &t1, const TypeId &t2) {
inline bool operator==(const GroupType &t1, const GroupType &t2) {
return t1.unwrap() == t2.unwrap();
}
@ -121,7 +123,7 @@ inline bool operator==(const Group &g1, const Group &g2) {
return g1.type_id() == g2.type_id() && g1.unwrap() == g2.unwrap();
}
inline bool operator==(const TypeId::block_num_t &b1, const TypeId::block_num_t &b2) {
inline bool operator==(const GroupType::block_num_t &b1, const GroupType::block_num_t &b2) {
return (b1.n_1x1 == b2.n_1x1) && (b1.n_1x2 == b2.n_1x2) && (b1.n_2x1 == b2.n_2x1);
}
@ -130,8 +132,8 @@ inline bool operator==(const GroupCase::info_t &i1, const GroupCase::info_t &i2)
}
inline bool operator!=(const Group &g1, const Group &g2) { return !(g1 == g2); }
inline bool operator!=(const TypeId &t1, const TypeId &t2) { return !(t1 == t2); }
inline bool operator!=(const GroupType &t1, const GroupType &t2) { return !(t1 == t2); }
inline bool operator!=(const GroupCase::info_t &i1, const GroupCase::info_t &i2) { return !(i1 == i2); }
inline bool operator!=(const TypeId::block_num_t &b1, const TypeId::block_num_t &b2) { return !(b1 == b2); }
inline bool operator!=(const GroupType::block_num_t &b1, const GroupType::block_num_t &b2) { return !(b1 == b2); }
} // namespace klotski

49
src/klotski_core/group/group_info.cc
View File

@ -1,52 +1,61 @@
#include <algorithm>
#include "group.h"
#include "type_id.h"
#include "group_seeds.h"
#include <iostream>
namespace klotski {
/// ----------------------------------------- Type ID -----------------------------------------
/// --------------------------------------- Group Type ----------------------------------------
uint32_t TypeId::group_num() const noexcept {
uint32_t GroupType::group_num() const noexcept {
return TYPE_ID_GROUP_NUM[type_id_];
}
uint32_t TypeId::group_num(const RawCode &raw_code) noexcept {
return TypeId(raw_code).group_num();
uint32_t GroupType::group_num(const RawCode &raw_code) noexcept {
return GroupType(raw_code).group_num();
}
uint32_t TypeId::group_num(const CommonCode &common_code) noexcept {
return TypeId(common_code).group_num();
uint32_t GroupType::group_num(const CommonCode &common_code) noexcept {
return GroupType(common_code).group_num();
}
uint32_t TypeId::group_max_size() const noexcept {
uint32_t GroupType::max_size() const noexcept {
return TYPE_ID_GROUP_MAX_SIZE[type_id_];
}
uint32_t TypeId::group_max_size(const RawCode &raw_code) noexcept {
return TypeId(raw_code).group_max_size();
uint32_t GroupType::max_size(const RawCode &raw_code) noexcept {
return GroupType(raw_code).max_size();
}
uint32_t TypeId::group_max_size(const CommonCode &common_code) noexcept {
return TypeId(common_code).group_max_size();
uint32_t GroupType::max_size(const CommonCode &common_code) noexcept {
return GroupType(common_code).max_size();
}
/// --------------------------------------- Group Case ----------------------------------------
GroupCase::info_t GroupCase::encode(const RawCode &raw_code) noexcept {
// TODO: function body
return {};
return encode(raw_code.to_common_code());
}
GroupCase::info_t GroupCase::encode(const CommonCode &common_code) noexcept {
// TODO: function body
return {};
auto cases = Group::cases(common_code);
std::vector<CommonCode> group(cases.begin(), cases.end());
uint32_t group_index = 0;
for (auto &&code: group) {
if (code < common_code) {
++group_index; // locate group index
}
}
GroupType type = GroupType(common_code);
auto seed = *std::min_element(group.begin(), group.end());
return {
.type_id = static_cast<uint16_t>(type.unwrap()),
.group_id = static_cast<uint16_t>(group_id(type, seed)),
.group_index = group_index,
};
}
CommonCode GroupCase::parse(const info_t &info) {

16
src/klotski_core/group/seeds.cc
View File

@ -7,13 +7,13 @@
namespace klotski {
std::vector<CommonCode> TypeId::seeds() const noexcept {
std::vector<CommonCode> GroupType::seeds() const noexcept {
auto offset = GROUP_SEEDS + TYPE_ID_OFFSET[type_id_]; // type id offset
return {offset, offset + TYPE_ID_GROUP_NUM[type_id_]};
}
CommonCode Group::seed() const noexcept { // group_id -> seed
auto offset = TYPE_ID_OFFSET[type_id_.unwrap()]; // type id offset
auto offset = TYPE_ID_OFFSET[type_.unwrap()]; // type id offset
auto index = offset + GROUP_SEEDS_INDEX[offset + group_id_];
return CommonCode::unsafe_create(GROUP_SEEDS[index]);
}
@ -28,11 +28,19 @@ CommonCode Group::seed(const CommonCode &common_code) noexcept {
return seed(common_code.to_raw_code());
}
uint32_t Group::group_id(uint32_t type_id, const CommonCode &seed) noexcept { // seed -> group_id
static inline uint32_t load_group_id(uint32_t type_id, uint64_t seed) { // seed -> group_id
auto start = GROUP_SEEDS + TYPE_ID_OFFSET[type_id];
auto end = start + TYPE_ID_GROUP_NUM[type_id];
auto index = std::lower_bound(start, end, seed.unwrap()) - GROUP_SEEDS;
auto index = std::lower_bound(start, end, seed) - GROUP_SEEDS;
return GROUP_SEEDS_INDEX_REV[index];
}
uint32_t Group::group_id(GroupType group_type, CommonCode seed) noexcept {
return load_group_id(group_type.unwrap(), seed.unwrap());
}
uint32_t GroupCase::group_id(GroupType group_type, CommonCode seed) noexcept {
return load_group_id(group_type.unwrap(), seed.unwrap());
}
} // namespace klotski

Write Preview
Loading…
Cancel
Save