/** @import {InputType} from "../index.js" */
/** @import {Metric} from "../metrics/index.js" */
/** @import {ParametersTriMap} from "./index.js" */
/** @import {KNN} from "../knn/KNN.js" */
/**
 * TriMap
 *
 * A dimensionality reduction technique that preserves both local and global
 * structure using triplets. It is designed to be a more robust alternative
 * to t-SNE and UMAP.
 *
 * @class
 * @template {InputType} T
 * @extends DR<T, ParametersTriMap>
 * @category Dimensionality Reduction
 */
export class TriMap<T extends InputType> extends DR<T, ParametersTriMap> {
  /**
   * @template {InputType} T
   * @param {T} X
   * @param {Partial<ParametersTriMap>} [parameters]
   * @returns {T}
   */
  static transform<T_1 extends InputType>(X: T_1, parameters?: Partial<ParametersTriMap>): T_1;
  /**
   * @template {InputType} T
   * @param {T} X
   * @param {Partial<ParametersTriMap>} [parameters]
   * @returns {Generator<T, T, void>}
   */
  static generator<T_1 extends InputType>(
    X: T_1,
    parameters?: Partial<ParametersTriMap>,
  ): Generator<T_1, T_1, void>;
  /**
   * @template {InputType} T
   * @param {T} X
   * @param {Partial<ParametersTriMap>} [parameters]
   * @returns {Promise<T>}
   */
  static transform_async<T_1 extends InputType>(
    X: T_1,
    parameters?: Partial<ParametersTriMap>,
  ): Promise<T_1>;
  /**
   * @param {T} X - The high-dimensional data.
   * @param {Partial<ParametersTriMap>} [parameters] - Object containing parameterization of the DR method.
   * @see {@link https://arxiv.org/pdf/1910.00204v1.pdf}
   * @see {@link https://github.com/eamid/trimap}
   */
  constructor(X: T, parameters?: Partial<ParametersTriMap>);
  /**
   * @param {Matrix | null} [pca=null] - Initial Embedding (if null then PCA gets used). Default is `null`
   * @param {import("../knn/KNN.js").KNN<number[] | Float64Array, any> | null} [knn=null] - KNN Object (if null then BallTree gets used). Default is `null`
   */
  init(
    pca?: Matrix | null,
    knn?: import("../knn/KNN.js").KNN<number[] | Float64Array, any> | null,
  ): this;
  n_inliers: number | undefined;
  n_outliers: number | undefined;
  n_random: number | undefined;
  knn: KNN<number[] | Float64Array<ArrayBufferLike>, any> | undefined;
  triplets: Matrix | undefined;
  weights: Float64Array<ArrayBuffer> | undefined;
  lr: number | undefined;
  C: number | undefined;
  vel: Matrix | undefined;
  gain: Matrix | undefined;
  /**
   * Generates {@link n_inliers} x {@link n_outliers} x {@link n_random} triplets.
   *
   * @param {number} n_inliers
   * @param {number} n_outliers
   * @param {number} n_random
   */
  _generate_triplets(
    n_inliers: number,
    n_outliers: number,
    n_random: number,
  ): {
    triplets: Matrix;
    weights: Float64Array<ArrayBuffer>;
  };
  /**
   * Calculates the similarity matrix P
   *
   * @private
   * @param {Matrix} knn_distances - Matrix of pairwise knn distances
   * @param {Float64Array} sig - Scaling factor for the distances
   * @param {Matrix} nbrs - Nearest neighbors
   * @returns {Matrix} Pairwise similarity matrix
   */
  private _find_p;
  /**
   * Sample nearest neighbors triplets based on the similarity values given in P.
   *
   * @private
   * @param {Matrix} P - Matrix of pairwise similarities between each point and its neighbors given in matrix nbrs.
   * @param {Matrix} nbrs - Nearest neighbors indices for each point. The similarity values are given in matrix
   *   {@link P}. Row i corresponds to the i-th point.
   * @param {number} n_inliers - Number of inlier points.
   * @param {number} n_outliers - Number of outlier points.
   */
  private _sample_knn_triplets;
  /**
   * Should do the same as np.argsort()
   *
   * @private
   * @param {Float64Array | number[]} A
   */
  private __argsort;
  /**
   * Samples {@link n_samples} integers from a given interval [0, {@link max_int}] while rejection the values that are
   * in the {@link rejects}.
   *
   * @private
   * @param {number} n_samples
   * @param {number} max_int
   * @param {number[]} rejects
   */
  private _rejection_sample;
  /**
   * Calculates the weights for the sampled nearest neighbors triplets
   *
   * @private
   * @param {Matrix} triplets - Sampled Triplets.
   * @param {Matrix} P - Pairwise similarity matrix.
   * @param {Matrix} nbrs - Nearest Neighbors
   * @param {Float64Array} outlier_distances - Matrix of pairwise outlier distances
   * @param {Float64Array} sig - Scaling factor for the distances.
   */
  private _find_weights;
  /**
   * Sample uniformly ranom triplets
   *
   * @private
   * @param {Matrix} X - Data matrix.
   * @param {number} n_random - Number of random triplets per point
   * @param {Float64Array} sig - Scaling factor for the distances
   */
  private _sample_random_triplets;
  /**
   * Computes the gradient for updating the embedding.
   *
   * @param {Matrix} Y - The embedding
   */
  _grad(Y: Matrix): {
    grad: Matrix;
    loss: number;
    n_viol: number;
  };
  /**
   * @param {number} max_iteration
   * @returns {T}
   */
  transform(max_iteration?: number): T;
  /**
   * @param {number} max_iteration
   * @returns {Generator<T, T, void>}
   */
  generator(max_iteration?: number): Generator<T, T, void>;
  /**
   * Does the iteration step.
   *
   * @private
   * @param {number} iter
   */
  private _next;
  /**
   * Updates the embedding.
   *
   * @private
   * @param {Matrix} Y
   * @param {number} iter
   * @param {Matrix} grad
   */
  private _update_embedding;
}
import type { InputType } from "../index.js";
import type { ParametersTriMap } from "./index.js";
import { DR } from "./DR.js";
import { Matrix } from "../matrix/index.js";
import type { KNN } from "../knn/KNN.js";
//# sourceMappingURL=TriMap.d.ts.map