MayaFlux::Yantra Namespace Reference

Namespaces
namespace	detail
namespace	Granular
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 controlling how a compute operation executes. 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	GpuAnalyzer
	Concrete UniversalAnalyzer that dispatches entirely via a GpuExecutionContext. More...
struct	GpuBufferBinding
	Declares a single storage buffer the shader expects. More...
struct	GpuChannelResult
	Erased output of a GPU dispatch: reconstructed float data plus any raw auxiliary outputs keyed by binding index. More...
class	GpuDispatchCore
	Non-template base that owns all type-independent GPU dispatch logic. More...
class	GpuExecutionContext
	Type-parameterised shell over GpuDispatchCore. More...
class	GpuExtractor
	Concrete UniversalExtractor that dispatches entirely via a GpuExecutionContext. More...
class	GpuResourceManager
	Encapsulates all Vulkan resource lifecycle behind Portal facades. More...
struct	GpuResourceManagerImpl
struct	GpuShaderConfig
	Plain-data description of the compute shader to dispatch. More...
class	GpuSorter
	Concrete UniversalSorter that dispatches entirely via a GpuExecutionContext. More...
class	GpuTransformer
	Concrete UniversalTransformer that dispatches entirely via a GpuExecutionContext. 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...
class	ShaderExecutionContext
	Concrete GpuExecutionContext for a single fixed shader with fixed bindings. 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...
class	TextureExecutionContext
	GpuExecutionContext specialisation for image-only compute shaders. 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...
struct	VulkanBufferSlot

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.

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

Enumerations
enum class	AnalysisGranularity : uint8_t { RAW_VALUES , ATTRIBUTED_SEGMENTS , ORGANIZED_GROUPS , SUMMARY_STATISTICS }
	Output granularity control for analysis results. 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	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	ConvolutionOperation : uint8_t {   DIRECT_CONVOLUTION , CROSS_CORRELATION , MATCHED_FILTER , DECONVOLUTION ,   AUTO_CORRELATION }
	Specific convolution operations supported. More...
enum class	EnergyLevel : uint8_t {   SILENT , QUIET , MODERATE , LOUD ,   PEAK }
	Qualitative classification of energy values. More...
enum class	EnergyMethod : uint8_t {   RMS , PEAK , SPECTRAL , ZERO_CROSSING ,   HARMONIC , POWER , DYNAMIC_RANGE }
	Supported energy computation methods. More...
enum class	ExecutionMode : uint8_t {   SYNC , ASYNC , PARALLEL , CHAINED ,   DEPENDENCY }
	Execution paradigms for operations. 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	ExtractionScope : uint8_t { FULL_DATA , TARGETED_REGIONS , FILTERED_CONTENT , SAMPLED_DATA }
	Scope control for extraction operations. 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	MathematicalOperation : uint8_t {   GAIN , OFFSET , POWER , LOGARITHMIC ,   EXPONENTIAL , TRIGONOMETRIC , QUANTIZE , NORMALIZE ,   POLYNOMIAL }
	Specific mathematical operations supported. More...
enum class	OperationType : uint8_t {   ANALYZER , SORTER , EXTRACTOR , TRANSFORMER ,   CUSTOM }
	Operation categories for organization and discovery. More...
enum class	SortingGranularity : uint8_t { RAW_DATA , ATTRIBUTED_INDICES , ORGANIZED_GROUPS , DETAILED_ANALYSIS }
	Output granularity control for sorting results. 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	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	SpectralOperation : uint8_t {   FREQUENCY_SHIFT , PITCH_SHIFT , SPECTRAL_FILTER , HARMONIC_ENHANCE ,   SPECTRAL_GATE }
	Spectral operations supported by SpectralTransformer. More...
enum class	StatisticalLevel : uint8_t {   EXTREME_LOW , LOW , NORMAL , HIGH ,   EXTREME_HIGH , OUTLIER }
	Qualitative classification of statistical 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	TemporalOperation : uint8_t {   TIME_REVERSE , TIME_STRETCH , DELAY , FADE_IN_OUT ,   SLICE , INTERPOLATE }
	Specific temporal operations supported. 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...
enum class	TransformationStrategy : uint8_t {   IN_PLACE , BUFFERED , STREAMING , INCREMENTAL ,   LAZY , CHUNKED , PARALLEL , RECURSIVE }
	Transformation execution strategies. 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...

Functions
template<typename OperationType >
void	apply_context_parameters (std::shared_ptr< OperationType > operation, const ExecutionContext &ctx)
	Applies context parameters to an operation.
template<ComputeData T>
std::vector< Datum< T > >	as_io_batch (const std::vector< T > &inputs)
	Convert a vector of raw values into a vector of Datum wrappers.
template<ComputeData T>
std::vector< Datum< T > >	as_io_batch (std::vector< T > &&inputs)
	Convert a vector of raw values into a vector of Datum wrappers via move.
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 T >
auto	create_multi_key_comparator (const std::vector< SortKey > &keys)
	Creates a multi-key comparator for complex sorting.
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.
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.
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_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_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_onsets (const std::vector< std::span< const double > > &channels, double threshold, uint32_t region_size, uint32_t fft_window_size, uint32_t hop_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_overlapping_windows (const std::vector< std::span< const double > > &channels, uint32_t window_size, double overlap)
std::vector< std::vector< double > >	extract_peaks (const std::vector< std::span< const double > > &channels, double threshold, double min_distance, uint32_t region_size)
MAYAFLUX_API double	extract_scalar_energy (const EnergyAnalysis &analysis, const std::string &qualifier)
	Extract a named scalar from an EnergyAnalysis result.
MAYAFLUX_API double	extract_scalar_statistics (const StatisticalAnalysis &analysis, const std::string &qualifier)
	Extract a named scalar from a StatisticalAnalysis result.
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_zero_crossings (const std::vector< std::span< const double > > &channels, double threshold, double min_distance, uint32_t region_size)
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.
std::shared_ptr< OperationRegistry >	get_operation_registry ()
	Global operation registry accessor Similar to how Engine provides global access to core systems.
template<typename T >
double	get_temporal_position (const T &item)
	Helper function to get temporal position from various types Used by TemporalSortable concept.
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_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)
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.
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_region_group (const Kakshya::RegionGroup &group, const std::shared_ptr< Kakshya::SignalSourceContainer > &container=nullptr)
	Infer structure from RegionGroup.
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.
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.
template<typename Executor , ComputeData DataType>
auto	make_fluent (std::shared_ptr< Executor > executor, DataType &&data)
	Construct a FluentExecutor from raw data with type deduction (convenience entry point)
template<typename Executor , ComputeData DataType>
auto	make_fluent (std::shared_ptr< Executor > executor, Datum< DataType > &&datum)
	Construct a FluentExecutor from a Datum with type deduction.
template<ComputeData InputType = std::vector<Kakshya::DataVariant>, ComputeData OutputType = InputType>
std::shared_ptr< ShaderExecutionContext< InputType, OutputType > >	make_shader_executor (GpuShaderConfig config, std::vector< GpuBufferBinding > bindings, std::string name="ShaderExecutionContext")
	Convenience factory for ShaderExecutionContext.
template<ComputeData T>
T	sort_compute_data (const T &data, SortingDirection direction=SortingDirection::ASCENDING)
	Convenience function with default algorithm.
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_extract (const T &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - returns sorted copy.
template<ComputeData T>
void	sort_compute_data_inplace (Datum< T > &data, SortingDirection direction, SortingAlgorithm algorithm)
	Universal sort function - handles extraction/conversion internally.
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_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>
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>
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, 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, 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)

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