MayaFlux::Yantra Namespace Reference

Namespaces
namespace	PipelineFactory
	Factory functions for common pipeline configurations.

Classes
struct	AutoRegisterOperation
	Automatic registration helper Operations can use this in their implementation files for auto-registration. More...
struct	ChannelEnergy
struct	ChannelStatistics
	Statistical results for a single data channel. More...
class	ComputationGrammar
	Core grammar system for rule-based computation in Maya Flux. More...
class	ComputationPipeline
	Pipeline that uses grammar rules for operation composition. More...
class	ComputeMatrix
	Local execution orchestrator for computational operations. More...
class	ComputeOperation
	Base interface for all computational operations in the processing pipeline. More...
class	ConvolutionTransformer
	Concrete transformer for convolution-based operations. More...
struct	DataStructureInfo
	Metadata about data structure for reconstruction. More...
struct	Datum
	Input/Output container for computation pipeline data flow with structure preservation. More...
struct	EnergyAnalysis
	Analysis result structure for energy analysis. More...
class	EnergyAnalyzer
	High-performance energy analyzer with zero-copy processing. More...
struct	ExecutionContext
	Context information for operation execution. More...
struct	extraction_traits_d
	Traits to determine how to extract data from various types. More...
struct	extraction_traits_d< Eigen::MatrixXd >
	Specialization of extraction_traits_d for Eigen::MatrixXd. More...
struct	extraction_traits_d< Kakshya::DataVariant >
	Specialization of extraction_traits_d for single Kakshya::DataVariant. More...
struct	extraction_traits_d< Kakshya::Region >
	Specialization of extraction_traits_d for Kakshya::Region. More...
struct	extraction_traits_d< Kakshya::RegionGroup >
	Specialization of extraction_traits_d for Kakshya::RegionGroup. More...
struct	extraction_traits_d< std::shared_ptr< Kakshya::SignalSourceContainer > >
	Specialization of extraction_traits_d for shared_ptr to Kakshya::SignalSourceContainer. More...
struct	extraction_traits_d< std::vector< Kakshya::DataVariant > >
	Specialization of extraction_traits_d for vector of Kakshya::DataVariant. More...
struct	extraction_traits_d< std::vector< Kakshya::RegionSegment > >
	Specialization of extraction_traits_d for vector of Kakshya::RegionSegment. More...
struct	extraction_traits_d< T >
	Specialization of extraction_traits_d for Eigen matrices with double scalar type. More...
class	FeatureExtractor
	Analyzer-guided feature extractor with enum-based configuration. More...
class	FluentExecutor
	Fluent interface for chaining operations on any executor. More...
class	GrammarAwareComputeMatrix
	ComputeMatrix extension that integrates grammar-based operation selection. More...
struct	is_eigen_matrix
struct	is_eigen_matrix< Eigen::Matrix< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct	is_IO
	Helper to detect if a type is an Datum. More...
struct	is_IO< Datum< T > >
	Specialization for Datum types. More...
class	MathematicalTransformer
	Concrete transformer for mathematical operations. More...
class	OperationHelper
	Universal data conversion helper for all Yantra operations. More...
class	OperationPool
	Thread-safe pool for managing named operation instances. More...
class	OperationRegistry
	Manages operation type registration, discovery, and factory creation. More...
class	OpUnit
	Abstract base class for operation units in recursive processing graphs. More...
struct	PooledOperationInfo
	Metadata about a pooled operation. More...
struct	SortKey
	Multi-dimensional sort key specification for complex sorting. More...
class	SpectralTransformer
	Concrete transformer for frequency-domain operations. More...
class	StandardSorter
	Concrete implementation for standard comparison-based sorting. More...
struct	StatisticalAnalysis
	Analysis result structure for statistical analysis. More...
class	StatisticalAnalyzer
	High-performance statistical analyzer with zero-copy processing. More...
class	TemporalTransformer
	Concrete transformer for time-domain operations. More...
struct	TransformationKey
	Multi-dimensional transformation key specification for complex transformations. More...
class	UniversalAnalyzer
	Template-flexible analyzer base with instance-defined I/O types. More...
class	UniversalExtractor
	Template-flexible extractor base with instance-defined I/O types. More...
