Towel .NET Utility Library

Towel includes several advanced data structures for specialized use cases.

Trees

• Heap (IHeap<T>): A binary tree sorted vertically. Uses "sifting up" and "sifting down" algorithms. Can be implemented via HeapArray.New<T>().
• AVL Tree (IAvltree<T>): A self-balancing binary tree that uses rotations (right, left, double right, double left) to maintain balance. Use AvlTreeLinked.New<T>().
• Red-Black Tree (IRedBlackTree<T>): A self-balancing binary tree that uses different algorithms than AVL to maintain balance. Use RedBlackTreeLinked.New<T>().
• Omnitree (IOmnitreePoints<T, ...> or IOmnitreeBounds<T, ...>): A Spatial Partitioning Tree (SPT) that works in arbitrary dimensions (e.g., Octrees for 3D, Quadtrees for 2D). It divides spaces into sub-spaces. The depth is bounded by $\Omega(\ln(\text{count}))$.
• B-Tree (BTree<T>): A self-balancing tree that allows nodes to have more than two children, supporting logarithmic time for search, insertion, and deletion. This implementation uses a Pre-emptive mode for Add/Remove, requiring the Maximum Degree to be an even number. Use new BTree<int>(degree).
• Trie (ITrie<T> or ITrie<T, D>): A tree that shares partial keys to reduce memory usage. Use TrieLinkedHashLinked.New<T>().

Other Structures

• Graph (IGraph<T>): Models nodes and edges. GraphSetOmnitree stores nodes in a hashed set and edges in a 2D omnitree (quadtree). Use GraphSetOmnitree.New<int>().
• SkipList (SkipList<T, ...>): A probabilistic data structure that allows $O(\log n)$ average complexity for basic operations using multiple layers. Use SkipList.New<T>(levels).
• TreeMap (ITree<T>): General tree mapping via TreeMap.New<T>().

// Heap
IHeap<T> heap = HeapArray.New<T>();

// AVL Tree
IAvltree<T> avlTree = AvlTreeLinked.New<T>();

// Red Black Tree
IRedBlackTree<T> redBlackTree = RedBlackTreeLinked.New<T>();

// Omnitree
IOmnitreePoints<T, A1, A2, A3...> omnitreePoints = 
    new OmnitreePointsLinked<T, A1, A2, A3...>( 
        (T value, out A1 a1, out A2 a2, out A3 a3...) => { ... });

// B-Tree
BTree<int> tree = new BTree<int>(4); 

// Graph
IGraph<int> graph = GraphSetOmnitree.New<int>();

// SkipList
SkipList<int, SFunc<int, int, CompareResult>>? list = SkipList.New<int>(5);

// Trie
ITrie<T> trie = TrieLinkedHashLinked.New<T>();

Towel provides type-safe measurement types (e.g., Length<T>, Mass<T>, Speed<T>) to prevent mathematically invalid operations and automate unit conversions.

Automatic Unit Conversion

When performing operations on measurements of the same type, conversions are handled automatically based on the units used.

Angle<double> angle1 = (90d, Degrees);
Angle<double> angle2 = (.5d, Turns);
Angle<double> result1 = angle1 + angle2; // Result is 270°

Type Safety

You cannot perform operations between incompatible measurement types (e.g., adding Length<T> to Angle<T>) at compile time.

Manual Conversion and Parsing

• Index Operator: double radians = angle1[Radians];
• Static Convert: Angle<double>.Convert(7d, Radians, Degrees);
• Parsing: Speed<float>.TryParse("20.5 Meters / Seconds", out var speed);

Integration with Vectors

Measurements can be used as the generic type within Vector<T>.

Vector<Speed<float>> velocity1 = new Vector<Speed<float>>((1f, Meters / Seconds), ...);
Vector<Speed<float>> velocity2 = new Vector<Speed<float>>((1f, Centimeters / Seconds), ...);
Vector<Speed<float>> velocity3 = velocity1 + velocity2; // Automatic conversion applied

// Automatic Unit Conversion
Angle<double> angle1 = (90d, Degrees);
Angle<double> angle2 = (.5d, Turns);
Angle<double> result1 = angle1 + angle2; // 270° 

// Type Safeness
Length<double> length1 = (2d, Yards);
// object result2 = angle1 + length1; // WILL NOT COMPILE!!!

// Manual Unit Conversions
double angle1_inRadians = angle1[Radians];
double angle3 = Angle<double>.Convert(7d, Radians, Degrees);

// Measurement Parsing
Speed<float>.TryParse("20.5 Meters / Seconds", out Speed<float> parsedSpeed);