ts-quantum/dist/core/types.d.ts

TypeScript library for quantum mechanics calculations and utilities

/**
 * Core type definitions for quantum operations
 */
import { Complex } from 'mathjs';
export type { Complex } from 'mathjs';
import { StateVector } from '../states/stateVector';
/**
 * Helper functions for complex number handling
 */
export declare function toComplex(value: number | Complex | {
    re: number;
    im: number;
}): Complex;
export declare function ensureComplex(value: Complex): Complex;
/**
 * Represents a quantum state vector
 */
export interface IStateVector {
    readonly objectType: 'state';
    dimension: number;
    amplitudes: Complex[];
    basis?: string;
    properties?: Record<string, any>;
    setState(index: number, value: Complex): void;
    getState(index: number): Complex;
    getAmplitudes(): Complex[];
    innerProduct(other: IStateVector): Complex;
    norm(): number;
    normalize(): IStateVector;
    tensorProduct(other: IStateVector): IStateVector;
    scale(factor: Complex): IStateVector;
    add(other: IStateVector): IStateVector;
    equals(other: IStateVector, tolerance?: number): boolean;
    isZero(tolerance?: number): boolean;
    toArray(): Complex[];
    toString(): string;
}
/**
 * Type of quantum operator (unitary, hermitian, etc)
 */
export type OperatorType = 'unitary' | 'hermitian' | 'projection' | 'general' | 'identity' | 'diagonal' | 'Jplus' | 'Jminus' | 'Jz' | 'J2';
/**
 * Base interface for quantum operators
 */
export interface IOperator {
    readonly objectType: 'operator';
    dimension: number;
    type: OperatorType;
    apply(state: IStateVector): StateVector;
    compose(other: IOperator): IOperator;
    adjoint(): IOperator;
    toMatrix(): Complex[][];
    tensorProduct(other: IOperator): IOperator;
    partialTrace(dims: number[], traceOutIndices: number[]): IOperator;
    scale(scalar: Complex): IOperator;
    add(other: IOperator): IOperator;
    eigenDecompose(): {
        values: Complex[];
        vectors: IOperator[];
    };
    norm(): number;
    isZero(tolerance?: number): boolean;
}
/**
 * Type for measurement outcomes
 */
export interface IMeasurementOutcome {
    value: number;
    state: IStateVector;
    probability: number;
}
/**
 * Interface for density matrix operations
 */
export interface IDensityMatrix extends IOperator {
    trace(): Complex;
    partialTrace(dims: number[], traceOutIndices: number[]): IOperator;
    purity(): number;
    vonNeumannEntropy(): number;
}
/**
 * Interface for quantum channels
 */
export interface IQuantumChannel {
    apply(state: IDensityMatrix): IDensityMatrix;
    getOperators(): IOperator[];
}
/**
 * Sparse matrix entry representation
 */
export interface ISparseEntry {
    row: number;
    col: number;
    value: Complex;
}
/**
 * Sparse matrix representation
 */
export interface ISparseMatrix {
    rows: number;
    cols: number;
    entries: ISparseEntry[];
    nnz: number;
}
/**
 * Interface for sparse operator operations
 */
export interface ISparseOperator extends IOperator {
    readonly sparse: true;
    getSparseMatrix(): ISparseMatrix;
    toSparse(): ISparseMatrix;
    fromSparse(sparse: ISparseMatrix): ISparseOperator;
}
/**
 * Unified quantum object type - union of all quantum objects
 */
export type QuantumObject = IStateVector | IOperator;
/**
 * Type guards for runtime discrimination
 */
export declare function isState(obj: QuantumObject): obj is IStateVector;
export declare function isOperator(obj: QuantumObject): obj is IOperator;
export declare function isDensityMatrix(obj: IOperator): obj is IDensityMatrix;
/**
 * Utility functions for unified operations
 */
export declare function adjoint(obj: QuantumObject): QuantumObject;
export declare function norm(obj: QuantumObject): number;
export declare function getObjectType(obj: QuantumObject): 'state' | 'operator';