class	UniversalMatcher
	Type-agnostic pattern matching for computation rules. More...
class	UniversalSorter
	Template-flexible sorter base with instance-defined I/O types. More...
class	UniversalTransformer
	Template-flexible transformer base with instance-defined I/O types. More...

Concepts
concept	OperationReadyData
	Concept to constrain types suitable for operation units.
concept	VariantVector
concept	ComputeData
	Universal concept for types that can be used as data in compute operations.
concept	RegionLike
concept	MultiVariant
concept	RequiresContainer
concept	SingleVariant
	A SingleVariant is either a single DataVariant, an Eigen vector type, or any type constructible from DataVariant but not a vector of DataVariants, not a shared_ptr to SignalSourceContainer, and not RegionLike.
concept	EigenMatrixLike
	Concept for Eigen matrix types with double scalar.
concept	ExecutorConcept
	Defines requirements for executor types that can be used with FluentExecutor.

Typedefs
using	StandardEnergyAnalyzer = EnergyAnalyzer< std::vector< Kakshya::DataVariant >, Eigen::MatrixXd >
	Standard energy analyzer: DataVariant -> MatrixXd.
using	ContainerEnergyAnalyzer = EnergyAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, Eigen::MatrixXd >
	Container energy analyzer: SignalContainer -> MatrixXd.
using	RegionEnergyAnalyzer = EnergyAnalyzer< Kakshya::Region, Eigen::MatrixXd >
	Region energy analyzer: Region -> MatrixXd.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	RawEnergyAnalyzer = EnergyAnalyzer< InputType, std::vector< std::vector< double > > >
	Raw energy analyzer: produces double vectors.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VariantEnergyAnalyzer = EnergyAnalyzer< InputType, std::vector< Kakshya::DataVariant > >
	Variant energy analyzer: produces DataVariant output.
using	StandardStatisticalAnalyzer = StatisticalAnalyzer< std::vector< Kakshya::DataVariant >, Eigen::MatrixXd >
	Standard statistical analyzer: DataVariant -> MatrixXd.
using	ContainerStatisticalAnalyzer = StatisticalAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, Eigen::MatrixXd >
	Container statistical analyzer: SignalContainer -> MatrixXd.
using	RegionStatisticalAnalyzer = StatisticalAnalyzer< Kakshya::Region, Eigen::VectorXd >
	Region statistical analyzer: Region -> MatrixXd.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	RawStatisticalAnalyzer = StatisticalAnalyzer< InputType, std::vector< std::vector< double > > >
	Raw statistical analyzer: produces double vectors.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VariantStatisticalAnalyzer = StatisticalAnalyzer< InputType, Kakshya::DataVariant >
	Variant statistical analyzer: produces DataVariant output.
template<ComputeData OutputType = std::vector<Kakshya::DataVariant>>
using	DataAnalyzer = UniversalAnalyzer< std::vector< Kakshya::DataVariant >, OutputType >
	Analyzer that takes DataVariant and produces DataVariant.
template<ComputeData OutputType = std::shared_ptr<Kakshya::SignalSourceContainer>>
using	ContainerAnalyzer = UniversalAnalyzer< std::shared_ptr< Kakshya::SignalSourceContainer >, OutputType >
	Analyzer for signal container processing.
template<ComputeData OutputType = Kakshya::Region>
using	RegionAnalyzer = UniversalAnalyzer< Kakshya::Region, OutputType >
	Analyzer for region-based analysis.
template<ComputeData OutputType = Kakshya::RegionGroup>
using	RegionGroupAnalyzer = UniversalAnalyzer< Kakshya::RegionGroup, OutputType >
	Analyzer for region group processing.
template<ComputeData OutputType = std::vector<Kakshya::RegionSegment>>
using	SegmentAnalyzer = UniversalAnalyzer< std::vector< Kakshya::RegionSegment >, OutputType >
	Analyzer for segment processing.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	MatrixAnalyzer = UniversalAnalyzer< InputType, Eigen::MatrixXd >
	Analyzer that produces Eigen matrices.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VectorAnalyzer = UniversalAnalyzer< InputType, Eigen::VectorXd >
	Analyzer that produces Eigen vectors.
