Skip to content

Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences

Refactor number_t to use a single int64_t as store.

kishorenc7b342c7c7368
diff --git a/include/number.h b/include/number.h
index 3fea6ca5..5367815b 100644
--- a/include/number.h
+++ b/include/number.h
@@ -4,73 +4,65 @@
struct number_t {
bool is_float;
- union {
- float floatval;
- int64_t intval;
- };
+ int64_t intval;
number_t(): is_float(false), intval(0) {
}
- number_t(bool is_float, float floatval): is_float(is_float), floatval(floatval) {
+ explicit number_t(float val): is_float(true), intval(*reinterpret_cast<int64_t*>(&val)) {
}
- number_t(bool is_float, int64_t intval): is_float(is_float), intval(intval) {
+ explicit number_t(int64_t val): is_float(false), intval(val) {
}
-
- number_t(float val): is_float(true), floatval(val) {
-
- }
-
- number_t(int64_t val): is_float(false), intval(val) {
-
- }
-
- inline void operator = (const float & val) {
- floatval = val;
+ inline number_t& operator = (const float val) {
+ intval = *reinterpret_cast<const int64_t*>(&val);
is_float = true;
+ return *this;
}
- inline void operator = (const int64_t & val) {
+ inline number_t& operator = (const int64_t & val) {
intval = val;
is_float = false;
+ return *this;
}
inline bool operator == (const number_t & rhs) const {
if(is_float) {
- return floatval == rhs.floatval;
+ return (*reinterpret_cast<const float*>(&intval)) == (*reinterpret_cast<const float*>(&rhs.intval));
}
return intval == rhs.intval;
}
inline bool operator < (const number_t & rhs) const {
if(is_float) {
- return floatval < rhs.floatval;
+ return (*reinterpret_cast<const float*>(&intval)) < (*reinterpret_cast<const float*>(&rhs.intval));
}
return intval < rhs.intval;
}
inline bool operator > (const number_t & rhs) const {
if(is_float) {
- return floatval > rhs.floatval;
+ return (*reinterpret_cast<const float*>(&intval)) > (*reinterpret_cast<const float*>(&rhs.intval));
}
return intval > rhs.intval;
}
inline number_t operator * (const number_t & rhs) const {
if(is_float) {
- return number_t((float)(floatval * rhs.floatval));
+ return number_t((*reinterpret_cast<const float*>(&intval)) * (*reinterpret_cast<const float*>(&rhs.intval)));
}
- return number_t((int64_t)(intval * rhs.intval));
+ return number_t(intval * rhs.intval);
}
inline number_t operator-() {
if(is_float) {
+ float floatval = *reinterpret_cast<float*>(&intval);
floatval = -floatval;
+ intval = *reinterpret_cast<int64_t *>(&floatval);
} else {
intval = -intval;
}
diff --git a/src/index.cpp b/src/index.cpp
index dafebf14..d1abe316 100644
--- a/src/index.cpp
+++ b/src/index.cpp
@@ -1442,7 +1442,7 @@ void Index::score_results(const std::vector<sort_by> & sort_fields, const uint16
// initialize primary_rank_factor
field sort_field = sort_schema.at(sort_fields[0].name);
- if(sort_field.is_single_integer()) {
+ if(sort_field.is_single_integer() || sort_field.is_single_bool()) {
primary_rank_factor = ((int64_t) 1);
} else {
primary_rank_factor = ((float) 1);
@@ -1458,7 +1458,7 @@ void Index::score_results(const std::vector<sort_by> & sort_fields, const uint16
// initialize secondary_rank_factor
field sort_field = sort_schema.at(sort_fields[1].name);
- if(sort_field.is_single_integer()) {
+ if(sort_field.is_single_integer() || sort_field.is_single_bool()) {
secondary_rank_factor = ((int64_t) 1);
} else {
secondary_rank_factor = ((float) 1);
@@ -1509,17 +1509,17 @@ void Index::score_results(const std::vector<sort_by> & sort_fields, const uint16
}
const int64_t default_score = 0;
- number_t primary_rank_score = default_score;
- number_t secondary_rank_score = default_score;
+ number_t primary_rank_score = number_t(default_score);
+ number_t secondary_rank_score = number_t(default_score);
if(primary_rank_scores) {
auto it = primary_rank_scores->find(seq_id);
- primary_rank_score = (it == primary_rank_scores->end()) ? default_score : it->second;
+ primary_rank_score = (it == primary_rank_scores->end()) ? number_t(default_score) : number_t(it->second);
}
if(secondary_rank_scores) {
auto it = secondary_rank_scores->find(seq_id);
- secondary_rank_score = (it == secondary_rank_scores->end()) ? default_score : it->second;
+ secondary_rank_score = (it == secondary_rank_scores->end()) ? number_t(default_score) : number_t(it->second);
}
const number_t & primary_rank_value = primary_rank_score * primary_rank_factor;
diff --git a/test/topster_test.cpp b/test/topster_test.cpp
index f034bcbf..5704e8fb 100644
--- a/test/topster_test.cpp
+++ b/test/topster_test.cpp
@@ -30,8 +30,8 @@ TEST(TopsterTest, MaxIntValues) {
};
for(int i = 0; i < 14; i++) {
- topster.add(data[i].key, data[i].field_id, data[i].query_index, data[i].match_score, data[i].primary_attr,
- data[i].secondary_attr);
+ topster.add(data[i].key, data[i].field_id, data[i].query_index, data[i].match_score,
+ number_t(data[i].primary_attr), number_t(data[i].secondary_attr));
}
topster.sort();
@@ -77,8 +77,8 @@ TEST(TopsterTest, MaxFloatValues) {
};
for(int i = 0; i < 12; i++) {
- topster.add(data[i].key, data[i].field_id, data[i].query_index, data[i].match_score, data[i].primary_attr,
- data[i].secondary_attr);
+ topster.add(data[i].key, data[i].field_id, data[i].query_index, data[i].match_score,
+ number_t(data[i].primary_attr), number_t(data[i].secondary_attr));
}
topster.sort();