| NExamples | |
| CSensorData | Simple example showing how a struct can participate in the SystemEx hashing system using IHashable<SensorData> |
| NKernelRamExamples | |
| CExampleRamKernelAdd | Example implementation of a RAM‑based compute kernel that adds two integers |
| NSystemEx | |
| NAlgorythmen | |
| CEqualTo< T > | Provides a boolean comparison that determines whether a and b are equal |
| CGreater< T > | Provides a boolean comparison that determines whether a is strictly larger than b |
| CGreaterEqual< T > | Provides a boolean comparison that determines whether a is larger than or equal to b |
| CISimpleCompare< T > | |
| CLess< T > | Provides a boolean comparison that determines whether a is strictly smaller than b |
| CLessEqual< T > | Provides a boolean comparison that determines whether a is smaller than or equal to b |
| CNotEqualTo< T > | Provides a boolean comparison that determines whether a and b are not equal |
| NBase | |
| CNumberRangeStepper< T > | Provides a cursor-based stepper over a normalized numeric range. The stepper moves from Start to End in fixed increments and exposes forward/backward stepping, reset, and enumeration |
| NCollections | |
| NGeneric | |
| NInterfaces | |
| CIArray< T > | |
| CIBidirectionalIterator< T > | Represents an iterator that can move both forward and backward |
| CICache | |
| CICompared< in T > | |
| CIContainerEx< T > | |
| CIDynamicArray< T > | Extends IArray<T> with dynamic resizing capabilities |
| CIForeachIterator< T > | Represents an iterator that can be used directly in foreach loops. Combines IEnumerable<T> and IEnumerator<T> |
| CIForwardIterator< T > | Represents a forward-only iterator that exposes the current element and an end-of-range indicator |
| CIIterator | |
| CIIterator< T > | Extends IIterator with cloning support, allowing iterators to be duplicated without affecting the original |
| CIMap | |
| CIMap< T, TU > | Defines a typed map structure that stores key/value pairs as Pair<T, TU>. Provides insertion, removal, searching, traversal, and conversion utilities |
| CINode< T > | |
| CIPair< T, TU > | |
| CIPairForwardIterator< T, TU > | Represents a forward iterator over key/value pairs |
| CIRandomAccessIterator< T > | Represents a random-access iterator that supports offset-based movement in addition to forward and backward stepping |
| CIReadOnlyMap< T, TU > | Defines a read‑only associative container mapping keys of type T to values of type TU |
| CISortedArray< T > | Extends IArray<T> with sorting capabilities using either a comparer interface or a delegate-based sort function |
| CISortedMap< T, TU > | Extends IMap<T, TU> with sorting capabilities for key/value pairs. Sorting can be performed using a delegate or a comparer interface |
| CISortedTupleMap | Extends ITupleMap with sorting capabilities for tuple elements. Sorting can be performed using a delegate or a comparer interface |
| CITraverse< T > | Defines a traversal operation over a range of elements using a specified direction and index boundaries |
| CITuple | |
| CITupleMap | |
| CITypeBuffer< T > | |
| CListIterator< T > | |
| CArray< T > | A dynamic array implementation that supports optional auto-growth, indexed access, insertion, removal, traversal, and basic search operations |
| CArrayRandomAccessIterator< T > | |
| CBasicRope< T, TN > | |
| CBinQueue< T > | |
| CCache | Represents a low-level byte buffer with position tracking, typed read/write helpers, and optional locking behavior |
| CCacheIsSharedException | Exception thrown when an operation is attempted on a shared or locked cache |
| CCluster< T > | Basic implementation of ICluster<T> representing a node with weighted children |
| CContainerFlexSpan< T, TContainer > | A container-backed span-like view over any IContainerEx<T> . Unlike System.Span, this type provides mode-based indexing (System, Reverse, Ring) and supports mutable access through Replace() |
| CEnumerator | Enumerator for ContainerExFlexSpan. Supports System, Reverse, and Ring modes. Ring mode produces infinite iteration (wrap-around) |
| CDeque< T > | |
| CFind< T, TContainer > | |
| CFixedArray< T > | |
| CFixedMap< T, TU > | |
| CFixedVector< T > | |
| CGroupNode< T > | |
| CICluster< T > | Represents a cluster node in a weighted graph structure |
| CMap< T, TU > | |
| CMirroredCache | |
| CMultiMap< TT, TU > | |
| CMultiSet< T, TContainer > | Equivalent to a std::flat_multiset, but implemented as an open, non-owning sorted view over any IContainerEx instance. The MultiSet struct does not store elements itself; it maintains ordering by sorting the referenced container using either a user-provided sorting delegate or a built-in BubbleSort fallback when no delegate is supplied |
| CMultiTupleMap | |
| CNode< T > | Represents a doubly linked node with optional child and sibling. Supports list-style navigation (Prev/Next), tree-style traversal, splicing, swapping, reversing, and random access movement |
| CNodeChain< T > | Represents a chained view over multiple NodeRange<T> segments, similar to std::views::concat in C++.
A NodeChain<T> allows iteration across several disjoint ranges of a linked Node<T> structure as if they formed one continuous sequence |
| CNodeIterrator< T > | Iterator for navigating through a doubly linked Node<T> chain. Supports random access, forward/backward movement, foreach enumeration, and cloning of iterator state |
| CNodeRange< T > | |
| CNodeSlice< T > | |
| CPair< T, TU > | |
| CPriorityQueueEx< T, TU > | A priority queue implemented on top of SortedMap<T, TU>.
Elements are stored as Pair<T, TU> where T is the value and TU is the priority.
Supports enqueue, dequeue, peek, priority updates, cloning, and median‑based selection |
| CPriorityQueueExIterator< T, TU > | |
| CQuad< TT, TU, TW, TJ > | |
| CQueue< T > | |
| CRopeChunkValue< T > | |
| CSet< T, TContainer > | Equivalent to a std::flat_set, but implemented as an open, non-owning sorted view over any IContainerEx instance. The Set struct does not store elements itself; it maintains ordering by sorting the referenced container using either a user-provided sorting delegate or a built-in BubbleSort fallback when no delegate is supplied |
| CSortedArray< T > | |
| CSortedFixedArray< T > | |
| CSortedMap< T, TU > | |
| CSortedMultiMap< T, TU > | A map that allows multiple entries with the same key.
Unlike Map<T, TU>, which prevents duplicate pairs, a MultiMap<T, TU> accepts all entries without checking for existing keys or values. /// Sorting is performed eagerly whenever elements are added or inserted, depending on the SortedMap<T, TU> setting |
| CSortedMultiTupleMap | |
| CSortedTupleList | |
| CSortedTupleMap | |
| CStack< T > | A fixed‑size, backward‑growing stack implementation that supports multiple independent virtual stack layers sharing the same underlying buffer |
| CStackLayer | |
| CStarNode< T > | |
| CStrippedCache | |
| CTriple< TT, TU, TW > | |
| CTuple | |
| CTupleList | |
| CTupleMap | |
| CTypeBuffer< T > | |
| CUnorderedMultiSet< T, TContainer > | |
| CUnorderedSet< T, TContainer > | |
| CVector< T > | |
| NModel | |
| CBinaryTree< T > | |
| CGenericNode< T > | Represents a generic node in the collection |
| CGenericNodeIterator< T > | |
| CGroupedNode< T > | |
| CLinkedNode< T > | Intrusive doubly‑linked node storing a value and two directional links |
| CLinkedNodeChain< T > | Represents a chained view over multiple LinkedNodeRange<T> segments, similar to std::views::concat in C++.
A LinkedNodeChain<T> allows iteration across several disjoint ranges of a linked Node<T> structure as if they formed one continuous sequence |
| CLinkedNodeIterrator< T > | Random‑access iterator for intrusive LinkedNode<T> chains |
| CLinkedNodeRange< T > | |
| CLinkedNodeSlice< T > | |
| CLinkedNodeWithSibling< T, TS > | |
| CNode< T > | Intrusive singly-linked node storing a value and a single forward link |
| CNodeIterator< T > | Forward iterator for intrusive singly-linked Node<T> chains |
| CRBTreeNode< T > | Represents a node in a red-black tree |
| CTree< T, TRE > | Represents a generic tree structure with a specified number of child nodes |
| NDevice | |
| NIntertropt | |
| CIDeviceSharedBackend | Defines the low‑level backend interface used by DeviceSharedBuffer and related shared‑memory abstractions.
A backend represents a hardware‑specific buffer implementation such as RAM, OpenCL, Vulkan, CUDA, or any custom device memory.
Each backend is responsible for creating, writing, reading, and closing its own hardware buffer handle |
| CRamSharedBackend | RAM‑based backend for shared device buffers |
| CUnmanagedObject | Represents a pinned unmanaged memory block used by SystemEx backends |
| NMemory | |
| CDeviceBuffer | Represents a cache that can be shared with a hardware backend through DeviceSharedBuffer<TDeviceSharedBackend>.
A DeviceBuffer behaves like a normal Cache, but supports locking and shared‑memory synchronization for device kernels |
| CDeviceSharedBuffer< TDeviceSharedBackend > | Represents a shared memory bridge between a DeviceBuffer and a hardware‑specific backend implementing IDeviceSharedBackend.
Manages the lifecycle of a hardware buffer, including creation, upload, download, and cleanup, depending on the configured SharedCacheType |
| CIKernel< TIDeviceSharedBackend > | Defines the interface for a compute kernel that operates on one or more DeviceSharedBuffer<TDeviceSharedBackend> instances.
A kernel represents a unit of computation that may run on different backends such as RAM, OpenCL, Vulkan, CUDA, or custom hardware |
| CNativeRAMKernel< TD > | Provides a base implementation for RAM‑based compute kernels that operate on DeviceSharedBuffer<RamSharedBackend> instances.
This class handles module loading, buffer management, backend initialization, locking/unlocking of shared buffers, and asynchronous kernel execution.
Derived classes only need to implement backend‑specific behavior such as buffer creation (OnCreate) and kernel invocation (OnRun) |
| NDrawing | |
| CColorCMY | |
| CColorGray | |
| CColorHDR | |
| CColorHSL | |
| CColorHSV | |
| CColorHWB | |
| CColorNCol | |
| CColorR10G10B10A2 | Represents a 10‑bit per channel RGB color (R10G10B10A2), stored internally as normalized floating‑point values (0–1) |
| CColorR10G10B10FormatSchema | |
| CColorR10G10B10Serializer | The ColorR10G10B10FormatSchema class defines the schema for serializing and deserializing a ColorR10G10B10A2 color to and from a binary representation. It specifies the total size, header size, endianness, and field offsets for the color data |
| CColorR16G16B16 | |
| CColorR8G8B8 | Represents an RGB color using normalized float channels (0–1). Provides basic color manipulation, brightness evaluation, contrast classification and interpolation utilities |
| CColorXYZ | |
| CColorYUV | |
| CICanvas< T > | |
| CICanvasList< T > | Represents a layered mathematical canvas system composed of multiple sub‑canvases. Each layer is a deterministic transformation applied on top of the base canvas, forming a purely mathematical composition model rather than a graphical drawing system |
| CIColor< T > | |
| CISubCanvas< T > | Represents a mathematical sub‑canvas that participates as a layer within a layered canvas system. A sub‑canvas does not perform graphical drawing; instead, it defines deterministic transformation rules, visibility states, and optional masking that influence the final composed pixel buffer when requested through ICanvasList<T>.GetPixels or ICanvasList<T>.SwapIn |
| CLight | Base light class used for all light types in the SystemEx.Drawing namespace. Provides shared parameters such as position, direction, diffuse/ambient color and projection settings. Specific light types (spot, point, directional) extend this class with additional behavior |
| CPointLight | Point light implementation. Adds attenuation parameters controlling how light intensity decreases over distance. Typically contains constant, linear, and quadratic terms |
| CPurpelColors | Purpel Color Group |
| CSpotLight | Spot light implementation. Adds inner and outer cone angles (phi/theta) expressed as cosine values. These values are used for smooth falloff inside the spotlight cone |
| NHash | |
| CAdlerHash | |
| CBernsteinHash | |
| CBlack3Hasher | ONLY TEST!!! |
| CFletcherHash | |
| CFnv1aHash | |
| CGrøstlHash | |
| CHash32 | |
| CHash64 | Represents a 64‑bit hash value produced by a SystemEx hashing algorithm |
| CHashable | |
| CHashAlgorithmAttribute | |
| CIHash | Interface for SystemEx hashing algorithms |
| CIHashable< T > | Defines a contract for objects that can be converted into a raw byte representation suitable for hashing, serialization, or low‑level processing |
| CRamakrishnaHash | |
| CWeinbergHash | |
| NIO | |
| NProvider | |
| CByteSeriablizeProvider | Provides a base implementation for serializing objects to and from byte arrays |
| CIByteFormatSchema | A schema defines total size, header size, endianness and fixed field offsets. Implementations must be deterministic and contain no dynamic or computed layout |
| CIByteSerialize< T, TSchema > | Provides deterministic binary serialization and deserialization for a type T using a schema TSchema |
| CIIsByteSeriablize | Represents a type that can be serialized to and from byte arrays |
| CCacheStream< TCache > | A Stream wrapper around a Cache instance.
Provides sequential read/write access to a cache, including endian‑aware primitive serialization, range operations, and chunked asynchronous copy methods.
Seeking is supported only through the underlying cache |
| NNumeric | |
| CAxisAngle< TV, T > | Represents a rotation in 3D space using an axis‑angle pair |
| CDQuatf | Dual quaternion using single-precision floating point values. Represents a rigid 3D transformation consisting of rotation (real part) and translation (dual part). Provides stable, non-drifting transformations compared to matrix-based approaches |
| CHalf16 | |
| CIHalf< T > | |
| CProjection | |
| CQuatd | Represents a doubleing‑point quaternion used for 3D rotations |
| CQuatf | Represents a floating‑point quaternion used for 3D rotations |
| CVec2d | |
| CVec2f | |
| CVec2i | |
| CVec3d | |
| CVec3f | |
| CVec3i | |
| CVec4d | |
| CVec4f | |
| CVec4i | |
| NRandom | |
| CIsaac32Engine | Represents the ISAAC 32-bit random number generator |
| CRandx | Provides a simple interface for generating random numbers using the ISAAC algorithm |
| NRuntime | |
| NInteropServices | |
| NPlatform | |
| CWindowsProcLoader | |
| CModule | |
| NUtils | |
| CMissingStructLayoutSequentialException | Exception thrown when a struct used for unmanaged interop does not specify StructLayoutAttribute with LayoutKind.Sequential.
Required for deterministic field ordering in native interop, binary serialization, and memory‑mapped structures |
| CSizeMismatchException | Exception thrown when the managed size of a struct does not match the expected unmanaged size.
Used to validate binary compatibility between C# structs and native memory layouts |
| CBuffer | |
| CFlexSpan< T > | A lightweight view over an array supporting System, Reverse, and Ring (circular) indexing. FlexSpan does not allocate and provides ref-return access to elements |
| CEnumerator | Enumerator for FlexSpan. Supports forward, reverse, and ring traversal |
| CIComparableEx< T > | Provides an extended and strongly typed comparison contract for SystemEx |
| CIRange< T > | |
| CNumberRange< T > | Represents a numeric range defined by a start and end value. Provides range validation, containment checks, normalization, intersection, adjacency, union, and enumeration |
| CNumberRangeIterator< T > | Forward iterator over a normalized numeric range. Supports stepping by one unit and exposes the current value and end-of-range state |
| CTriple | Represents a three-valued logic value |
1.17.0