using	DataOperation = ComputeOperation< Kakshya::DataVariant >
using	ContainerOperation = ComputeOperation< std::shared_ptr< Kakshya::SignalSourceContainer > >
using	RegionOperation = ComputeOperation< Kakshya::Region >
using	RegionGroupOperation = ComputeOperation< Kakshya::RegionGroup >
using	SegmentOperation = ComputeOperation< std::vector< Kakshya::RegionSegment > >
using	DataIO = Datum< std::vector< Kakshya::DataVariant > >
	IO for universal data variant.
using	ContainerIO = Datum< std::shared_ptr< Kakshya::SignalSourceContainer > >
	IO for signal containers.
using	RegionIO = Datum< Kakshya::Region >
	IO for single regions.
using	RegionGroupIO = Datum< Kakshya::RegionGroup >
	IO for region groups.
using	SegmentIO = Datum< std::vector< Kakshya::RegionSegment > >
	IO for region segments.
template<typename T >
using	enable_if_single_variant_t = std::enable_if_t< SingleVariant< T > >
template<typename T >
using	enable_if_multi_variant_t = std::enable_if_t< extraction_traits_d< T >::is_multi_variant >
template<typename T >
using	enable_if_region_like_t = std::enable_if_t< extraction_traits_d< T >::is_region_like >
template<typename T >
using	enable_if_multi_no_container_t = std::enable_if_t< extraction_traits_d< T >::is_multi_variant &&!extraction_traits_d< T >::requires_container >
template<typename T >
using	enable_if_multi_with_container_t = std::enable_if_t< extraction_traits_d< T >::is_multi_variant &&extraction_traits_d< T >::requires_container >
template<typename T >
using	enable_if_eigen_matrix_t = std::enable_if_t< is_eigen_matrix_v< T > &&std::is_same_v< typename T::Scalar, double > >
template<typename T >
using	extraction_result_t = typename extraction_traits_d< T >::result_type
template<typename T >
using	variant_result_t = typename extraction_traits_d< T >::variant_result_type
using	StandardFeatureExtractor = FeatureExtractor< std::vector< Kakshya::DataVariant >, std::vector< std::vector< double > > >
	Standard feature extractor: vector of [DataVariant -> vector<double>].
using	MatrixFeatureExtractor = FeatureExtractor< std::vector< Kakshya::DataVariant >, Eigen::MatrixXd >
	Eigen Matrix feature extractor: DataVariant -> Matrixxd.
using	ContainerFeatureExtractor = FeatureExtractor< std::shared_ptr< Kakshya::SignalSourceContainer >, std::vector< std::vector< double > > >
	Container feature extractor: SignalContainer -> multi vector<double>
using	RegionFeatureExtractor = FeatureExtractor< Kakshya::Region, std::vector< std::vector< double > > >
	Region feature extractor: Region -> multi vector<double>
using	VariantFeatureExtractor = FeatureExtractor< std::vector< Kakshya::DataVariant >, std::vector< Kakshya::DataVariant > >
	Variant feature extractor: DataVariant -> DataVariant.
template<ComputeData OutputType = Kakshya::DataVariant>
using	DataExtractor = UniversalExtractor< std::vector< Kakshya::DataVariant >, OutputType >
	Extractor that takes DataVariant and produces any ComputeData type.
template<ComputeData OutputType = std::shared_ptr<Kakshya::SignalSourceContainer>>
using	ContainerExtractor = UniversalExtractor< std::shared_ptr< Kakshya::SignalSourceContainer >, OutputType >
	Extractor for signal container processing.
template<ComputeData OutputType = Kakshya::Region>
using	RegionExtractor = UniversalExtractor< Kakshya::Region, OutputType >
	Extractor for region-based extraction.
template<ComputeData OutputType = Kakshya::RegionGroup>
using	RegionGroupExtractor = UniversalExtractor< Kakshya::RegionGroup, OutputType >
	Extractor for region group processing.
template<ComputeData OutputType = std::vector<Kakshya::RegionSegment>>
using	SegmentExtractor = UniversalExtractor< std::vector< Kakshya::RegionSegment >, OutputType >
	Extractor for segment processing.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	MatrixExtractor = UniversalExtractor< InputType, Eigen::MatrixXd >
	Extractor that produces Eigen matrices.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VectorExtractor = UniversalExtractor< InputType, Eigen::VectorXd >
	Extractor that produces Eigen vectors.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	NumericExtractor = UniversalExtractor< InputType, std::vector< double > >
	Extractor that produces numeric vectors.
