Structure and extraction helpers for Yantra operation data. More...

#include <OperationHelper.hpp>

Collaboration diagram for MayaFlux::Yantra::OperationHelper:

Static Public Member Functions
template<CompositeData T>
static const Kakshya::CompositeArray &	extract_composite_data (const Datum< T > &datum)
	Borrow Composite data carried by a Datum.

static const Kakshya::CompositeArray &	extract_composite_data (const Kakshya::CompositeArray &data) noexcept
	Borrow an owning Composite array without converting its fields.

static const Kakshya::CompositeArray &	extract_composite_data (const std::shared_ptr< Kakshya::CompositeContainer > &container)
	Borrow the array owned by a Composite container.

template<typename EigenMatrix > requires is_eigen_matrix_v<EigenMatrix>
static auto	extract_native_data (const EigenMatrix &matrix) -> std::vector< std::span< const typename EigenMatrix::Scalar > >
	Extract native-typed column spans from any Eigen matrix.

static Kakshya::DataSpanVariant	extract_native_data (const Kakshya::DataVariant &variant)
	Extract a single DataVariant as a type-erased span without conversion.

static std::vector< Kakshya::DataSpanVariant >	extract_native_data (const std::shared_ptr< Kakshya::SignalSourceContainer > &container, bool use_processed=false)
	Extract native-typed channel spans from a SignalSourceContainer.

static std::vector< Kakshya::DataSpanVariant >	extract_native_data (const std::vector< Kakshya::DataVariant > &variants)
	Extract a vector of DataVariants as type-erased spans without conversion.

template<typename T > requires SingleVariant<T>
static std::span< double >	extract_numeric_data (const T &compute_data)
	extract numeric data from single-variant types

template<typename T > requires (MultiVariant<T> \|\| EigenMatrixLike<T>)
static std::vector< std::span< double > >	extract_numeric_data (const T &compute_data, bool needs_processig=false)
	extract numeric data from multi-variant types

template<typename T > requires RegionLike<T>
static std::vector< std::span< double > >	extract_numeric_data (const T &compute_data, const std::shared_ptr< Kakshya::SignalSourceContainer > &container)
	extract numeric data from region-like types

template<typename ValueT , typename T > requires (detail::is_composite_operation_data_v<T> && ArithmeticData<ValueT> && Kakshya::DataVariantElement<ValueT>)
static std::optional< CompositeFieldDoubleData >	extract_projected_composite_double (const T &compute_data, std::string_view field_name)
	Extract one compatible numeric field for double-based operations.

template<typename T > requires detail::is_composite_operation_data_v<T>
static std::pair< std::reference_wrapper< const Kakshya::CompositeArray >, DataStructureInfo >	extract_structured_composite (const T &compute_data)
	Borrow Composite records together with their row axis and field layout.

template<OperationReadyData T> requires (!detail::is_composite_operation_data_v<T>)
static std::tuple< std::vector< std::span< double > >, DataStructureInfo >	extract_structured_double (T &compute_data)
	Extract structured double data from Datum container or direct ComputeData with automatic container handling.

template<OperationReadyData T> requires (!detail::is_composite_operation_data_v<T>)
static std::tuple< std::vector< Kakshya::DataSpanVariant >, DataStructureInfo >	extract_structured_native (T &compute_data)
	Extract native-typed channel spans and structure metadata from a Datum or direct ComputeData, without double coercion.

static Kakshya::ComplexConversionStrategy	get_complex_conversion_strategy ()
	Get current complex conversion strategy.

template<OperationReadyData T>
static DataStructureInfo	get_structure_info (const T &compute_data)
	Populate DataStructureInfo from a Datum without extracting spans.

template<typename ValueT , typename T > requires (detail::is_composite_operation_data_v<T> && ArithmeticData<ValueT> && Kakshya::DataVariantElement<ValueT>)
static std::optional< Kakshya::CompositeProjection >	project_composite_field (const T &compute_data, std::string_view field_name)
	Project one exact-type numeric Composite field to compatible NDData.

