/** @import {InputType} from "../index.js" */
/** @import {Metric} from "../metrics/index.js" */
/** @import {ParametersUMAP} from "./index.js" */
/**
 * Uniform Manifold Approximation and Projection (UMAP)
 *
 * A novel manifold learning technique for dimensionality reduction. UMAP is constructed
 * from a theoretical framework based on Riemannian geometry and algebraic topology.
 * It is often faster than t-SNE while preserving more of the global structure.
 *
 * @class
 * @template {InputType} T
 * @extends DR<T, ParametersUMAP>
 * @category Dimensionality Reduction
 * @see {@link https://arxiv.org/abs/1802.03426|UMAP Paper}
 * @see {@link TSNE} for a similar visualization technique
 *
 * @example
 * import * as druid from "@saehrimnir/druidjs";
 *
 * const X = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]];
 * const umap = new druid.UMAP(X, {
 *     n_neighbors: 15,
 *     min_dist: 0.1,
 *     d: 2,
 *     seed: 42
 * });
 *
 * const Y = umap.transform(500); // 500 iterations
 * // [[x1, y1], [x2, y2], [x3, y3]]
 */
export class UMAP<T extends InputType> extends DR<T, ParametersUMAP> {
  /**
   * @template {InputType} T
   * @param {T} X
   * @param {Partial<ParametersUMAP>} [parameters]
   * @returns {T}
   */
  static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersUMAP>): T_1;
  /**
   * @template {InputType} T
   * @param {T} X
   * @param {Partial<ParametersUMAP>} [parameters]
   * @returns {Generator<T, T, void>}
   */
  static generator<T_1 extends InputType>(
    X: T_1,
    parameters?: Partial<ParametersUMAP>,
  ): Generator<T_1, T_1, void>;
  /**
   * @template {InputType} T
   * @param {T} X
   * @param {Partial<ParametersUMAP>} [parameters]
   * @returns {Promise<T>}
   */
  static transform_async<T_1 extends InputType>(
    X: T_1,
    parameters?: Partial<ParametersUMAP>,
  ): Promise<T_1>;
  /**
   * @param {T} X - The high-dimensional data.
   * @param {Partial<ParametersUMAP>} [parameters] - Object containing parameterization of the DR method.
   */
  constructor(X: T, parameters?: Partial<ParametersUMAP>);
  _iter: number;
  /**
   * @private
   * @param {number} spread
   * @param {number} min_dist
   * @returns {number[]}
   */
  private _find_ab_params;
  /**
   * @private
   * @param {{ element: Float64Array; index: number; distance: number }[][]} distances
   * @param {number[]} sigmas
   * @param {number[]} rhos
   * @returns {{ element: Float64Array; index: number; distance: number }[][]}
   */
  private _compute_membership_strengths;
  /**
   * @private
   * @param {NaiveKNN<Float64Array> | BallTree<Float64Array>} knn
   * @param {number} k
   * @returns {{
   *     distances: { element: Float64Array; index: number; distance: number }[][];
   *     sigmas: number[];
   *     rhos: number[];
   * }}
   */
  private _smooth_knn_dist;
  /**
   * @private
   * @param {Matrix} X
   * @param {number} n_neighbors
   * @returns {Matrix}
   */
  private _fuzzy_simplicial_set;
  /**
   * @private
   * @param {number} n_epochs
   * @returns {Float32Array}
   */
  private _make_epochs_per_sample;
  /**
   * @private
   * @param {Matrix} graph
   * @returns {{ rows: number[]; cols: number[]; data: number[] }}
   */
  private _tocoo;
  /**
   * Computes all necessary
   *
   * @returns {UMAP<T>}
   */
  init(): UMAP<T>;
  _a: number | undefined;
  _b: number | undefined;
  _graph: Matrix | undefined;
  _head: number[] | undefined;
  _tail: number[] | undefined;
  _weights: number[] | undefined;
  _epochs_per_sample: Float32Array<ArrayBufferLike> | undefined;
  _epochs_per_negative_sample: Float32Array<ArrayBuffer> | undefined;
  _epoch_of_next_sample: Float32Array<ArrayBuffer> | undefined;
  _epoch_of_next_negative_sample: Float32Array<ArrayBuffer> | undefined;
  graph(): {
    cols: number[] | undefined;
    rows: number[] | undefined;
    weights: number[] | undefined;
  };
  /**
   * @param {number} [iterations=350] - Number of iterations. Default is `350`
   * @returns {T}
   */
  transform(iterations?: number): T;
  /**
   * @param {number} [iterations=350] - Number of iterations. Default is `350`
   * @returns {Generator<T, T, void>}
   */
  generator(iterations?: number): Generator<T, T, void>;
  /**
   * @private
   * @param {number} x
   * @returns {number}
   */
  private _clip;
  /**
   * Performs the optimization step.
   *
   * @private
   * @param {Matrix} head_embedding
   * @param {Matrix} tail_embedding
   * @param {number[]} head
   * @param {number[]} tail
   * @returns {Matrix}
   */
  private _optimize_layout;
  /**
   * @private
   * @returns {Matrix}
   */
  private next;
  _alpha: number | undefined;
}
import type { InputType } from "../index.js";
import type { ParametersUMAP } from "./index.js";
import { DR } from "./DR.js";
import { Matrix } from "../matrix/index.js";
//# sourceMappingURL=UMAP.d.ts.map