using	OpererationHookCallback = std::function< void(std::any &)>
	Callback type for pre/post operation hooks.
using	ReconstructionCallback = std::function< std::any(std::vector< std::vector< double > > &, std::any &)>
	Callback type for custom reconstruction logic.
using	SortingDirection = Kinesis::Discrete::SortingDirection
using	SortingAlgorithm = Kinesis::Discrete::SortingAlgorithm
using	StandardDataSorter = StandardSorter< std::vector< Kakshya::DataVariant > >
	Standard sorter for DataVariant.
template<typename T >
using	StandardVectorSorter = StandardSorter< std::vector< std::vector< T > > >
	Standard sorter for numeric vectors (DataVariant contains these)
using	StandardRegionGroupSorter = StandardSorter< Kakshya::RegionGroup >
	Standard sorter for region groups (proper way to handle multiple regions)
using	StandardSegmentSorter = StandardSorter< std::vector< Kakshya::RegionSegment > >
	Standard sorter for region segments.
using	StandardMatrixSorter = StandardSorter< Eigen::MatrixXd >
	Standard sorter for Eigen matrices.
using	StandardVectorSorterEigen = StandardSorter< Eigen::VectorXd >
	Standard sorter for Eigen vectors.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	StandardIndexSorter = StandardSorter< InputType, std::vector< std::vector< size_t > > >
	Standard sorter that generates indices.
template<ComputeData OutputType = std::vector<Kakshya::DataVariant>>
using	DataSorter = UniversalSorter< std::vector< Kakshya::DataVariant >, OutputType >
	Sorter that takes DataVariant and produces DataVariant.
template<ComputeData OutputType = std::shared_ptr<Kakshya::SignalSourceContainer>>
using	ContainerSorter = UniversalSorter< std::shared_ptr< Kakshya::SignalSourceContainer >, OutputType >
	Sorter for signal container processing.
template<ComputeData OutputType = Kakshya::Region>
using	RegionSorter = UniversalSorter< Kakshya::Region, OutputType >
	Sorter for region-based sorting.
template<ComputeData OutputType = Kakshya::RegionGroup>
using	RegionGroupSorter = UniversalSorter< Kakshya::RegionGroup, OutputType >
	Sorter for region group processing.
template<ComputeData OutputType = std::vector<Kakshya::RegionSegment>>
using	SegmentSorter = UniversalSorter< std::vector< Kakshya::RegionSegment >, OutputType >
	Sorter for segment processing.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	MatrixSorter = UniversalSorter< InputType, Eigen::MatrixXd >
	Sorter that produces Eigen matrices.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	VectorSorter = UniversalSorter< InputType, Eigen::VectorXd >
	Sorter that produces Eigen vectors.
template<typename T , ComputeData OutputType = std::vector<std::vector<T>>>
using	VectorContainerSorter = UniversalSorter< std::vector< std::vector< T > >, OutputType >
	Sorter for vector containers.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>>
using	IndexSorter = UniversalSorter< InputType, std::vector< std::vector< size_t > > >
	Sorter for indices generation.

Enumerations
enum class	EnergyMethod : uint8_t {   RMS , PEAK , SPECTRAL , ZERO_CROSSING ,   HARMONIC , POWER , DYNAMIC_RANGE }
	Supported energy computation methods. More...
enum class	EnergyLevel : uint8_t {   SILENT , QUIET , MODERATE , LOUD ,   PEAK }
	Qualitative classification of energy values. More...
enum class	StatisticalMethod : uint8_t {   MEAN , VARIANCE , STD_DEV , SKEWNESS ,   KURTOSIS , MIN , MAX , MEDIAN ,   RANGE , PERCENTILE , MODE , MAD ,   CV , SUM , COUNT , RMS ,   ENTROPY , ZSCORE }
	Supported statistical computation methods. More...
