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	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	IO
	Input/Output container for computation pipeline data flow with structure preservation. 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 IO. More...
struct	is_IO< IO< T > >
	Specialization for IO 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 = IO< std::vector< Kakshya::DataVariant > >
	IO for universal data variant.
using	ContainerIO = IO< std::shared_ptr< Kakshya::SignalSourceContainer > >
	IO for signal containers.
using	RegionIO = IO< Kakshya::Region >
	IO for single regions.
using	RegionGroupIO = IO< Kakshya::RegionGroup >
	IO for region groups.
using	SegmentIO = IO< 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	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	SortingAlgorithm : uint8_t {   STANDARD , STABLE , PARTIAL , NTH_ELEMENT ,   HEAP , PARALLEL , RADIX , COUNTING ,   BUCKET , MERGE_EXTERNAL , QUICK_OPTIMIZED , LAZY_STREAMING ,   PREDICTIVE_ML , EIGEN_OPTIMIZED , GPU_ACCELERATED }
	Available sorting algorithms for different use cases. 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	SortingDirection : uint8_t { ASCENDING , DESCENDING , CUSTOM , BIDIRECTIONAL }
	Basic sort direction for simple comparisons. 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 }
	Specific spectral operations supported. 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::vector< double >	compute_dynamic_range_energy (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute dynamic range energy using zero-copy processing.
std::vector< double >	compute_zero_crossing_energy (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute zero-crossing energy using zero-copy processing.
std::vector< double >	compute_power_energy (std::span< const double > data, const size_t num_windows, const uint32_t m_hop_size, const uint32_t m_window_size)
	Compute power energy using zero-copy processing.
std::vector< double >	compute_peak_energy (std::span< const double > data, const uint32_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute peak energy using zero-copy processing.
std::vector< double >	compute_rms_energy (std::span< const double > data, const uint32_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute RMS energy using zero-copy processing.
std::vector< double >	compute_spectral_energy (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute spectral energy using FFT-based analysis.
std::vector< double >	compute_harmonic_energy (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute harmonic energy using low-frequency FFT analysis.
std::vector< size_t >	find_zero_crossing_positions (std::span< const double > data, double threshold=0.0)
	Find actual zero-crossing positions in the signal.
std::vector< size_t >	find_peak_positions (std::span< const double > data, double threshold=0.0, size_t min_distance=1)
	Find actual peak positions in the signal.
std::vector< size_t >	find_onset_positions (std::span< const double > data, uint32_t window_size, uint32_t hop_size, double threshold=0.1)
	Find onset positions using spectral flux.
std::vector< double >	compute_mean_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute mean statistic using zero-copy processing.
std::vector< double >	compute_variance_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size, bool sample_variance=true)
	Compute variance statistic using zero-copy processing.
std::vector< double >	compute_std_dev_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size, bool sample_variance=true)
	Compute standard deviation statistic using zero-copy processing.
std::vector< double >	compute_skewness_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute skewness statistic using zero-copy processing.
std::vector< double >	compute_kurtosis_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute kurtosis statistic using zero-copy processing.
std::vector< double >	compute_median_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute median statistic using zero-copy processing.
std::vector< double >	compute_percentile_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size, double percentile)
	Compute percentile statistic using zero-copy processing.
std::vector< double >	compute_entropy_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size, size_t num_bins=0)
	Compute entropy statistic using zero-copy processing.
std::vector< double >	compute_min_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute min statistic using zero-copy processing.
std::vector< double >	compute_max_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute max statistic using zero-copy processing.
std::vector< double >	compute_range_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute range statistic using zero-copy processing.
std::vector< double >	compute_sum_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute sum statistic using zero-copy processing.
std::vector< double >	compute_count_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute count statistic using zero-copy processing.
std::vector< double >	compute_mad_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute MAD (Median Absolute Deviation) statistic using zero-copy processing.
std::vector< double >	compute_cv_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size, bool sample_variance=true)
	Compute CV (Coefficient of Variation) statistic using zero-copy processing.
std::vector< double >	compute_mode_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size)
	Compute mode statistic using zero-copy processing.