template<ComputeData T> requires (!is_IO<T>::value && !CompositeData<T>)
static T	reconstruct_from_double (const std::vector< std::vector< double > > &double_data, const DataStructureInfo &structure_info)
	Reconstruct ComputeData type from double vector and structure info.

template<typename T > requires (is_IO<T>::value && !detail::is_composite_operation_data_v<T>)
static T	reconstruct_from_double (const std::vector< std::vector< double > > &double_data, const DataStructureInfo &structure_info)
	Reconstruct Datum type from double vector and structure info.

template<typename ValueT , typename T > requires (detail::is_composite_operation_data_v<T> && ArithmeticData<ValueT> && Kakshya::DataVariantElement<ValueT>)
static std::optional< Kakshya::CompositeArray >	reconstruct_projected_composite (const T &compute_data, const CompositeFieldDoubleData &projected)
	Copy Composite records and replace one projected numeric field.

static void	set_complex_conversion_strategy (Kakshya::ComplexConversionStrategy strategy)
	Set global complex conversion strategy.

template<OperationReadyData T> requires (!detail::is_composite_operation_data_v<T>)
static auto	setup_operation_buffer (T &input, std::vector< std::vector< double > > &working_buffer)
	Setup operation buffer from Datum or ComputeData type.

template<typename T > requires MultiVariant<T>
static std::vector< Kakshya::DataVariant >	to_data_variant (const T &compute_data)
	Convert ComputeData to DataVariant format.

template<typename T > requires RegionLike<T>
static std::vector< Kakshya::DataVariant >	to_data_variant (const T &compute_data, const std::shared_ptr< Kakshya::SignalSourceContainer > &container)
	Convert region-like ComputeData to DataVariant format.

Static Private Member Functions
template<typename EigenMatrix >
static std::vector< Kakshya::DataVariant >	convert_eigen_matrix_to_variant (const EigenMatrix &matrix)
	Extract data from Eigen vector to double span.

template<typename EigenType >
static Kakshya::DataVariant	create_data_variant_from_eigen (const EigenType &eigen_data)
	Create DataVariant from Eigen matrix/vector.

template<typename T >
static Eigen::MatrixXd	create_eigen_matrix (const std::vector< std::span< const T > > &spans)
	Create Eigen matrix from spans.

template<typename T >
static Eigen::MatrixXd	create_eigen_matrix (const std::vector< std::vector< T > > &columns)
	Infer data structure from ComputeData type.

template<typename EigenMatrix >
static std::vector< std::span< double > >	extract_from_eigen_matrix (const EigenMatrix &matrix)
	Infer data structure from ComputeData type.

static Kakshya::DataVariant	reconstruct_data_variant_from_double (const std::vector< double > &double_data, const DataStructureInfo &structure_info)
	Reconstruct DataVariant from double data and structure info.

static Eigen::MatrixXd	recreate_eigen_matrix (const std::vector< std::span< const double > > &spans, const DataStructureInfo &structure_info)
	Infer data structure from ComputeData type.

static Eigen::MatrixXd	recreate_eigen_matrix (const std::vector< std::vector< double > > &columns, const DataStructureInfo &structure_info)
	Infer data structure from ComputeData type.

Static Private Attributes
static Kakshya::ComplexConversionStrategy	s_complex_strategy = Kakshya::ComplexConversionStrategy::MAGNITUDE

Detailed Description

Structure and extraction helpers for Yantra operation data.

Numeric operations can use this helper to:

Convert compatible numeric data to std::vector<double>
Process data in double format (universal algorithms)
Reconstruct results back to target ComputeData types

Key Features:

Explicit Composite access with field schema and presence-aware projection
Structure preservation via metadata
Configurable complex number handling

Definition at line 77 of file OperationHelper.hpp.

The documentation for this class was generated from the following files:

Static Public Member Functions

Static Private Member Functions

Static Private Attributes

Detailed Description