enum class	StatisticalLevel : uint8_t {   EXTREME_LOW , LOW , NORMAL , HIGH ,   EXTREME_HIGH , OUTLIER }
	Qualitative classification of statistical values. More...
enum class	AnalysisType : uint8_t {   STATISTICAL , SPECTRAL , TEMPORAL , SPATIAL ,   FEATURE , PATTERN , TRANSFORM , CUSTOM }
	Categories of analysis operations for discovery and organization. More...
enum class	AnalysisGranularity : uint8_t { RAW_VALUES , ATTRIBUTED_SEGMENTS , ORGANIZED_GROUPS , SUMMARY_STATISTICS }
	Output granularity control for analysis results. More...
enum class	ExecutionPolicy : uint8_t { CONSERVATIVE , BALANCED , AGGRESSIVE }
	Policy for execution strategy selection. More...
enum class	ExtractionMethod : uint8_t {   HIGH_ENERGY_DATA , PEAK_DATA , OUTLIER_DATA , HIGH_SPECTRAL_DATA ,   ABOVE_MEAN_DATA , OVERLAPPING_WINDOWS , ZERO_CROSSING_DATA , SILENCE_DATA ,   ONSET_DATA }
	Supported extraction methods for FeatureExtractor. More...
enum class	ExtractionType : uint8_t {   DIRECT , REGION_BASED , FEATURE_GUIDED , PATTERN_BASED ,   TRANSFORM , RECURSIVE , CUSTOM }
	Categories of extraction operations for discovery and organization. More...
enum class	ExtractionScope : uint8_t { FULL_DATA , TARGETED_REGIONS , FILTERED_CONTENT , SAMPLED_DATA }
	Scope control for extraction operations. More...
enum class	OperationType : uint8_t {   ANALYZER , SORTER , EXTRACTOR , TRANSFORMER ,   CUSTOM }
	Operation categories for organization and discovery. More...
enum class	ExecutionMode : uint8_t {   SYNC , ASYNC , PARALLEL , CHAINED ,   DEPENDENCY }
	Execution paradigms for operations. More...
enum class	ComputationContext : uint8_t {   TEMPORAL , SPECTRAL , SPATIAL , SEMANTIC ,   STRUCTURAL , LOGICAL , PARAMETRIC , REACTIVE ,   CONCURRENT , RECURSIVE , CONVOLUTION }
	Defines the computational contexts in which rules can be applied. More...
enum class	SortingType : uint8_t {   STANDARD , ALGORITHMIC , PATTERN_BASED , TEMPORAL ,   SPATIAL , PREDICTIVE , CROSS_MODAL , RECURSIVE ,   CUSTOM }
	Categories of sorting operations for discovery and organization. More...
enum class	SortingStrategy : uint8_t {   IN_PLACE , COPY_SORT , INDEX_ONLY , PARTIAL_SORT ,   LAZY_SORT , CHUNKED_SORT , PARALLEL_SORT }
	Sorting execution strategies. More...
enum class	SortingGranularity : uint8_t { RAW_DATA , ATTRIBUTED_INDICES , ORGANIZED_GROUPS , DETAILED_ANALYSIS }
	Output granularity control for sorting results. More...
enum class	ConvolutionOperation : uint8_t {   DIRECT_CONVOLUTION , CROSS_CORRELATION , MATCHED_FILTER , DECONVOLUTION ,   AUTO_CORRELATION }
	Specific convolution operations supported. More...
enum class	MathematicalOperation : uint8_t {   GAIN , OFFSET , POWER , LOGARITHMIC ,   EXPONENTIAL , TRIGONOMETRIC , QUANTIZE , NORMALIZE ,   POLYNOMIAL }
	Specific mathematical operations supported. More...
enum class	SpectralOperation : uint8_t {   FREQUENCY_SHIFT , PITCH_SHIFT , SPECTRAL_FILTER , HARMONIC_ENHANCE ,   SPECTRAL_GATE }
	Spectral operations supported by SpectralTransformer. More...
enum class	TemporalOperation : uint8_t {   TIME_REVERSE , TIME_STRETCH , DELAY , FADE_IN_OUT ,   SLICE , INTERPOLATE }
	Specific temporal operations supported. More...
