/**
 * Non-negative Matrix Factorization (NMF) for polyphonic pitch detection
 *
 * This module implements NMF algorithms for source separation and spectral
 * dictionary learning to enable detection of multiple simultaneous pitches.
 */
/**
 * Configuration for NMF algorithm
 */
export interface NMFConfig {
    rank?: number;
    maxIterations?: number;
    tolerance?: number;
    sparsity?: number;
    smoothness?: number;
    useMultiplicative?: boolean;
    useAlternating?: boolean;
    useKullbackLeibler?: boolean;
    useEuclidean?: boolean;
    randomSeed?: number;
}
/**
 * NMF result containing factorized matrices
 */
export interface NMFResult {
    W: Float32Array[];
    H: Float32Array[];
    reconstruction: Float32Array[];
    error: number;
    iterations: number;
    converged: boolean;
    components: NMFComponent[];
}
/**
 * Individual NMF component with metadata
 */
export interface NMFComponent {
    index: number;
    basis: Float32Array;
    coefficients: Float32Array;
    energy: number;
    spectralCentroid: number;
    spectralRolloff: number;
    fundamental: number;
    confidence: number;
    isPitch: boolean;
}
/**
 * Spectral dictionary for NMF
 */
export interface SpectralDictionary {
    atoms: Float32Array[];
    frequencies: number[];
    pitches: number[];
    weights: number[];
    size: number;
}
/**
 * Main NMF algorithm class
 */
export declare class NMFAlgorithm {
    private config;
    private random;
    constructor(config?: NMFConfig);
    /**
     * Perform NMF decomposition
     */
    decompose(V: Float32Array[], initialW?: Float32Array[], initialH?: Float32Array[]): NMFResult;
    /**
     * Initialize basis matrix W
     */
    private initializeW;
    /**
     * Initialize coefficient matrix H
     */
    private initializeH;
    /**
     * Multiplicative update rules
     */
    private multiplicativeUpdate;
    /**
     * Alternating least squares update
     */
    private alternatingLeastSquares;
    /**
     * Calculate WH product for element (i, j)
     */
    private calculateWH;
    /**
     * Calculate reconstruction error
     */
    private calculateError;
    /**
     * Reconstruct matrix from factors
     */
    private reconstruct;
    /**
     * Extract components with metadata
     */
    private extractComponents;
    /**
     * Calculate spectral centroid
     */
    private calculateSpectralCentroid;
    /**
     * Calculate spectral rolloff
     */
    private calculateSpectralRolloff;
    /**
     * Estimate fundamental frequency from basis
     */
    private estimateFundamental;
    /**
     * Calculate component confidence
     */
    private calculateConfidence;
    /**
     * Calculate sparsity of a vector
     */
    private calculateSparsity;
    /**
     * Calculate consistency of coefficients
     */
    private calculateConsistency;
    /**
     * Determine if component represents a pitch
     */
    private isPitchComponent;
    /**
     * Check if basis has clear spectral structure
     */
    private hasClearSpectralStructure;
    /**
     * Find peaks in spectrum
     */
    private findPeaks;
    /**
     * Create random number generator
     */
    private createRandomGenerator;
    /**
     * Get current configuration
     */
    getConfig(): Readonly<Required<NMFConfig>>;
    /**
     * Update configuration
     */
    updateConfig(newConfig: Partial<NMFConfig>): void;
}
/**
 * Spectral dictionary learning utilities
 */
export declare const SpectralDictionary: {
    /**
     * Learn dictionary from training data
     */
    learnDictionary(trainingData: Float32Array[][], dictionarySize?: number, config?: NMFConfig): SpectralDictionary;
    /**
     * Flatten training data
     */
    flattenTrainingData(trainingData: Float32Array[][]): Float32Array[];
    /**
     * Estimate frequency from atom
     */
    estimateFrequency(atom: Float32Array): number;
    /**
     * Calculate atom weight
     */
    calculateAtomWeight(atom: Float32Array): number;
};
/**
 * NMF utilities for polyphonic detection
 */
export declare const NMFUtils: {
    /**
     * Separate sources using NMF
     */
    separateSources(spectrogram: Float32Array[], dictionary: SpectralDictionary, config?: NMFConfig): NMFResult;
    /**
     * Extract pitch components
     */
    extractPitchComponents(result: NMFResult): NMFComponent[];
    /**
     * Group components by pitch
     */
    groupComponentsByPitch(components: NMFComponent[]): Map<number, NMFComponent[]>;
    /**
     * Calculate component similarity
     */
    calculateSimilarity(comp1: NMFComponent, comp2: NMFComponent): number;
};
/**
 * Quick utility function for NMF decomposition
 */
export declare function decomposeNMF(spectrogram: Float32Array[], config?: NMFConfig): NMFResult;