fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Fixed some missing and erroneous testing logic for containers

Browse Source 
- Lots of bug-fixing for containers
 - Performance optimization for containers
This commit is contained in:
Medusa Slockbower
2025-09-17 17:13:52 -04:00
parent 80925965d4
commit a35f2a699d
15 changed files with 886 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
include/fennec/containers/bintree.h
View File

@@ -56,7 +56,6 @@ public:
using value_t = TypeT;
using alloc_t = allocator_traits<AllocT>::template rebind<node>;
static constexpr size_t npos = -1;
inline static size_t sink = npos;
friend class iterator;
friend class const_iterator;
@@ -189,7 +188,7 @@ public:
/// \param i The node id
/// \returns The parent of node `i`
constexpr size_t parent(size_t i) const {
return i >= _table.size() ? npos : _table[i].parent;
return i == npos ? npos : _table[i].parent;
}
///
@@ -205,7 +204,7 @@ public:
/// \param i The node id
/// \returns The left child of node `i`
constexpr size_t left(size_t i) const {
return i >= _table.size() ? npos : _table[i].left;
return i == npos ? npos : _table[i].left;
}
///
@@ -213,7 +212,7 @@ public:
/// \param i The node id
/// \returns The right child of node `i`
constexpr size_t right(size_t i) const {
return i >= _table.size() ? npos : _table[i].right;
return i == npos ? npos : _table[i].right;
}
///
@@ -230,11 +229,7 @@ public:
/// \param i The node id
/// \returns `true` if `i` is the right node of `parent(i)`, `false` otherwise
constexpr bool direction(size_t i) const {
size_t p = parent(i);
if (p >= _table.capacity()) {
return false;
}
return i == right(p);
return i == npos ? false : i == right(parent(i));
}
///
@@ -245,15 +240,7 @@ public:
size_t p = parent(i);
size_t l = left(p);
size_t r = right(p);
return i == l ? l : r;
}
///
/// \brief Short for "Parent Sibling," \f$O(1)\f$
/// \param i The id of the node
/// \returns The id of the parents' sibling of `i`
constexpr size_t parsib(size_t i) const {
return sibling(parent(i));
return i == l ? r : l;
}
///
@@ -305,22 +292,18 @@ public:
/// \details \f$O(1)\f$
/// \param i The node id
/// \returns `nullptr` if node `i` does not exist, otherwise, a pointer to the value of node `i`
constexpr value_t* operator[](size_t i) {
if (i >= _table.size()) {
return nullptr;
}
return _table[i] ? &*_table[i] : nullptr;
constexpr value_t& operator[](size_t i) {
assertd(i < _table.size(), "Index out of bounds.");
return _table[i].value;
}
///
/// \details Const Access, \f$O(1)\f$
/// \param i The node id
/// \returns `nullptr` if node `i` does not exist, otherwise, a pointer to the value of node `i`
constexpr const value_t* operator[](size_t i) const {
if (i >= _table.size()) {
return nullptr;
}
return _table[i] ? &*_table[i] : nullptr;
constexpr const value_t& operator[](size_t i) const {
assertd(i < _table.size(), "Index out of bounds.");
return _table[i].value;
}
/// @}
@@ -458,14 +441,16 @@ public:
size_t new_root = child(sub, not dir);
size_t new_child = child(new_root, dir);
child(sub, not dir) = new_child;
parent(new_child) = sub;
child(new_root, dir) = sub;
_child(sub, not dir) = new_child;
if (new_child != npos) {
_parent(new_child) = sub;
}
_child(new_root, dir) = sub;
parent(new_root) = sub_parent;
parent(sub) = new_root;
_parent(new_root) = sub_parent;
_parent(sub) = new_root;
if (sub_parent != npos) {
child(sub_parent, sub == right(sub_parent)) = new_root;
_child(sub_parent, sub == right(sub_parent)) = new_root;
} else {
_root = new_root;
}
@@ -516,13 +501,13 @@ public:
/// \param visit The visiting object
/// \param i The node to start at
template<typename OrderT, typename VisitorT>
constexpr void traverse(VisitorT&& visit, size_t i = root) {
constexpr void traverse(VisitorT&& visit, size_t i) {
OrderT order;
i = order(*this, i);
while (i != npos) {
uint8_t mode = traversal_control_continue;
if (_table[i].value) {
mode = visit(*_table[i].value, i);
mode = visit(_table[i].value, i);
}
if (mode == traversal_control_break) {
break;
@@ -581,7 +566,7 @@ public:
return npos;
}
size_t nxt = tree.sibling(node);
size_t nxt = tree.right(tree.parent(node));
size_t chd = tree.left(node);
nxt = node == nxt ? npos : nxt;
@@ -618,19 +603,16 @@ public:
return npos;
}
size_t prnt = tree.parent(node);
size_t next = tree.sibling(node);
next = node == next ? npos : next;
size_t parent = tree.parent(node);
size_t pright = tree.right(parent);
size_t next = tree.left_most(tree.right(node));
if (node != head) {
if (tree.left(prnt) == node) {
visit.push_back(prnt);
if (next != npos) {
visit.push_back(tree.left_most(next));
}
} else if (next != npos) {
visit.push_front(tree.left_most(next));
}
if (node != pright && parent != npos) {
visit.push_front(parent);
}
if (next != npos) {
visit.push_front(next);
}
if (not visit.empty()) {
@@ -648,9 +630,23 @@ public:
list<size_t> visit;
size_t head;
constexpr size_t successor(const bintree& tree, size_t n) {
size_t s = tree.left_most(n);
while (n == s) {
size_t r = tree.right(n);
if (r != npos) {
n = r;
s = tree.left_most(n);
} else {
break;
}
}
return s == npos ? n : s;
}
constexpr size_t operator()(const bintree& tree, size_t start) {
head = start;
return tree.left_most(start);
return this->successor(tree, start);
}
constexpr size_t operator[](const bintree& tree, size_t node, uint8_t) {
@@ -658,16 +654,15 @@ public:
return npos;
}
size_t prnt = tree.parent(node);
size_t next = tree.sibling(node);
next = node == next ? npos : next;
size_t parent = tree.parent(node);
size_t pright = tree.right(parent);
if (node != head) {
if (next != npos) {
visit.push_front(tree.left_most(next));
} else {
visit.push_front(prnt);
if (node == pright) {
if (parent != npos) {
visit.push_front(parent);
}
} else if (pright != npos) {
visit.push_front(this->successor(tree, pright));
}
if (not visit.empty()) {
@@ -677,6 +672,7 @@ public:
node = npos;
}
return node;
}
};
@@ -690,6 +686,12 @@ public:
size_t _n;
public:
constexpr iterator(bintree* tree, size_t root)
: _tree(tree)
, _order()
, _n(_order(*tree, root)) {
}
constexpr iterator(bintree* tree, size_t root, size_t node)
: _tree(tree)
, _order()
@@ -706,19 +708,19 @@ public:
}
value_t& operator*() {
return _tree[_n];
return (*_tree)[_n];
}
value_t* operator->() {
return &_tree[_n];
return &(*_tree)[_n];
}
const value_t& operator*() const {
return _tree[_n];
return (*_tree)[_n];
}
const value_t* operator->() const {
return &_tree[_n];
return &(*_tree)[_n];
}
constexpr bool operator==(const iterator& it) {
@@ -754,7 +756,8 @@ protected:
template<typename...ArgsT>
constexpr size_t _insert_left(size_t p, ArgsT&&...args) {
size_t i = p == npos ? _root : left(p);
size_t i = p >= capacity() ? npos : p;
i = i == npos ? _root : _left(i);
if (i != npos) {
_table[i].value = value_t(fennec::forward<ArgsT>(args)...);
} else {
@@ -764,6 +767,9 @@ protected:
d = depth(p) + 1;
_table[p].left = i;
}
if (_root == npos) {
_root = i;
}
fennec::construct(&_table[i], p, npos, npos, d, fennec::forward<ArgsT>(args)...);
}
return i;
@@ -771,7 +777,7 @@ protected:
template<typename...ArgsT>
constexpr size_t _insert_right(size_t p, ArgsT&&...args) {
size_t i = p == npos ? _root : right(p);
size_t i = p == npos ? _root : _right(p);
if (i != npos) {
_table[i].value = value_t(fennec::forward<ArgsT>(args)...);
if (p == npos || _root == npos) {
@@ -784,42 +790,41 @@ protected:
d = depth(p) + 1;
_table[p].right = i;
}
if (_root == npos) {
_root = i;
}
fennec::construct(&_table[i], p, npos, npos, d, fennec::forward<ArgsT>(args)...);
}
return i;
}
constexpr size_t& parent(size_t i) {
return i >= _table.size() ? sink : _table[i].parent;
constexpr size_t& _parent(size_t i) {
return _table[i].parent;
}
constexpr size_t& grandparent(size_t i) {
return parent(parent(i));
constexpr size_t& _grandparent(size_t i) {
return _parent(parent(i));
}
constexpr size_t& left(size_t i) {
return i >= _table.size() ? sink : _table[i].left;
constexpr size_t& _left(size_t i) {
return _table[i].left;
}
constexpr size_t& right(size_t i) {
return i >= _table.size() ? sink : _table[i].right;
constexpr size_t& _right(size_t i) {
return _table[i].right;
}
constexpr size_t& child(size_t i, bool dir) {
return dir ? right(i) : left(i);
constexpr size_t& _child(size_t i, bool dir) {
return dir ? _right(i) : _left(i);
}
constexpr size_t& sibling(size_t i) {
constexpr size_t& _sibling(size_t i) {
size_t p = parent(i);
size_t& l = left(p);
size_t& r = right(p);
size_t& l = _left(p);
size_t& r = _right(p);
return i == l ? l : r;
}
constexpr size_t& parsib(size_t i) {
return sibling(parent(i));
}
};
}

16
include/fennec/containers/dynarray.h
View File

@@ -156,7 +156,9 @@ public:
// This constructor should not be invokable since moving is a single object operation and will cause undefined
// behaviour when moving to multiple elements
constexpr dynarray(size_t n, TypeT&&) = delete;
constexpr dynarray(size_t n, TypeT&& val)
: dynarray(n, fennec::copy(val)) {
};
///
/// \brief Emplace Constructor
@@ -432,6 +434,18 @@ public:
}
}
///
/// \brief Resize the dynarray, invoking the copy constructor for all new elements
/// \param n The new size in elements
/// \param val The value to fill with
constexpr void resize(size_t n, const TypeT& val) {
_alloc.creallocate(n);
while (_size < n) {
emplace_back(val);
}
}
///
/// \brief Clears the contents of the dynarray, destructing all elements and releasing the allocation.
constexpr void clear() {

31
include/fennec/containers/object_pool.h
View File

@@ -48,8 +48,8 @@ struct object_pool {
// Definitions =========================================================================================================
public:
using value_t = TypeT;
using elem_t = optional<TypeT>;
using table_t = dynarray<elem_t, AllocT>;
using table_t = allocation<value_t, AllocT>;
using freed_t = list<size_t, AllocT>;
// Constructors & Destructor ===========================================================================================
@@ -119,8 +119,7 @@ public:
/// \returns a reference to the object with id `i`
constexpr value_t& operator[](size_t i) {
assert(i < capacity(), "Index out of Bounds!");
assert(_table[i], "Attempted to access Null Object.");
return *_table[i];
return _table[i];
}
///
@@ -129,8 +128,7 @@ public:
/// \returns a const-qualified reference to the object with id `i`
constexpr const value_t& operator[](size_t i) const {
assert(i < capacity(), "Index out of Bounds!");
assert(_table[i], "Attempted to access Null Object.");
return *_table[i];
return _table[i];
}
/// @}
@@ -171,17 +169,24 @@ public:
/// \brief Erase an object from the pool
/// \param i The id of the object
constexpr void erase(size_t i) {
_table[i] = nullopt;
fennec::destruct(&_table[i]);
_freed.push_back(i);
--_size;
}
///
/// \brief Clear the object pool
constexpr void clear() {
dynarray<bool> free(capacity(), false);
_size = 0;
}
/// @}
private:
dynarray<elem_t, AllocT> _table;
list<size_t> _freed;
size_t _size;
table_t _table;
freed_t _freed;
size_t _size;
size_t _next_free() {
size_t next = _size;
@@ -196,10 +201,10 @@ private:
template<typename...ArgsT>
size_t _insert(ArgsT&&...args) {
size_t i = _next_free();
if (i >= _table.size()) {
_table.emplace_back();
if (i >= _table.capacity()) {
_table.creallocate(fennec::max(_table.size() * 2, size_t(8)));
}
_table[i].emplace(fennec::forward<ArgsT>(args)...);
fennec::construct(&_table[i], fennec::forward<ArgsT>(args)...);
return i;
}
};

145
include/fennec/containers/priority_queue.h
View File

@@ -36,28 +36,155 @@
#include <fennec/lang/types.h>
#include <fennec/memory/allocator.h>
// Binary heaps are just kinda busted.
// In-array binary heaps are one of the most efficient data structures for computers
// -> Cache Locality
// -> log(n) runtime
// -> No auxiliary structures or constant runtimes
// -> Only needs an extra byte for color
//
// I tried just about every heap under the sun
// -> strict fibonacci heap, got blown out of the water by std::priority_queue
// -> fibonacci heap, got blown out of the water by std::priority_queue
// -> binomial heap, on-par with std::set, blown out of the water by std::priority_queue
//
// Then I relented and fell back to ye old binary heap
// This implementation roughly matches gcc's std::priority_queue
namespace fennec
{
template<typename ValueT, class CompareT = less<ValueT>, class AllocT = allocator<ValueT>>
struct priority_queue {
// Definitions & Constants =============================================================================================
public:
using value_t = ValueT;
using compare_t = CompareT;
using alloc_t = AllocT;
using alloc_t = allocation<value_t, AllocT>;
static constexpr size_t npos = -1;
private:
struct node {
size_t parent, child;
size_t left, right;
int degree;
value_t key;
};
constexpr size_t left(size_t n) const {
n = n * 2 + 1;
return n >= _size ? npos : n;
}
using table_t = object_pool<node>;
constexpr size_t right(size_t n) const {
n = n * 2 + 2;
return n >= _size ? npos : n;
}
constexpr size_t parent(size_t n) const {
return n == 0 ? npos : (n - 1) / 2;
}
// Constructors & Destructor ===========================================================================================
public:
table_t _table;
constexpr priority_queue()
: _size(0) {
}
constexpr ~priority_queue() {
while (_size > 0) {
--_size;
fennec::destruct(&_table[_size]);
}
}
// Properties ==========================================================================================================
constexpr size_t size() const {
return _size;
}
constexpr size_t capacity() const {
return _table.capacity();
}
constexpr bool empty() const {
return size() == 0;
}
// Access ==============================================================================================================
constexpr const value_t& front() const {
return _table[0];
}
// Modifiers ===========================================================================================================
constexpr void push(const value_t& key) {
this->_insert(key);
}
constexpr void push(value_t&& key) {
this->_insert(fennec::forward<value_t>(key));
}
template<typename...ArgsT>
constexpr void emplace(ArgsT&&...args) {
this->_insert(fennec::forward<ArgsT>(args)...);
}
constexpr void pop() {
fennec::swap(_table[0], _table[--_size]);
fennec::destruct(&_table[_size]);
_fix_erase(0);
}
// Members =============================================================================================================
private:
compare_t _compare;
alloc_t _table;
size_t _size;
// Helpers =============================================================================================================
template<typename...ArgsT>
constexpr void _insert(ArgsT&&...args) {
if (_size == _table.capacity()) {
_expand();
}
fennec::construct(&_table[_size], fennec::forward<ArgsT>(args)...);
_fix_insert(_size++);
}
constexpr void _expand() {
_table.reallocate((_table.capacity() + 1) * 2 - 1);
}
constexpr size_t _min(size_t a, size_t b) {
if (a == npos) { return b; }
if (b == npos) { return a; }
return _compare(_table[a], _table[b]) ? a : b;
}
void _fix_insert(size_t n) {
size_t p = parent(n);
while (p != npos && _compare(_table[n], _table[p])) {
fennec::swap(_table[n], _table[p]);
n = p;
p = parent(n);
}
}
void _fix_erase(size_t n) {
size_t c = _min(left(n), right(n));
while (n != npos && c != npos && _compare(_table[c], _table[n])) {
fennec::swap(_table[c], _table[n]);
n = c;
c = _min(left(n), right(n));
}
}
};
}

355
include/fennec/containers/sequence.h
View File

@@ -39,6 +39,21 @@
#include <fennec/lang/compare.h>
#include <fennec/memory/allocator.h>
// https://en.wikipedia.org/wiki/Red%E2%80%93black_tree
// https://www.geeksforgeeks.org/dsa/insertion-in-red-black-tree/
// Uncertain how I managed to do this, but this data structure has
// A 50%-100% performance increase over std::set when running Dijkstra's
//
// Guesses:
// -> I likely make some assumptions that std::set doesn't
// -> Cache locality
// -> Simplified rotation and coloring logic
//
// Some of the implementations I have seen have multiple levels
// of if statements based on directionality which causes branching.
// I use const-expressions that reduce down to cmov instructions
namespace fennec
{
@@ -97,7 +112,6 @@ protected:
using base_t::parent;
using base_t::grandparent;
using base_t::sibling;
using base_t::parsib;
using base_t::left_most;
using base_t::right_most;
@@ -224,7 +238,7 @@ public:
}
constexpr void erase(const value_t& val) {
_erase_bst(val);
_erase(find(val).index());
}
///
@@ -246,38 +260,39 @@ public:
///
/// \returns An iterator at the smallest element in the sequence
constexpr sequence::iterator begin() {
return sequence::iterator(this, _root, _root);
constexpr iterator begin() {
return sequence::iterator(this, _root);
}
///
/// \returns An iterator after the largest element in the sequence
constexpr sequence::iterator end() {
constexpr iterator end() {
return sequence::iterator(this, _root, npos);
}
class iterator : public base_t::iterator {
protected:
using base_t::iterator::_n;
using base_t::iterator::_tree;
public:
using base_t::iterator::iterator;
value_t& operator*() {
return _table[_n].value.second;
return base_t::iterator::operator*().first;
}
const value_t& operator*() const {
return _table[_n].value.second;
return base_t::iterator::operator*().first;
}
value_t* operator->() {
return &_table[_n].value.second;
return &base_t::iterator::operator*().first;
}
const value_t* operator->() const {
return &_table[_n].value.second;
return &base_t::iterator::operator*().firstf;
}
};
@@ -290,26 +305,46 @@ protected:
// Helpers =============================================================================================================
protected:
using base_t::_left;
using base_t::_right;
using base_t::_parent;
using base_t::_sibling;
using base_t::_child;
constexpr value_t& _value(size_t i) {
return i >= _table.capacity() ? value_sink : _table[i].value.first;
return _table[i].value.first;
}
constexpr const value_t& _value(size_t i) const {
return i >= _table.capacity() ? value_sink : _table[i].value.first;
return _table[i].value.first;
}
constexpr bool& _color(size_t i) {
return i >= _table.capacity() ? color_sink = false : _table[i].value.second;
return _table[i].value.second;
}
constexpr bool _color(size_t i) const {
return i >= _table.capacity() ? color_sink = false : _table[i].value.second;
constexpr bool color(size_t i) const {
return i == npos ? false : _table[i].value.second;
}
constexpr void _recolor(size_t n) {
bool c = !color(n);
if (n == _root) { // Only recolor if not the root node
_color(n) = c;
}
_color(left(n)) = !_color(left(n)) ;
_color(right(n)) = !_color(right(n));
}
// run-of-the-mill bst insert
template<typename...ArgsT>
constexpr size_t _insert_bst(ArgsT&&...args) {
value_t val(fennec::forward<ArgsT>(args)...);
if (_root == npos) {
return _root = insert_left(npos, node_t(fennec::move(val), red));
}
size_t i = _root;
size_t p = npos;
while (i != npos) {
@@ -324,10 +359,6 @@ protected:
}
}
if (_root == npos) {
return _root = insert_left(npos, node_t(fennec::move(val), red));
}
if (_compare(val, _value(p))) {
return insert_left(p, node_t(fennec::move(val), red));
} else {
@@ -335,118 +366,232 @@ protected:
}
}
constexpr void _fix_insert(size_t x) {
while (x != _root && _color(parent(x)) == red) {
if (_color(parsib(x)) == red) {
_color(parent(x)) = black;
_color(parsib(x)) = black;
_color(grandparent(x)) = red;
x = grandparent(x);
} else if (parent(x) == left(grandparent(x))) {
if (x == right(parent(x))) {
x = parent(x);
rotate_left(x);
}
_color(parent(x)) = black;
_color(grandparent(x)) = red;
rotate_right(grandparent(x));
} else {
if (x == left(parent(x))) {
x = parent(x);
rotate_right(x);
}
_color(parent(x)) = black;
_color(grandparent(x)) = red;
rotate_left(grandparent(x));
// This makes some cheats given that the structure is modified only by internal functions
// If such is the case, ONLY LL, LR, RL, and RR will show up
// Then we just need to handle splitting a 4-node
constexpr void _fix_insert(size_t n) {
size_t p = parent(n);
while (color(p) != black) {
size_t g = parent(p);
size_t u = sibling(p);
size_t d = direction(n);
size_t r = direction(p);
// Split 4 node
if (color(u) == red) {
_recolor(g);
n = p;
p = g;
continue;
}
// LR & RL case
if (d != r) {
rotate(p, r);
}
// LL & RR case
rotate(g, not r);
n = parent(n);
p = parent(n);
}
_color(_root) = black;
}
constexpr void _shift(size_t u, size_t v) {
if (parent(u) == npos) {
constexpr void _transplant(size_t u, size_t v) {
size_t p = parent(u);
if (p == npos) {
_root = v;
} else if (u == left(p)) {
_left(p) = v;
} else {
child(parent(u), direction(u)) = v;
_right(p) = v;
}
if (v != npos) {
parent(v) = parent(u);
_parent(v) = _parent(u);
}
constexpr void _swap_val(size_t a, size_t b) {
fennec::swap(_value(a), _value(b));
}
constexpr size_t _replace(size_t x) {
size_t l = left(x);
size_t r = right(x);
// Both are null
if (l == r) {
return npos;
}
if (l == npos) {
return r;
} else if (r == npos) {
return l;
} else {
return left_most(right(x));
}
}
constexpr void _erase_bst(const value_t& val) {
size_t z = find(val).index();
size_t y = z;
size_t x = npos;
bool c = _color(y);
size_t p = npos;
constexpr size_t _red_child(size_t x) {
size_t l = left(x);
size_t r = right(x);
if (left(z) == npos) {
x = right(z);
p = parent(z);
_shift(z, x);
} else if (right(z) == npos) {
x = left(z);
p = parent(z);
_shift(z, x);
} else {
y = left_most(right(z));
c = _color(y);
x = right(y);
p = (parent(y) == z) ? y : parent(y);
if (parent(y) != z) {
_shift(y, right(y));
right(y) = right(z);
parent(right(y)) = y;
}
_shift(z, y);
left(y) = left(z);
if (left(y))
parent(left(y)) = y;
_color(y) = _color(z);
if (color(l) == red) {
return l;
}
fennec::destruct(&_table[z]);
--_size;
if (c == black) {
_fix_erase(x, p);
if (color(r) == red) {
return r;
}
return npos;
}
constexpr void _fix_erase(size_t x, size_t p) {
while (x != _root && _color(x) == black) {
bool dir = direction(x);
size_t w = child(p, not dir);
// This is an implementation based on the C code in
// the wikipedia article adapted to this framework
constexpr void _fix_erase(size_t n) {
size_t p = parent(n);
size_t s, sc, sf;
bool d = n == right(p);
if (_color(w) == red) {
_color(w) = black;
_child(p, d) = npos;
goto start_balance;
do {
d = n == right(p);
start_balance:
s = child(p, !d);
sf = child(s, !d);
sc = child(s, d);
if (color(s) == red) {
// Case 3
rotate(p, d);
_color(p) = red;
w = rotate(p, dir);
}
_color(s) = black;
if (w == npos || (_color(left(w)) == black && _color(right(w)) == black)) {
_color(w) = red;
x = p;
p = parent(x);
} else {
if (_color(child(w, not dir)) == black) {
_color(child(w, dir)) = black;
_color(w) = red;
rotate(w, not dir);
w = child(p, not dir);
// Fix pointers
s = sc;
sf = child(s, !d);
sc = child(s, d);
if (color(sf) == red) {
goto case_6;
}
_color(w) = _color(p);
if (color(sc) == red) {
goto case_5;
}
// Case 4
if (color(p) == red) {
if (s != npos) {
_color(s) = red;
}
_color(p) = black;
return;
}
}
if (color(sf) == red) {
goto case_6;
}
if (color(sc) == red) {
goto case_5;
}
// Case 4
if (color(p) == red) {
if (s != npos) {
_color(s) = red;
}
_color(p) = black;
_color(child(w, not dir)) = black;
rotate(p, dir);
x = _root;
break;
return;
}
// Case 1
if (p == npos) {
return;
}
// Case 2
if (s != npos) {
_color(s) = red;
}
n = p;
} while ((p = parent(n)) != npos);
return; //
case_5:
rotate(s, !d);
_color(s) = red;
_color(sc) = black;
sf = s;
s = sc;
case_6:
rotate(p, d);
_color(s) = color(p);
_color(p) = black;
_color(sf) = black;
}
constexpr void _erase(size_t n) {
if (n == npos) {
return;
}
size_t l = left(n);
size_t r = right(n);
// 2 children
if (l != npos && r != npos) {
size_t s = left_most(r);
_swap_val(n, s);
n = s;
l = left(n);
r = right(n);
}
size_t p = parent(n);
bool d = n == right(p);
size_t c = l != npos ? l : r;
// Single child
if (c != npos) {
_parent(c) = p;
}
// Handles root cases
if (p == npos) {
_root = c;
if (c == npos) {
fennec::destruct(&_table[n]);
_freed.push_back(n);
--_size;
return;
} else {
_color(c) = black;
}
}
_color(x) = black;
// Single Child, Red, and Root cases
if (p == npos || c != npos || color(n) == red) {
if (p != npos) {
_child(p, d) = c;
}
fennec::destruct(&_table[n]);
_freed.push_back(n);
--_size;
return;
}
_fix_erase(n);
fennec::destruct(&_table[n]);
_freed.push_back(n);
--_size;
}
};

16
include/fennec/lang/integer.h
View File

@@ -51,25 +51,25 @@
#undef ULLONG_MIN
#undef ULLONG_MAX
#define CHAR_IS_SIGNED false
#define CHAR_IS_SIGNED true
#define CHAR_ROUNDS 0x0
#define CHAR_RADIX_DIG 0x8
#define CHAR_RADIX_DIG 0x7
#define CHAR_DIG 0x2
#define CHAR_DECIMAL_DIG 0x0
#define CHAR_RADIX 0x2
#define CHAR_TRAPS 0xtrue
#define CHAR_MIN 0x0
#define CHAR_MAX 0xff
#define CHAR_MIN 0x80
#define CHAR_MAX 0x7f
#define WCHAR_IS_SIGNED false
#define WCHAR_IS_SIGNED true
#define WCHAR_ROUNDS 0x0
#define WCHAR_RADIX_DIG 0x20
#define WCHAR_RADIX_DIG 0x1f
#define WCHAR_DIG 0x9
#define WCHAR_DECIMAL_DIG 0x0
#define WCHAR_RADIX 0x2
#define WCHAR_TRAPS 0xtrue
#define WCHAR_MIN 0x0
#define WCHAR_MAX 0xffffffff
#define WCHAR_MIN 0x80000000
#define WCHAR_MAX 0x7fffffff
#define SCHAR_ROUNDS 0x0
#define SCHAR_RADIX_DIG 0x7