std::vector< double >	compute_zscore_statistic (std::span< const double > data, const size_t num_windows, const uint32_t hop_size, const uint32_t window_size, bool sample_variance=true)
	Compute z-score statistic using zero-copy processing.
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_data (const std::vector< std::span< const double > > &data, double energy_threshold=0.1, uint32_t window_size=512, uint32_t hop_size=256)
	Extract data from high-energy regions using EnergyAnalyzer.
std::vector< std::vector< double > >	extract_peak_data (const std::vector< std::span< const double > > &data, double threshold=0.1, double min_distance=10.0, uint32_t region_size=256)
	Extract data from peak regions using peak detection.
std::vector< std::vector< double > >	extract_outlier_data (const std::vector< std::span< const double > > &data, double std_dev_threshold=2.0, uint32_t window_size=512, uint32_t hop_size=256)
	Extract data from statistical outlier regions.
std::vector< std::vector< double > >	extract_high_spectral_data (const std::vector< std::span< const double > > &data, double spectral_threshold=0.1, uint32_t window_size=512, uint32_t hop_size=256)
	Extract data from regions with high spectral energy.
std::vector< std::vector< double > >	extract_above_mean_data (const std::vector< std::span< const double > > &data, double mean_multiplier=1.5, uint32_t window_size=512, uint32_t hop_size=256)
	Extract data from regions with values above statistical mean.
std::vector< std::vector< double > >	extract_overlapping_windows (const std::vector< std::span< const double > > &data, uint32_t window_size=512, double overlap=0.5)
	Extract overlapping windows of actual data.
std::vector< std::vector< double > >	extract_windowed_data_by_indices (const std::vector< std::span< const double > > &data, const std::vector< size_t > &window_indices, uint32_t window_size=512)
	Extract specific data windows by indices.
std::vector< std::string >	get_available_extraction_methods ()
	Get available extraction methods.
bool	validate_extraction_parameters (uint32_t window_size, uint32_t hop_size, size_t data_size)
	Validate extraction parameters.
std::vector< std::vector< double > >	extract_zero_crossing_data (const std::vector< std::span< const double > > &data, double threshold=0.0, double min_distance=1.0, uint32_t region_size=1)
	Extract data at zero crossing points using existing EnergyAnalyzer.
std::vector< std::vector< double > >	extract_silence_data (const std::vector< std::span< const double > > &data, double silence_threshold=0.01, uint32_t min_duration=1024, uint32_t window_size=512, uint32_t hop_size=256)
	Extract data from silent regions using existing EnergyAnalyzer.
std::vector< std::vector< double > >	extract_onset_data (const std::vector< std::span< const double > > &data, double threshold=0.3, uint32_t region_size=512, uint32_t window_size=1024, uint32_t hop_size=256)
	Extract data at onset/transient positions using spectral flux.
std::vector< std::vector< double > >	extract_data_from_regions (const std::vector< std::span< const double > > &data, const std::vector< Kakshya::Region > &regions)
	Extract actual data from specified regions.
std::vector< std::vector< double > >	extract_data_from_region_group (const std::vector< std::span< const double > > &data, const Kakshya::RegionGroup &region_group)
	Extract data from a RegionGroup.
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.
void	sort_span_inplace (std::span< double > data, SortingDirection direction, SortingAlgorithm algorithm)
	Sort a single span of doubles in-place.
std::span< double >	sort_span_extract (std::span< const double > data, std::vector< double > &output_storage, SortingDirection direction, SortingAlgorithm algorithm)
	Sort a single span and return copy in output vector.
void	sort_channels_inplace (std::vector< std::span< double > > &channels, SortingDirection direction, SortingAlgorithm algorithm)
	Sort multiple channels (spans) in-place.