enum class	TransformationType : uint8_t {   TEMPORAL , SPECTRAL , MATHEMATICAL , CROSS_MODAL ,   GENERATIVE , SPATIAL , PATTERN_BASED , RECURSIVE ,   GRANULAR , CONVOLUTION , CUSTOM }
	Categories of transformation operations for discovery and organization. More...
enum class	TransformationStrategy : uint8_t {   IN_PLACE , BUFFERED , STREAMING , INCREMENTAL ,   LAZY , CHUNKED , PARALLEL , RECURSIVE }
	Transformation execution strategies. More...
enum class	TransformationQuality : uint8_t {   DRAFT , STANDARD , HIGH_QUALITY , REFERENCE ,   ADAPTIVE }
	Quality vs performance trade-off control. More...
enum class	TransformationScope : uint8_t { FULL_DATA , TARGETED_REGIONS , SELECTIVE_BANDS , CONDITIONAL }
	Scope control for transformation operations. More...

Functions
std::shared_ptr< OperationRegistry >	get_operation_registry ()
	Global operation registry accessor Similar to how Engine provides global access to core systems.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_data_variant (const Kakshya::DataVariant &data)
	Infer structure from DataVariant.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_data_variant_vector (const std::vector< Kakshya::DataVariant > &data)
	Infer structure from vector of DataVariants (NEW)
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_container (const std::shared_ptr< Kakshya::SignalSourceContainer > &container)
	Infer structure from SignalSourceContainer.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_region (const Kakshya::Region &region, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from Region (placeholder since regions are markers)
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_segments (const std::vector< Kakshya::RegionSegment > &segments, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from RegionSegments.
std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_region_group (const Kakshya::RegionGroup &group, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from RegionGroup.
template<typename EigenType >
static std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_from_eigen (const EigenType &eigen_data)
	Infer structure from Eigen matrix/vector.
template<typename T >
static std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_generic_structure (const T &data)
	Generic structure inference for unknown types.
template<ComputeData T>
static std::pair< std::vector< Kakshya::DataDimension >, Kakshya::DataModality >	infer_structure (const T &data, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer dimensions and modality from any ComputeData type.
std::vector< std::vector< double > >	extract_high_energy (const std::vector< std::span< const double > > &channels, double energy_threshold, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_peaks (const std::vector< std::span< const double > > &channels, double threshold, double min_distance, uint32_t region_size)
std::vector< std::vector< double > >	extract_outliers (const std::vector< std::span< const double > > &channels, double std_dev_threshold, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_high_spectral (const std::vector< std::span< const double > > &channels, double spectral_threshold, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_above_mean (const std::vector< std::span< const double > > &channels, double mean_multiplier, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_overlapping_windows (const std::vector< std::span< const double > > &channels, uint32_t window_size, double overlap)
std::vector< std::vector< double > >	extract_zero_crossings (const std::vector< std::span< const double > > &channels, double threshold, double min_distance, uint32_t region_size)
std::vector< std::vector< double > >	extract_silence (const std::vector< std::span< const double > > &channels, double silence_threshold, uint32_t min_duration, uint32_t window_size, uint32_t hop_size)
std::vector< std::vector< double > >	extract_onsets (const std::vector< std::span< const double > > &channels, double threshold, uint32_t region_size, uint32_t fft_window_size, uint32_t hop_size)
template<typename OperationType , typename... Args>
std::shared_ptr< OperationType >	create_configured_operation (const std::unordered_map< std::string, std::any > &parameters, Args &&... args)
	Creates an operation instance with parameters using safe_any_cast system.
template<typename OperationType >
void	apply_context_parameters (std::shared_ptr< OperationType > operation, const ExecutionContext &ctx)
	Applies context parameters to an operation.
template<typename Executor , ComputeData DataType>
auto	make_fluent (std::shared_ptr< Executor > executor, DataType &&data)
	Helper to create FluentExecutor with type deduction.
template<ComputeData T>
void	sort_compute_data_inplace (Datum< T > &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - handles extraction/conversion internally.
template<ComputeData T>
T	sort_compute_data_extract (const T &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - returns sorted copy.
template<typename T >
T	sort_compute_data_extract (const Datum< T > &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - returns sorted copy.
template<ComputeData T>
T	sort_compute_data (const T &data, SortingDirection direction=SortingDirection::ASCENDING)
	Convenience function with default algorithm.
template<ComputeData T>
std::vector< std::vector< size_t > >	generate_compute_data_indices (const Datum< T > &data, SortingDirection direction)
	Generate sort indices for any ComputeData type.
template<typename T >
auto	create_multi_key_comparator (const std::vector< SortKey > &keys)
	Creates a multi-key comparator for complex sorting.
template<typename T >
double	get_temporal_position (const T &item)
	Helper function to get temporal position from various types Used by TemporalSortable concept.
template<typename T >
SortKey	create_universal_sort_key (const std::string &name, SortingDirection direction=SortingDirection::ASCENDING)
	Create universal sort key extractor for common data types.
Eigen::MatrixXd	create_rotation_matrix (double angle, uint32_t axis, uint32_t dimensions)
Eigen::MatrixXd	create_scaling_matrix (const std::vector< double > &scale_factors)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, DataType>
DataType	transform_regions (DataType &input, const std::shared_ptr< Kakshya::SignalSourceContainer > &container, const std::vector< Kakshya::Region > &regions, TransformFunc transform_func)
	Region-selective transformation using container-based extraction (IN-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, DataType>
DataType	transform_regions (DataType &input, const std::shared_ptr< Kakshya::SignalSourceContainer > &container, const std::vector< Kakshya::Region > &regions, TransformFunc transform_func, std::vector< std::vector< double > > &working_buffer)
	Region-selective transformation using container-based extraction (OUT-OF-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_by_energy (DataType &input, double energy_threshold, TransformFunc transform_func, uint32_t window_size=1024, uint32_t hop_size=512)
	Energy-based transformation using existing EnergyAnalyzer (IN-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_by_energy (DataType &input, double energy_threshold, TransformFunc transform_func, uint32_t window_size, uint32_t hop_size, std::vector< std::vector< double > > &working_buffer)
	Energy-based transformation using existing EnergyAnalyzer (OUT-OF-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_outliers (DataType &input, double std_dev_threshold, TransformFunc transform_func)
	Statistical outlier transformation using existing StatisticalAnalyzer (IN-PLACE)
template<OperationReadyData DataType, typename TransformFunc > requires std::invocable<TransformFunc, double>
DataType	transform_outliers (DataType &input, double std_dev_threshold, TransformFunc transform_func, std::vector< std::vector< double > > &working_buffer)
	Statistical outlier transformation using existing StatisticalAnalyzer (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_crossfade_regions (DataType &input, const std::vector< std::pair< Kakshya::Region, Kakshya::Region > > &fade_regions, uint32_t fade_duration)
	Cross-fade between regions with smooth transitions (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_crossfade_regions (DataType &input, const std::vector< std::pair< Kakshya::Region, Kakshya::Region > > &fade_regions, uint32_t fade_duration, std::vector< std::vector< double > > &working_buffer)
	Cross-fade between regions with smooth transitions (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix (DataType &input, const Eigen::MatrixXd &transformation_matrix)
	Matrix transformation using existing infrastructure (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix (DataType &input, const Eigen::MatrixXd &transformation_matrix, std::vector< std::vector< double > > &working_buffer)
	Matrix transformation using existing infrastructure (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix_multichannel (DataType &input, const Eigen::MatrixXd &transformation_matrix, uint32_t num_channels)
	Multi-channel matrix transformation with error handling (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_matrix_multichannel (DataType &input, const Eigen::MatrixXd &transformation_matrix, uint32_t num_channels, std::vector< std::vector< double > > &working_buffer)
	Multi-channel matrix transformation with error handling (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_channel_operation (DataType &input, uint32_t num_channels, bool interleave)
	Channel operations using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_channel_operation (DataType &input, uint32_t num_channels, bool interleave, std::vector< std::vector< double > > &working_buffer)
	Channel operations using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
std::vector< Kakshya::Region >	detect_regions_by_energy (const DataType &input, double energy_threshold, uint32_t min_region_size, uint32_t window_size, uint32_t hop_size)
	Detect regions based on energy threshold using existing EnergyAnalyzer.

Variables
template<typename T >
constexpr bool	is_eigen_matrix_v = is_eigen_matrix<T>::value