| ►Choney::Allocator< FreeListAllocator, T > | |
| ►Choney::MemPoolAllocator< FreeListAllocator, T > | |
| Choney::lockfree::FreeListAllocator< T > | |
| ►Choney::Allocator< SmallAllocator, T > | |
| ►Choney::MemPoolAllocator< SmallAllocator, T > | |
| Choney::SmallAllocator< T > | Global allocator for small memory blocks. To provide a custom pool define SmallAllocator_createSingleton_ and implement SmallAllocator_createSingleton() |
| Choney::Atomic< bool > | |
| Choney::Atomic< float > | |
| Choney::Atomic< honey::MemPool::Bucket::TaggedHandle > | |
| Choney::Atomic< honey::MonoClock::honey::TimePoint > | |
| Choney::Atomic< honey::Thread::ThreadId > | |
| Choney::Atomic< int > | |
| Choney::Atomic< intptr_t > | |
| Choney::Atomic< MarkedHandle > | |
| Choney::Atomic< Node * > | |
| Choney::Atomic< RunMode > | |
| Choney::Atomic< sdt > | |
| Choney::Atomic< State > | |
| Choney::Atomic< szt > | |
| Choney::Atomic< uint8 > | |
| Choney::BitSet_< Block, Alloc > | |
| ►Choney::matrix::priv::BlockTraits< MatrixP, Rows, Cols > | |
| Choney::matrix::priv::Traits< Block< MatrixP, Rows, Cols > > | |
| ►Choney::matrix::priv::BlockTraits< Vec, 1, 1 > | |
| Choney::matrix::priv::Traits< Block< Vec, 1, 1 > > | 1x1 block traits |
| ►Choney::matrix::priv::BlockTraits< Vec, 1, Cols > | |
| Choney::matrix::priv::Traits< Block< Vec, 1, Cols > > | Column vector block traits |
| ►Choney::matrix::priv::BlockTraits< Vec, Rows, 1 > | |
| Choney::matrix::priv::Traits< Block< Vec, Rows, 1 > > | Row vector block traits |
| ►CVariant | |
| Choney::json::Value_< Config_ > | Json value variant. Provide a Config to customize the variant's bounded types |
| Choney::DefaultAllocator< Bucket > | |
| Choney::DefaultAllocator< Heap > | |
| Choney::DefaultAllocator< honey::ConditionLock > | |
| Choney::DefaultAllocator< honey::ListenerList > | |
| Choney::DefaultAllocator< honey::lockfree::HazardMem::ThreadData::DelNode > | |
| Choney::DefaultAllocator< honey::SlotBase > | |
| Choney::DefaultAllocator< honey::SpinLock > | |
| Choney::DefaultAllocator< std::string > | |
| Choney::DefaultAllocator< ThreadData > | |
| Choney::DefaultAllocator< uint8 > | |
| Choney::DefaultAllocator< Vec< dim, Real > > | |
| Choney::DefaultAllocator< Worker > | |
| Choney::DepGraph< const log::Level > | |
| Choney::DepGraph< DepNode > | |
| Choney::DepGraph< DepTask::DepNode > | |
| Choney::DepNode< DepTask * > | |
| Choney::DepNode< Type * > | |
| Choney::deref_wrap< honey::json::Value_ > | |
| Choney::deref_wrap< TreeNode > | |
| Choney::finalize< Block, Alloc > | |
| Choney::finalize< Bucket > | |
| Choney::finalize< Heap > | |
| Choney::finalize< honey::ConditionLock > | |
| Choney::finalize< honey::ListenerList > | |
| Choney::finalize< honey::lockfree::HazardMem::ThreadData::DelNode > | |
| Choney::finalize< honey::SlotBase > | |
| Choney::finalize< honey::SpinLock > | |
| Choney::finalize< std::string > | |
| Choney::finalize< ThreadData > | |
| Choney::finalize< uint8 > | |
| Choney::finalize< Vec< dim, Real > > | |
| Choney::finalize< Worker > | |
| Choney::lockfree::FreeList< Node >< Node > | |
| ►CFunc | |
| Choney::overload_< Func, Funcs... > | An overloaded visitor functor |
| Choney::mt::Funcptr< void()> | |
| ►Choney::FutureCommon< Future< R >, R > | |
| Choney::Future< R > | Unique future, guarantees sole access to a future function result |
| ►Choney::FutureCommon< SharedFuture< R >, R > | |
| Choney::SharedFuture< R > | Shared future, allows multiple access to a future function result |
| ►Choney::Allocator< Subclass, T > | Std::allocator compatible allocator |
| Choney::MemPoolAllocator< Subclass, T > | MemPool allocator |
| Choney::Allocator< Subclass, T >::rebind< U > | |
| ►Choney::AllocatorObject< Alloc > | Objects that inherit from this class will use Alloc for new/delete ops |
| ►Choney::Listener | Holds a slot that can receive signals |
| Choney::ListenerQueue | Listener that holds queued slot for delayed processing of signals |
| Choney::SlotBase | Multicast receiver |
| Choney::app::ModuleRegistry | List of application modules |
| Choney::Atomic< T, B > | |
| Choney::atomic::SwapType< T > | Get the smallest atomically-swappable type that is large enough to hold T |
| Choney::Atomic< T *, false > | Wrapper around pointer type to make all operations atomic and sequentially consistent |
| Choney::Atomic< T, false > | Wrapper around a trivially copyable type to make load/store operations atomic and sequentially consistent |
| Choney::Atomic< T, true > | Wrapper around integral type to make all operations atomic and sequentially consistent |
| Choney::BackSub< Real > | Back substitute to solve a linear system |
| Choney::BetaInc< Real > | Evaluate the incomplete beta function |
| Choney::Bisect< Real > | Find the root of a function by the bisection method. ie. Finds where function returns 0 |
| Choney::BisectN< Real, Dim > | Find the root of a set of functions by the bisection method. ie. Finds (x,y,...) where all functions return 0 |
| ►Choney::BitOpCommon | Bit util common to any endian type. Use through class BitOp |
| Choney::BitOpEndian< static_cast< int >(Endian::big)> | Specialization for big endian |
| Choney::BitOpEndian< static_cast< int >(Endian::little)> | Specialization for little endian |
| Choney::BitOpEndian< Endian > | Bit util specific to endian type. Use through class BitOp |
| Choney::BitSet_< Block, Alloc_ > | A compact array of bits. Dynamic version of std::bitset |
| Choney::bloom_filter::hash< T > | Functor used to generate hash. Each hashIndex for the same object must produce a unique hash |
| Choney::bloom_filter::Key< T, Alloc > | Caches multiple hashes of an object. The key can be inserted into a bloom filter and tested very quickly |
| Choney::BloomFilter< T, Block, Alloc > | A space-efficient probabilistic data structure that is used to test set membership. Can be tuned to use less space at the expense of increased false positive probabilty |
| Choney::Bootstrap< SampleT, Dim, Real__ > | Monte Carlo (random-based) method to estimate the interval of confidence in a function's result, when that function operates on samples from a complex or unknown distribution |
| Choney::Bootstrap< SampleT, Dim, Real__ >::meanFunc | Functor to estimate the sample mean |
| Choney::Bootstrap< SampleT, Dim, Real__ >::varianceFunc | Functor to estimate the sample variance. This is the unbiased estimator (mean over all possible samples is the population variance) |
| Choney::Buffer< T > | A contiguous region of referenced (not owned by object) memory |
| Choney::Chacha::State | Generator State |
| Choney::ComRegistry | Holds global list of all component types |
| Choney::ConditionAny | Condition that can be used with any kind of lock. Slightly slower than the default Condition class |
| Choney::DefaultAllocator< T, class > | Returns T::Allocator<T> if available, otherwise std::allocator<T> |
| Choney::DefaultAllocator< T, typename mt::True< typename T::template Allocator< T > >::type > | |
| Choney::DefaultAllocator< T[], std::true_type > | |
| Choney::DepGraph< DepNode_ > | Dependency graph. Collects nodes and builds a searchable directed graph |
| Choney::DepGraph< DepNode_ >::Iter_< Vertex_ > | Depth-first pre-order iterator over vertices |
| Choney::DepGraph< DepNode_ >::NodeIter_< Vertex_ > | Depth-first pre-order iterator over nodes. Iterates over nodes that constitute each vertex in a vertex range |
| Choney::DepGraph< DepNode_ >::Vertex | A vertex is initially associated with one key and acts like a multi-map, storing all nodes and graph links of DepNodes matching that key |
| Choney::DepNode< Data_, Key_, Alloc_ > | Dependency node for insertion into graph |
| Choney::DepSched | Scheduler that serializes and parallelizes task execution given a dependency graph of tasks and a pool of threads |
| Choney::deref_wrap< T, Ptr, ConstPtr > | Wraps a pointer so that it behaves similar to a reference |
| Choney::Duration< Rep_, Period_ > | Duration represented by repetitions of a period. The period must be a ratio |
| Choney::Eigen< Real > | Eigendecomposition. Decomposes any square (n x n) symmetric matrix  into eigenvalues and eigenvectors |
| Choney::EnumElem | Base class of all generated enum classes. A single element in the enumeration. See Enumeration Classes |
| Choney::EnumInfo_< EnumType > | Run-time info about an enum class. Contains a list of elements and maps for element lookups. See Enumeration Classes for more info and examples |
| Choney::EnumInfo_< EnumType >::Elem | |
| Choney::Exception::Raiser | Helper to raise an exception after the right side of ^ has been evaluated |
| Choney::Exception::Source | Info about source where exception was thrown |
| Choney::finalize< T, Alloc > | Functor to delete a pointer |
| Choney::finalize< T[], std::allocator< T > > | Specialization for array |
| Choney::finalize< void, std::allocator< void > > | Specialization for void |
| ►Choney::future::AsyncSched_tag | |
| Choney::future::AsyncSched | |
| Choney::FutureCommon< Subclass, R > | Mixin for common future methods |
| Choney::GammaFunc_< Real > | Class to evaluate Gamma and related functions |
| ►Choney::Id | Holds a name string and its hashed value for fast comparison ops. See String Identifier |
| ►Choney::NameId | Holds both a name string and its hashed value, and unlike Id the name is never compiled out |
| Choney::ComRegistry::Type | Component type |
| Choney::IdLiteral | Id created from a string literal at compile-time |
| Choney::IntIter< T > | Incremental integer iterator (step size = 1). See range(int, int) to create |
| Choney::IntStepIter< T > | Integer iterator with step size. See range(int, int, int) to create |
| Choney::json::Config< ordered, Alloc > | Configuration for json value variant |
| Choney::json::null_t | Json null value type |
| Choney::lazy< T, Eval, Pred > | Wraps a value so that it is calculated only when needed. A lock synchronizes access |
| Choney::LinearLeastSqr< Real > | Linear least squares solver |
| Choney::ListenerList | Collection of listeners |
| Choney::ListenerList::Callback | Callback to handle events from this class |
| Choney::lockfree::Backoff | Exponential backoff algorithm. Backoff spins for first X ticks, then sleeps with a time that doubles every X ticks thereafter |
| Choney::lockfree::HazardMem< Config >::ThreadData::DelNode | |
| ►Choney::lockfree::HazardMemConfig | Configuration interface for memory manager. Inherit this class and override types and static members |
| Choney::lockfree::List< T, Alloc_, Backoff, iterMax > | Lock-free doubly-linked list |
| ►Choney::lockfree::HazardMemLink< Node > | Base link class, contains a generic Cas-able data chunk. The data chunk contains a pointer to a HazardMemNode |
| Choney::lockfree::List< T, Alloc_, Backoff, iterMax >::Node::Link | Combines node pointer and delete mark in one Cas-able integer |
| Choney::lockfree::HazardMemNode | Base node class, inherit from this class, add link members, and use as Node type in HazardMemConfig |
| Choney::lockfree::List< T, Alloc_, Backoff, iterMax >::Iter_< T_ > | Iterator |
| Choney::lockfree::List< T, Alloc_, Backoff, iterMax >::IterR_< T_ > | Reverse iterator |
| Choney::Log | Logger |
| Choney::Manip< Subclass > | Base class to hold iostream manipulator state. Inherit from this class and call Subclass::inst(ios) to attach an instance of Subclass to an iostream |
| Choney::ManipFunc< Func, Tuple > | Helper to create a manipulator that takes arguments |
| Choney::matrix::Builder< Matrix > | Matrix comma initializer |
| Choney::matrix::Iter< Matrix > | Matrix element iterator |
| Choney::matrix::Option | Matrix type options |
| Choney::matrix::priv::BlockTraits< MatrixP_, Rows, Cols > | |
| Choney::matrix::priv::StorageAutoArray< Real, Size, Align > | |
| Choney::matrix::priv::StorageAutoArray< Real, Size, 16 > | |
| ►Choney::matrix::priv::StorageDense< Subclass > | |
| Choney::matrix::priv::StorageAuto< Subclass > | Automatic (stack-compatible) dense storage |
| Choney::matrix::priv::StorageBlock< Subclass > | Block wrapper around any constant matrix with auto / dynamic dense storage type. Fully recursive, a block can wrap a block |
| Choney::matrix::priv::StorageDynamic< Subclass > | Dynamic (heap) dense storage |
| Choney::vec::priv::StorageFields< Subclass > | Automatic (stack-compatible) vector storage that allows direct access to dimension fields |
| Choney::matrix::priv::Traits< Subclass > | |
| Choney::matrix::priv::Traits< Matrix< Rows, Cols, Real_, Options, Alloc_ > > | (m x n)-dimensional matrix traits |
| Choney::MemPool::Bucket::BlockHeader | Bucket block header |
| Choney::MemPool::Bucket::BlockHeader::Debug | |
| ►Choney::MemPool::Bucket::Handle | Enables blocks to be referenced via index rather than pointer so that they can include a tag while still maintaining a swappable size |
| Choney::MemPool::Bucket::TaggedHandle | Holds block handle and tag to prevent lock-free ABA issues |
| Choney::MemPool::Heap::BlockHeader | Heap block header |
| Choney::MemPool::Heap::BlockHeader::Debug | |
| Choney::Minimize< Real > | Find a local minimum of a 1-dimensional function using "Brent's method" – bisection and inverse quadratic interpolation |
| Choney::MinimizeN< Real, Dim > | Find a local minimum of an n-dimensional function using "Powell's conjugate gradient descent method" |
| Choney::mt::elemOf< Range > | Get range element type |
| Choney::mt::Funcptr< Sig > | |
| Choney::mt::Funcptr< R(Args...)> | Holds a function pointer so that a functor can be called non-virtually. The functor must inherit from FuncptrBase |
| Choney::mt::Funcptr< void(Args...)> | Specialization for void return type |
| ►Choney::mt::FuncptrBase | Inherit to enable non-virtual functor calling |
| ►Choney::thread::Pool::Task | All tasks must inherit from this class. std::function is not used here to avoid the operator() virtual call |
| ►Choney::DepTask | Base class of DepTask_, can be added to scheduler. Instances must be created through class DepTask_ |
| Choney::DepTask_< void > | |
| Choney::DepTask_< Result > | Holds a functor and dependency information, enqueue in a scheduler to run the task |
| ►Choney::PeriodicTask | Base class of PeriodicTask_, returned by scheduler |
| Choney::PeriodicTask_< Result > | Holds a functor and period information, returned by scheduler |
| Choney::mt::gcd< a, b > | Calc greatest common divisor of a and b |
| Choney::mt::identity< T > | Returns type T unchanged |
| Choney::mt::isCallable< Func, Args > | Check if functor is callable with arguments |
| Choney::mt::isRange< T > | Check if type is a range or a reference to one. A range is a type where std::begin(range) is a valid call |
| Choney::mt::iter_endOf< Range > | Get range iterator end type |
| Choney::mt::iterOf< Range > | Get range iterator begin type |
| Choney::mt::max< vals > | Get maximum of all arguments |
| Choney::mt::min< vals > | Get minimum of all arguments |
| ►Choney::mt::NoCopy | Inherit to declare that class is not copyable |
| Choney::lockfree::FreeList< Node > | |
| Choney::lockfree::HazardMem< honey::lockfree::List > | |
| Choney::Alge_< Real > | Algebra |
| Choney::App | Top-level application flow controller, provides entry point and run loop |
| ►Choney::Condition | Method to synchronize threads. Condition variables eliminate the need for repeated polling to check the value of some data |
| Choney::ConditionLock | Lock that is bound to a single condition. This is the common usage case of condition variables |
| ►Choney::FutureBase | Base class for Future types |
| Choney::Future< R > | Unique future, guarantees sole access to a future function result |
| Choney::SharedFuture< R > | Shared future, allows multiple access to a future function result |
| Choney::Interp_< Real > | Interpolation math |
| Choney::lockfree::FreeList< T > | Lock-free freelist, allocates re-usable objects and provides automatic storage expansion for concurrent algorithms |
| Choney::lockfree::HazardMem< Config > | Lock-free memory manager, provides safe memory reclamation for concurrent algorithms |
| Choney::lockfree::List< T, Alloc_, Backoff, iterMax > | Lock-free doubly-linked list |
| Choney::lockfree::Queue< T > | Lock-free FIFO queue. Uses auto-expanding freelist allocator so memory is only reclaimed upon destruction |
| Choney::lockfree::SpscDeque< T, Alloc_ > | Deque that is lock-free only when used by a single producer and consumer, otherwise contention is split between front and back locks |
| Choney::lockfree::Stack< T > | Lock-free FILO stack. Uses auto-expanding freelist allocator so memory is only reclaimed upon destruction |
| Choney::lockfree::UnorderedMap< Key, T, Hash, KeyEqual > | Lock-free unordered map. Uses auto-expanding freelist allocator so memory is only reclaimed upon destruction |
| Choney::MemPool | Memory pool |
| Choney::net::Socket | Socket class |
| Choney::net::StreamBuf_< Alloc > | Automatically resizable buffer class based on ByteStreamBuf |
| Choney::PackagedTask< R(Param...)> | |
| Choney::Promise< R > | Container to hold a delayed function result |
| Choney::RealBase< Real_ > | Base class for real number operations |
| Choney::ScopeGuard_< F > | Run a function at scope exit. See ScopeGuard() to create |
| Choney::SharedLock< Lockable_ > | A scoped lock that references a shared mutex. Does a shared read lock on construction and unlocks on destruction |
| Choney::SharedObj< Subclass > | Reference-counted object for intrusive shared pointers |
| Choney::Thread | Thread class |
| Choney::thread::InterruptEnable | Enable / disable interrupts in the current thread's scope |
| Choney::TransferLock< FromLock, ToLock > | Scoped transfer of mutex ownership between two locks |
| Choney::UniqueLock< Lockable_ > | A scoped lock that references any lockable. Locks on construction and unlocks on destruction |
| Choney::UniquePtr< T, Fin > | Pointer to a unique, non-shared, object. Finalizer is run upon destruction (deletes object by default) if pointer is not null |
| Choney::lockfree::Queue< TaskPtr > | |
| Choney::lockfree::Queue< tuple< Action, honey::PeriodicTask::Ptr > > | |
| ►Choney::RealBase< double > | |
| Choney::Double_ | Defines 64-bit floating point operations and constants |
| ►Choney::RealBase< float > | |
| Choney::Float_ | Defines floating point operations and constants |
| ►Choney::RealBase< float128 > | |
| Choney::Quad_ | Defines 128-bit floating point operations and constants |
| ►Choney::SharedObj< DepTask > | |
| Choney::DepTask | Base class of DepTask_, can be added to scheduler. Instances must be created through class DepTask_ |
| ►Choney::SharedObj< Exception > | |
| ►Choney::Exception | Base exception class. Exceptions inherited from this class provide debug info and can be thrown polymorphically (unlike standard c++ exceptions) |
| Choney::App::Terminated | Process terminated. Use this interrupt to exit the run loop |
| Choney::debug::AssertionFailure | Thrown on debug assert() failure |
| Choney::EnumError | |
| Choney::exception::Std< T > | Wrapper around std exception to allow for polymorphic throw |
| Choney::exception::Unknown | |
| Choney::future::AlreadySatisfied | |
| Choney::future::Broken | Exceptions |
| Choney::future::FutureAlreadyRetrieved | |
| Choney::future::NoState | |
| Choney::json::ValueError | |
| Choney::PeriodicTask::Cancelled | Future result when cancelled |
| Choney::PropertyError | |
| Choney::thread::Interrupted | Interrupted exception |
| Choney::VariantError | |
| ►Choney::SharedObj< Listener > | |
| Choney::Listener | Holds a slot that can receive signals |
| ►Choney::SharedObj< Module > | |
| Choney::app::Module | An application module, holds a task and its dependencies |
| ►Choney::SharedObj< Object > | |
| ►Choney::Object | Base class for objects |
| Choney::ComObject | Component object. Object that consists of a collection of components |
| Choney::Component | Base class for components. Components can only be attached to one ComObject at a time |
| ►Choney::PropertyBase | Base class for all properties |
| Choney::Property< T > | Generic property |
| Choney::Property< vector< T > > | Generic vector property |
| Choney::PropertyObject | Object that contains properties |
| ►Choney::SharedObj< PeriodicTask > | |
| Choney::PeriodicTask | Base class of PeriodicTask_, returned by scheduler |
| ►Choney::SharedObj< Pool > | |
| ►Choney::thread::Pool | Spreads task execution across a pool of re-usable threads. Uses a lock-free work-stealing queue to ensure workers are never idle |
| Choney::future::AsyncSched | |
| ►Choney::SharedObj< Sink > | |
| ►Choney::log::Sink | |
| Choney::log::BufferSink | Captures records in a buffer |
| ►Choney::log::StreamSink | Formats record to a stream |
| Choney::log::FileSink | Formats record to a file stream |
| Choney::SharedObj< State > | |
| Choney::UniqueLock< SpinLock > | |
| Choney::UniquePtr< Block, honey::finalize< Block, Alloc > > | |
| Choney::UniquePtr< Bucket > | |
| Choney::UniquePtr< Heap > | |
| Choney::UniquePtr< honey::ConditionLock > | |
| Choney::UniquePtr< honey::ListenerList > | |
| Choney::UniquePtr< honey::lockfree::HazardMem::ThreadData::DelNode[]> | |
| Choney::UniquePtr< honey::SlotBase > | |
| Choney::UniquePtr< honey::SpinLock > | |
| Choney::UniquePtr< std::string > | |
| Choney::UniquePtr< T, honey::finalize< T, Alloc > > | |
| Choney::UniquePtr< ThreadData > | |
| Choney::UniquePtr< uint8 > | |
| Choney::UniquePtr< Vec< dim, Real >[]> | |
| Choney::UniquePtr< Worker > | |
| Choney::mt::tag< int > | Use to differentiate an overloaded function by type. Accepts dummy parameter default value: func(tag<0> = 0) |
| Choney::mt::Void | Special void type, use where void is intended but implicit members are required (default ctor, copyable, etc.) |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ > | Common functions between map elem and the map tail specialization. Use through class MtMapElem |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::priv< isTail, _ >::findElem< Key, Prev_ > | Specialize for our key |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::priv< true, _ >::findElem< Key, Prev_ > | |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::size_ | Get size of map at compile-time |
| Choney::MtMapIter< Head, Elem > | Bidirectional iterator over map key/value pairs |
| Choney::MtPair< Key_, Val_ > | Key/value pair. A pair can be constructed with the syntax: (key() = value) |
| Choney::Numeral< T > | Numeric type information, use numeral() to get instance safely from a static context |
| Choney::NumeralFloat< T > | Numeric type info for floating point types |
| Choney::NumeralInt< T > | Numeric type info for integer types |
| Choney::optional< T > | Enables any type to be optional so it can exist in an uninitialized null state |
| Choney::optional< T & > | Specialization for references |
| Choney::optnull_t | Null optional type |
| Choney::overload_< Funcs > | |
| Choney::overload_<> | |
| Choney::PackagedTask< Sig > | A container that wraps a function so that its result is stored in a future when invoked |
| Choney::PeriodicSched | Scheduler that executes tasks periodically or after a delay given a pool of threads |
| Choney::Permute_< Real > | Generate all permutations of a list. A functor can be specified for fast culling of entire subtrees of undesired permutations |
| Choney::Permute_< Real >::Iter< T > | Iter for permutations of a list |
| Choney::Polynomial< Real > | Polynomial algorithms |
| Choney::Qrd< Real > | QR Decomposition. Can be used to solve least squares problems |
| Choney::Quat_< Real__ > | Quaternion rotation class. Represents a counter-clockwise rotation of an angle about its axis |
| Choney::Random_< Real > | Random-related methods |
| Choney::Random_< Real >::DistStats | |
| ►Choney::RandomDist< Real > | Base class for all random distributions |
| Choney::Beta_< Real > | Generate a random variate from a beta distribution  |
| Choney::Binomial_< Real > | Generate a random integer variate from a binomial distribution |
| Choney::BinomialNeg_< Real > | Generate a random integer variate from a negative binomial distribution |
| Choney::ChiSqr_< Real > | Generate a random variate from a noncentral chi-square  distribution |
| Choney::DiscreteGen_< Real > | Generate a random integer variate from a generalized discrete distribution |
| Choney::Gamma_< Real > | Generate a random variate from a gamma distribution  |
| Choney::Gaussian_< Real > | Generate a normally (Gaussian) distributed random variate |
| Choney::HyperGeo_< Real > | Generate a random integer variate from a hypergeometric distribution |
| Choney::Poisson_< Real > | Generate a random integer variate from a poisson distribution |
| Choney::StudentT_< Real > | Generate a random variate from a Student's t-distribution |
| Choney::Uniform_< Real > | Generate a random variate between min and max non-inclusive with uniform (flat) distribution |
| Choney::Weibull_< Real > | Generate a random integer variate from a weibull distribution |
| ►Choney::RandomGen | Random number generator interface |
| Choney::Chacha | ChaCha8, a cryptographically secure pseudo random number generator |
| Choney::Range_< T1_, T2_ > | Iterator range. See range(Iter1&&, Iter2&&) to create |
| Choney::Ratio< Num, Den > | Class to hold compile-time finite rational numbers, ie. the fraction num / den |
| Choney::Ratio< Num, Den >::add< rhs > | Operator+ |
| Choney::Ratio< Num, Den >::div< rhs > | Operator/ |
| Choney::Ratio< Num, Den >::mul< rhs > | Operator* |
| Choney::Ratio< Num, Den >::sub< rhs > | Operator- |
| Choney::RealIter< T > | Real number iterator. See range(Real, Real, Real) to create |
| Choney::recursive_wrap< T, Alloc > | Allows for recursive type definitions, eg. class Object : vector<recursive_wrap<Object>> |
| Choney::RingIter< Range, Iter > | Ring iterator. See ringRange() to create |
| Choney::SharedMutex | A thread lock for shared data where there may be many readers and one writer |
| Choney::SimplexNoiseCommon< Subclass, Dim, Real > | Methods common to all simplex noise dimensions |
| Choney::SinTable< Real > | Speeds up all trig functions at the cost of precision. Precision is roughly 1 / size |
| Choney::SpinLock | A thread lock where the lock is acquired through a busy wait loop |
| Choney::StudentT_< Real >::PooledStats | |
| Choney::StudentT_< Real >::Stats | |
| Choney::Svd< Real > | Singular Value Decomposition. Can be used to calculate the pseudo-inverse of any matrix or solve least squares problems |
| Choney::thread::Local< T > | Local thread storage. Multiple threads can access one Local object, but each thread will only see its own separate "local" instance |
| Choney::TimePoint< Clock_, Dur > | TimePoint represented by a duration since a clock's epoch time |
| Choney::Transform_< Real > | A 3D linear transform from TRS components (translation, rotation, and scale/skew) |
| Choney::TreeClone< TreeNode > | Clone and track changes to an entire tree |
| Choney::TreeNode< Data_, Key_, Alloc > | Unrooted acyclic tree |
| Choney::TreeNode< Data_, Key_, Alloc >::PreOrdIter_< TreeNode > | Depth-first pre-order traversal |
| Choney::Trig_< Real > | Trigonometry |
| Choney::TupleIter< Iter, I, IterCategory > | Wrapper around an iterator with tuple value type. When dereferenced returns I'th element |
| ►Choney::TupleIter< Iter, I, std::forward_iterator_tag > | |
| Choney::TupleIter< Iter, I, std::bidirectional_iterator_tag > | |
| Choney::vec::priv::Segment< Vec, Dim > | Vector segment view |
| Choney::vec::priv::StorageFieldsMixin< Real, Dim, Align > | |
| Choney::vec::priv::StorageFieldsMixin< Real, 1, Align > | |
| Choney::vec::priv::StorageFieldsMixin< Real, 2, Align > | |
| Choney::vec::priv::StorageFieldsMixin< Real, 3, Align > | |
| Choney::vec::priv::StorageFieldsMixin< Real, 4, 16 > | |
| Choney::vec::priv::StorageFieldsMixin< Real, 4, Align > | |
| Choney::vec::priv::Traits< Dim, Real_, Options, Alloc_ > | N-dimensional vector traits |
| Choney::VecSwizCon< Dim, Real, Options > | Vector for const swizzle operators |
| Choney::VecSwizRef< Dim, Real, Options > | Vector reference holder for mutable swizzle operators |
| Choney::Vegas< Dim, DimRes, Real__, BinCount > | Monte Carlo (random-based) method to approximate the integral of a function over any number of dimensions |
| Choney::lazy< Matrix< matrix::dynamic, matrix::dynamic, Real > > | |
| ►Ctemplate findElem | |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::priv< isTail, _ >::findElem< Key, Prev > | We don't have this key, recurse towards tail |
| ►Ctemplate sizeR | |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::priv< isTail, _ >::sizeR< Count > | Recurse to tail |
| ►CList_ | |
| Choney::MtMapElem< Key_, Val_, List_ > | Map element in recursive list |
| Choney::thread::Local< Local > | |
| Choney::thread::Local< ThreadDataRef > | |
| Choney::thread::Local< Worker * > | |
| ►CStorage | |
| ►Choney::MatrixBase< Subclass > | Matrix base class |
| Choney::VecBase< Subclass > | Vector base class |
| ►Choney::MatrixBase< Matrix< 4, 4, Real, Options > > | |
| Choney::Matrix< 4, 4, Real, Options > | 4x4 homogeneous matrix class. Supports both affine and projective operations |
| ►Choney::MatrixBase< Matrix< Rows, Cols, Real, Options, Alloc > > | |
| Choney::Matrix< Rows, Cols, Real, Options, Alloc > | (m x n)-dimensional matrix |
| Choney::Matrix< matrix::dynamic, matrix::dynamic, Real > | |
| ►Choney::MatrixBase< Vec< 1, Real, Options > > | |
| ►Choney::VecBase< Vec< 1, Real, Options > > | |
| ►Choney::Vec< 1, Real, Options > | 1D vector |
| Choney::Matrix< 1, 1, Real, Options > | Matrix 1x1 vector |
| ►Choney::MatrixBase< Vec< 2, Real, Options > > | |
| ►Choney::VecBase< Vec< 2, Real, Options > > | |
| Choney::Vec< 2, Real, Options > | 2D vector |
| ►Choney::MatrixBase< Vec< 3, Real, Options > > | |
| ►Choney::VecBase< Vec< 3, Real, Options > > | |
| Choney::Vec< 3, Real, Options > | 3D vector |
| ►Choney::MatrixBase< Vec< 4, Real, Options > > | |
| ►Choney::VecBase< Vec< 4, Real, Options > > | |
| Choney::Vec< 4, Real, Options > | 4D vector |
| ►Choney::MatrixBase< Vec< Dim, Double, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, Double, Options, Alloc > > | |
| Choney::Vec< matrix::dynamic, Double > | |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< SwizT >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< SwizT >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< SwizT >::dim, matrix::priv::Traits< SwizT >::Real, matrix::priv::Traits< SwizT >::options > | |
| Choney::VecSwizConBase< SwizT > | |
| Choney::VecSwizRefBase< SwizT > | |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< VecSwizCon< 2, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< VecSwizCon< 2, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< VecSwizCon< 2, Real, Options > >::dim, matrix::priv::Traits< VecSwizCon< 2, Real, Options > >::Real, matrix::priv::Traits< VecSwizCon< 2, Real, Options > >::options > | |
| ►Choney::VecSwizConBase< VecSwizCon< 2, Real, Options > > | |
| Choney::VecSwizCon< 2, Real, Options > | 2D const swizzle vector |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< VecSwizCon< 3, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< VecSwizCon< 3, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< VecSwizCon< 3, Real, Options > >::dim, matrix::priv::Traits< VecSwizCon< 3, Real, Options > >::Real, matrix::priv::Traits< VecSwizCon< 3, Real, Options > >::options > | |
| ►Choney::VecSwizConBase< VecSwizCon< 3, Real, Options > > | |
| Choney::VecSwizCon< 3, Real, Options > | 3D const swizzle vector |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< VecSwizCon< 4, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< VecSwizCon< 4, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< VecSwizCon< 4, Real, Options > >::dim, matrix::priv::Traits< VecSwizCon< 4, Real, Options > >::Real, matrix::priv::Traits< VecSwizCon< 4, Real, Options > >::options > | |
| ►Choney::VecSwizConBase< VecSwizCon< 4, Real, Options > > | |
| Choney::VecSwizCon< 4, Real, Options > | 4D const swizzle vector |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< VecSwizRef< 2, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< VecSwizRef< 2, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< VecSwizRef< 2, Real, Options > >::dim, matrix::priv::Traits< VecSwizRef< 2, Real, Options > >::Real, matrix::priv::Traits< VecSwizRef< 2, Real, Options > >::options > | |
| ►Choney::VecSwizRefBase< VecSwizRef< 2, Real, Options > > | |
| Choney::VecSwizRef< 2, Real, Options > | 2D mutable swizzle vector |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< VecSwizRef< 3, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< VecSwizRef< 3, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< VecSwizRef< 3, Real, Options > >::dim, matrix::priv::Traits< VecSwizRef< 3, Real, Options > >::Real, matrix::priv::Traits< VecSwizRef< 3, Real, Options > >::options > | |
| ►Choney::VecSwizRefBase< VecSwizRef< 3, Real, Options > > | |
| Choney::VecSwizRef< 3, Real, Options > | 3D mutable swizzle vector |
| ►Choney::MatrixBase< Vec< Dim, matrix::priv::Traits< VecSwizRef< 4, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, matrix::priv::Traits< VecSwizRef< 4, Real, Options > >::Real, Options, Alloc > > | |
| ►Choney::Vec< matrix::priv::Traits< VecSwizRef< 4, Real, Options > >::dim, matrix::priv::Traits< VecSwizRef< 4, Real, Options > >::Real, matrix::priv::Traits< VecSwizRef< 4, Real, Options > >::options > | |
| ►Choney::VecSwizRefBase< VecSwizRef< 4, Real, Options > > | |
| Choney::VecSwizRef< 4, Real, Options > | 4D mutable swizzle vector |
| ►Choney::MatrixBase< Vec< Dim, Real, Options, Alloc > > | |
| ►Choney::VecBase< Vec< Dim, Real, Options, Alloc > > | |
| Choney::Vec< Dim, Real, Options, Alloc > | N-dimensional vector |
| Choney::Vec< 2, Real > | |
| Choney::Vec< 3, Real > | |
| Choney::Vec< Dim, Real > | |
| Choney::Vec< dim, Real > | |
| Choney::Vec< matrix::dynamic, Real > | |
| ►Choney::MatrixBase< Vec< Dim, Real, Options, Alloc_ > > | |
| ►Choney::VecBase< Vec< Dim, Real, Options, Alloc_ > > | |
| ►Choney::Vec< Dim, Real, Options, Alloc_ > | |
| Choney::Matrix< Dim, 1, Real, Options, Alloc_ > | Matrix column vector |
| ►Choney::Vec< Dim, Real, Options|matrix::Option::vecRow, Alloc_ > | |
| Choney::Matrix< 1, Dim, Real, Options, Alloc_ > | Matrix row vector |
| ►CValue | |
| Choney::matrix::Option::getAlign< Options > | |
| Choney::matrix::Option::setAlign< Align > | Alignment must be a power of 2 |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::empty_ | Check if empty at compile-time |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::hasKey_< Key > | Check if key exists at compile-time |
| Choney::MtMapCommon< Subclass, Key_, Val_, List_ >::priv< true, _ >::sizeR< Count > | End recursion |
| Choney::Ratio< Num, Den >::equal< rhs > | Operator== |
| Choney::Ratio< Num, Den >::greater< rhs > | Operator> |
| Choney::Ratio< Num, Den >::greaterEqual< rhs > | Operator>= |
| Choney::Ratio< Num, Den >::less< rhs > | Operator< |
| Choney::Ratio< Num, Den >::lessEqual< rhs > | Operator<= |
| Choney::Ratio< Num, Den >::notEqual< rhs > | Operator!= |
| ►Choney::MtMapCommon< MtMapElem< Key_, Val_, List_ >, Key_, Val_, List_ > | |
| Choney::MtMapElem< Key_, Val_, List_ > | Map element in recursive list |
| Choney::Numeral< Real > | |
| Choney::optional< honey::MonoClock::honey::Duration > | |
| ►Choney::overload_< Funcs... > | |
| Choney::overload_< Func, Funcs... > | An overloaded visitor functor |
| Choney::PackagedTask< Result()> | |
| Choney::PackagedTask< void()> | |
| ►CCondition | |
| Choney::Condition | Method to synchronize threads. Condition variables eliminate the need for repeated polling to check the value of some data |
| ►CMonoClock | |
| Choney::MonoClock | System-wide monotonic clock. High-resolution and steady-rate time since application start, can't go backwards |
| ►CMutex | |
| ►Choney::Mutex | A thread lock where the lock is acquired by suspending thread execution until it becomes available |
| Choney::ConditionLock | Lock that is bound to a single condition. This is the common usage case of condition variables |
| Choney::TimedMutex | A mutex that has a timed try-lock |
| ►COp | |
| Choney::atomic::Op | Methods to perform thread-safe atomic read/write operations |
| ►CSystemClock | |
| Choney::SystemClock | System-wide real-time clock. Low-resolution time since Unix Epoch, can possibly go backwards if changed by OS |
| ►CThread | |
| Choney::Thread | Thread class |
| ►CfunctorTraits | |
| ►Choney::mt::funcTraits< Sig_ > | |
| Choney::Signal< Sig_ > | Multicast sender |
| Choney::mt::funcTraits< T > | Get function type traits |
| ►CSharedControlPtr | |
| Choney::SharedPtr< T > | Combined intrusive/non-intrusive smart pointer. Can reference and share any object automatically |
| Choney::WeakPtr< T > | Point to a shared object without holding a reference. The object is accessible through a lock, which prevents unexpected destruction |
| Choney::SharedPtr< PeriodicTask > | |
| Choney::SharedPtr< State > | |
| Choney::SharedPtr< thread::Pool > | |
| Choney::WeakPtr< honey::DepTask > | |
| ►CSharedObj_tag | |
| Choney::SharedObj< Subclass > | Reference-counted object for intrusive shared pointers |
| Choney::SharedObj< DepTask > | |
| Choney::SharedObj< Exception > | |
| Choney::SharedObj< Listener > | |
| Choney::SharedObj< Module > | |
| Choney::SharedObj< Object > | |
| Choney::SharedObj< PeriodicTask > | |
| Choney::SharedObj< Pool > | |
| Choney::SharedObj< Sink > | |
| Choney::SharedObj< State > | |
| ►CBase | |
| Choney::matrix::Block< MatrixP, s_rows, s_cols > | Matrix block view |
| ►Cvariant | |
| Choney::variant< Types > | Multi-typed value. A variant is a value of any type from a fixed set of bounded types, the active bounded type may be changed dynamically |
| Choney::Quat_< Real > | |
| ►Choney::RandomDist< Numeral< Int >::Real > | |
| Choney::Discrete_< Int > | Generate random integer variate between min and max inclusive with uniform (flat) distribution |
| ►Choney::SimplexNoiseCommon< SimplexNoise< Dim, Real >, Dim, Real > | |
| Choney::SimplexNoise< Dim, Real > | Generate smooth noise over space. Implementation of Perlin's "Simplex Noise" generator |
| ►Cstd::array< T > | STL class |
| ►Choney::ByteArray< 32 > | |
| Choney::hash::sval | 256-bit secure hash value |
| Choney::ByteArray< N > | Fixed array of N bytes |
| ►Cstd::basic_string< Char > | STL class |
| Choney::String | Unicode UTF-16 string class, wrapper around std::u16string |
| Cstd::common_type< honey::Duration< Rep, Period >, honey::Duration< Rep2, Period2 > > | Get common duration between two durations. The period of the resulting duration is the greatest common divisor |
| Cstd::common_type< honey::Ratio< Num, Den >, honey::Ratio< Num2, Den2 > > | Get common ratio between two ratios |
| ►Ctype | |
| ►Choney::matrix::priv::Storage< Subclass > | Chooses storage based on traits |
| Choney::vec::priv::Storage< Subclass > | Auto or dynamic vector storage |
| ►Cstd::exception | STL class |
| Choney::Exception | Base exception class. Exceptions inherited from this class provide debug info and can be thrown polymorphically (unlike standard c++ exceptions) |
| ►Cfalse_type | |
| Choney::mt::isSpecializationOf< T, Template > | Check if T is a specialization of Template |
| Cstd::hash< honey::bloom_filter::Key< T, Alloc > > | Adapter for std hasher |
| Cstd::hash< honey::SharedPtr< T > > | Allow class to be used as key in unordered containers |
| Cstd::hash< honey::UniquePtr< T, Fin > > | Allow class to be used as key in unordered containers |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_ostream< Char > | STL class |
| ►Cstd::basic_ostringstream< Char > | STL class |
| ►Cstd::ostringstream | STL class |
| Choney::Exception::MsgStream | Custom error message builder |
| Choney::Log::RecordStream | Builds a record |
| ►Ciostream | |
| Choney::ByteStream | An I/O stream into which objects may be serialized and subsequently deserialized |
| ►Cis_base_of | |
| Choney::mt::is_base_of< Base, Derived > | Version of std::is_base_of that removes reference qualifiers before testing |
| ►Cstringbuf | |
| ►Choney::ByteStreamBuf | A stream I/O buffer of bytes, to be passed into ByteStream |
| Choney::net::StreamBuf_< Alloc > | Automatically resizable buffer class based on ByteStreamBuf |
| ►Ctrue_type | |
| Choney::mt::isSpecializationOf< Template< Param... >, Template > | |
| Choney::mt::True<... > | Always returns true. Can be used to force a clause to be type dependent |
| Choney::mt::True_int<... > | Variant of True for integers |
| ►Cstd::unordered_map< K, T > | STL class |
| Choney::json::Config< ordered, Alloc >::ObjectOrdered | |
| ►Cstd::vector< T > | STL class |
| Choney::Bytes | String of bytes |
| Choney::Property< vector< T > > | Generic vector property |
| Choney::matrix::priv::StorageAutoArray< Real, honey::matrix::priv::StorageDense::s_size, honey::matrix::Option::getAlign< honey::matrix::priv::StorageDense::options >::value > | |
| ►Choney::vec::priv::StorageFieldsMixin< matrix::priv::Traits< Subclass >::Real, matrix::priv::Traits< Subclass >::dim, matrix::Option::getAlign< matrix::priv::Traits< Subclass >::options >::value > | |
| Choney::vec::priv::StorageFields< Subclass > | Automatic (stack-compatible) vector storage that allows direct access to dimension fields |
| ►Csize_ | |
| Choney::variant< Types >::size_ | Get number of bounded types at compile-time |
| ►Ctemplate Type_ | |
| Choney::variant< Types >::Type< id > | Get bounded type for id |
| Choney::atomic::SwapType< T * > | |
| ►Choney::vec::priv::Traits< 1, Real, Options, std::allocator< int8 > > | |
| Choney::matrix::priv::Traits< Vec< 1, Real, Options > > | |
| ►Choney::vec::priv::Traits< 2, Real, Options, std::allocator< int8 > > | |
| Choney::matrix::priv::Traits< Vec< 2, Real, Options > > | |
| ►Choney::vec::priv::Traits< 3, Real, Options, std::allocator< int8 > > | |
| Choney::matrix::priv::Traits< Vec< 3, Real, Options > > | |
| ►Choney::vec::priv::Traits< 4, Real, Options, std::allocator< int8 > > | |
| Choney::matrix::priv::Traits< Vec< 4, Real, Options > > | |
| ►Choney::vec::priv::Traits< Dim, Real, Options, Alloc > | |
| Choney::matrix::priv::Traits< Vec< Dim, Real, Options, Alloc > > | |
| ►Choney::matrix::priv::Traits< Vec< Dim, Real, Options > > | |
| Choney::matrix::priv::Traits< VecSwizCon< Dim, Real, Options > > | |
| Choney::matrix::priv::Traits< VecSwizRef< Dim, Real, Options > > | |
| Choney::TreeNode< honey::ComRegistry::Type * > | |
| ►CValue | |
| Choney::mt::conditional_int< b, t, f > | Variant of std::conditional for integers, stores result in value |
| Choney::mt::conditional_int< true, t, f > | |
| Choney::mt::gcd< 0, b > | |
| Choney::mt::gcd< a, 0 > | |
| Choney::mt::log2Floor< x > | Calc log base 2 of unsigned integer, rounded down to nearest integer. Returns -1 if x is zero |
| Choney::mt::log2Floor< 0 > | |
| Choney::mt::max< val > | |
| Choney::mt::max< val, vals... > | |
| Choney::mt::min< val > | |
| Choney::mt::min< val, vals... > | |
| Choney::Vec< dim, Real >< dim, Real > | |
1.8.10