std::vector< std::span< double > >	sort_channels_extract (const std::vector< std::span< const double > > &channels, std::vector< std::vector< double > > &output_storage, SortingDirection direction, SortingAlgorithm algorithm)
	Sort multiple channels and return copies.
std::vector< size_t >	generate_span_sort_indices (std::span< double > data, SortingDirection direction)
	Generate sort indices for a single span.
std::vector< std::vector< size_t > >	generate_channels_sort_indices (const std::vector< std::span< double > > &channels, SortingDirection direction)
	Generate sort indices for multiple channels.
template<std::random_access_iterator Iterator, typename Comparator >
void	execute_sorting_algorithm (Iterator begin, Iterator end, Comparator comp, SortingAlgorithm algorithm)
	Execute sorting algorithm on iterator range.
auto	create_double_comparator (SortingDirection direction)
	Create standard direction-based comparator for doubles.
template<ComplexData T>
auto	create_complex_magnitude_comparator (SortingDirection direction)
	Create magnitude-based comparator for complex numbers.
template<typename Container , typename Comparator >
std::vector< size_t >	generate_sort_indices (const Container &container, Comparator comp)
	Generate sort indices for any container with custom comparator.
template<ComputeData T>
void	sort_compute_data_inplace (IO< 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 IO< 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 IO< 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.
template<typename OperationFunc >
std::vector< double >	fft_convolve_helper (std::span< const double > data_span, std::span< const double > kernel, OperationFunc &&operation, bool return_full_size=true)
	Common FFT convolution helper to eliminate code duplication.
template<OperationReadyData DataType>
DataType	transform_convolve_with_fir (DataType &input, const std::vector< double > &impulse_response)
	Direct convolution using existing FIR filter infrastructure (IN-PLACE) This leverages the existing, well-tested filter implementation.
template<OperationReadyData DataType>
DataType	transform_convolve_with_fir (DataType &input, const std::vector< double > &impulse_response, std::vector< std::vector< double > > &working_buffer)
	Direct convolution using existing FIR filter infrastructure (OUT-OF-PLACE) This leverages the existing, well-tested filter implementation.
template<OperationReadyData DataType>
DataType	transform_convolve (DataType &input, const std::vector< double > &impulse_response)
	Convolution transformation using existing infrastructure with C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_convolve (DataType &input, const std::vector< double > &impulse_response, std::vector< std::vector< double > > &working_buffer)
	Convolution transformation using existing infrastructure with C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_cross_correlate (DataType &input, const std::vector< double > &template_signal, bool normalize=true)
	Cross-correlation using FFT (convolution with time-reversed impulse) (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_cross_correlate (DataType &input, const std::vector< double > &template_signal, bool normalize, std::vector< std::vector< double > > &working_buffer)
	Cross-correlation using FFT (convolution with time-reversed impulse) (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_auto_correlate_fft (DataType &input, bool normalize=true)
	Auto-correlation using FFT (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_auto_correlate_fft (DataType &input, std::vector< std::vector< double > > &working_buffer, bool normalize=true)
	Auto-correlation using FFT (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_matched_filter (DataType &input, const std::vector< double > &reference_signal)
	Matched filter using cross-correlation for signal detection (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_matched_filter (DataType &input, const std::vector< double > &reference_signal, std::vector< std::vector< double > > &working_buffer)
	Matched filter using cross-correlation for signal detection (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_deconvolve (DataType &input, const std::vector< double > &impulse_to_remove, double regularization=1e-6)
	Deconvolution using frequency domain division (IN-PLACE) Useful for removing known impulse responses.
template<OperationReadyData DataType>
DataType	transform_deconvolve (DataType &input, const std::vector< double > &impulse_to_remove, double regularization, std::vector< std::vector< double > > &working_buffer)
	Deconvolution using frequency domain division (OUT-OF-PLACE) Useful for removing known impulse responses.
template<OperationReadyData DataType>
DataType	transform_linear (DataType &input, double a, double b)
	Linear transformation y = ax + b using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_linear (DataType &input, double a, double b, std::vector< std::vector< double > > &working_buffer)
	Linear transformation y = ax + b using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_power (DataType &input, double exponent)
	Power transformation y = x^exponent (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_power (DataType &input, double exponent, std::vector< std::vector< double > > &working_buffer)
	Power transformation y = x^exponent (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_polynomial (DataType &input, const std::vector< double > &coefficients)
	Polynomial transformation using existing Generator::Polynomial (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_polynomial (DataType &input, const std::vector< double > &coefficients, std::vector< std::vector< double > > &working_buffer)
	Polynomial transformation using existing Generator::Polynomial (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_exponential (DataType &input, double a, double b, double base=std::numbers::e)
	Exponential transformation y = a * base^(b * x) (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_exponential (DataType &input, double a, double b, std::vector< std::vector< double > > &working_buffer, double base=std::numbers::e)
	Exponential transformation y = a * base^(b * x) (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_logarithmic (DataType &input, double a, double b, double c=1.0, double base=std::numbers::e)
	Logarithmic transformation y = a * log_base(b * x + c) (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_logarithmic (DataType &input, double a, double b, double c, std::vector< std::vector< double > > &working_buffer, double base=std::numbers::e)
	Logarithmic transformation y = a * log_base(b * x + c) (OUT-OF-PLACE)
template<OperationReadyData DataType, typename TrigFunc > requires std::invocable<TrigFunc, double>
DataType	transform_trigonometric (DataType &input, TrigFunc trig_func, double frequency=1.0, double amplitude=1.0, double phase=0.0)
	Trigonometric transformation using specified function (IN-PLACE)
template<OperationReadyData DataType, typename TrigFunc > requires std::invocable<TrigFunc, double>
DataType	transform_trigonometric (DataType &input, TrigFunc trig_func, double frequency, double amplitude, double phase, std::vector< std::vector< double > > &working_buffer)
	Trigonometric transformation using specified function (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_quantize (DataType &input, uint8_t bits)
	Quantization transformation (bit reduction) using C++20 features (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_quantize (DataType &input, uint8_t bits, std::vector< std::vector< double > > &working_buffer)
	Quantization transformation (bit reduction) using C++20 features (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_clamp (DataType &input, double min_val, double max_val)
	Clamp transformation using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_clamp (DataType &input, double min_val, double max_val, std::vector< std::vector< double > > &working_buffer)
	Clamp transformation using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_wrap (DataType &input, double wrap_range)
	Wrap transformation (modulo operation) using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_wrap (DataType &input, double wrap_range, std::vector< std::vector< double > > &working_buffer)
	Wrap transformation (modulo operation) using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_normalize (DataType &input, const std::pair< double, double > &target_range={ -1.0, 1.0 })
	Normalize transformation using existing infrastructure (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_normalize (DataType &input, const std::pair< double, double > &target_range, std::vector< std::vector< double > > &working_buffer)
	Normalize transformation using existing infrastructure (OUT-OF-PLACE)
void	interpolate (std::span< double > input, std::vector< double > &output, uint32_t target_size)
template<OperationReadyData DataType>
DataType	interpolate_linear (DataType &input, size_t target_size)
	Linear interpolation between data points using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	interpolate_linear (DataType &input, size_t target_size, std::vector< std::vector< double > > &working_buffer)
	Linear interpolation between data points using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	interpolate_cubic (DataType &input, size_t target_size)
	Cubic interpolation between data points using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	interpolate_cubic (DataType &input, size_t target_size, std::vector< std::vector< double > > &working_buffer)
	Cubic interpolation between data points using C++20 ranges (OUT-OF-PLACE)
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.
uint64_t	smallest_size (std::vector< std::vector< double > > &data)
template<typename ProcessorFunc >
std::vector< double >	process_spectral_windows (std::span< double > data, uint32_t window_size, uint32_t hop_size, ProcessorFunc &&processor)
	Common spectral processing helper to eliminate code duplication.
template<OperationReadyData DataType>
DataType	transform_window (DataType &input, Nodes::Generator::WindowType window_type, uint32_t window_size=0)
	Windowing transformation using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_window (DataType &input, Nodes::Generator::WindowType window_type, uint32_t window_size, std::vector< std::vector< double > > &working_buffer)
	Windowing transformation using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_spectral_filter (DataType &input, double low_freq, double high_freq, double sample_rate=48000.0, uint32_t window_size=1024, uint32_t hop_size=256)
	Spectral filtering using existing FFT infrastructure with C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_spectral_filter (DataType &input, double low_freq, double high_freq, double sample_rate, uint32_t window_size, uint32_t hop_size, std::vector< std::vector< double > > &working_buffer)
	Spectral filtering using existing FFT infrastructure with C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_pitch_shift (DataType &input, double semitones, uint32_t window_size=1024, uint32_t hop_size=256)
	Pitch shifting using existing FFT from AnalysisHelper with C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_pitch_shift (DataType &input, double semitones, uint32_t window_size, uint32_t hop_size, std::vector< std::vector< double > > &working_buffer)
	Pitch shifting using existing FFT from AnalysisHelper with C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_spectral_invert (DataType &input, uint32_t window_size=1024, uint32_t hop_size=256)
	Spectral inversion (phase inversion in frequency domain) using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_spectral_invert (DataType &input, uint32_t window_size, uint32_t hop_size, std::vector< std::vector< double > > &working_buffer)
	Spectral inversion (phase inversion in frequency domain) using C++20 ranges (OUT-OF-PLACE)
template<typename TransformFunc > requires std::invocable<TransformFunc, std::span<const double>>
std::vector< double >	process_overlap_add (const std::span< const double > &data, uint32_t window_size, uint32_t hop_size, TransformFunc transform_func)
	Overlap-add processing for windowed transforms using C++20 ranges.
template<OperationReadyData DataType>
DataType	transform_time_reverse (DataType &input)
	Time reversal transformation using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_time_reverse (DataType &input, std::vector< std::vector< double > > &working_buffer)
	Time reversal transformation using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_time_stretch (DataType &input, double stretch_factor)
	Simple time stretching via resampling using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_time_stretch (DataType &input, double stretch_factor, std::vector< std::vector< double > > &working_buffer)
	Simple time stretching via resampling using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_delay (DataType &input, uint32_t delay_samples, double fill_value=0.0)
	Delay transformation that extends buffer size (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_delay (DataType &input, uint32_t delay_samples, double fill_value, std::vector< std::vector< double > > &working_buffer)
	Delay transformation that extends buffer size (OUT-OF-PLACE) - CORRECTED.
template<OperationReadyData DataType>
DataType	transform_fade (DataType &input, double fade_in_duration_ratio=0.0, double fade_out_duration_ratio=0.0)
	Fade transformation (linear fade-in and fade-out) using C++20 ranges (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_fade (DataType &input, double fade_in_duration_ratio, double fade_out_duration_ratio, std::vector< std::vector< double > > &working_buffer)
	Fade transformation (linear fade-in and fade-out) using C++20 ranges (OUT-OF-PLACE)
template<OperationReadyData DataType>
DataType	transform_slice (DataType &input, double start_ratio, double end_ratio)
	Slice transformation to extract a portion of the data based on ratios (IN-PLACE)
template<OperationReadyData DataType>
DataType	transform_slice (DataType &input, double start_ratio, double end_ratio, std::vector< std::vector< double > > &working_buffer)
	Slice transformation to extract a portion of the data based on ratios (OUT-OF-PLACE)

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