genetic-search/lib/cache.d.ts

Multiprocessing genetic algorithm implementation library

import type { PhenomeRow, PhenomeCacheInterface } from "./types";
/**
 * A dummy phenome cache implementation that does nothing.
 *
 * This class is used when the {@link GeneticSearch} is created without a
 * phenome cache.
 *
 * @category Cache
 * @category Strategies
 */
export declare class DummyPhenomeCache implements PhenomeCacheInterface {
    getReady(_: number): PhenomeRow | undefined;
    get(_: number, defaultValue?: PhenomeRow): PhenomeRow | undefined;
    set(_: number, __: PhenomeRow): void;
    clear(_: number[]): void;
    export(): Record<number, never>;
    import(_: Record<number, never>): void;
}
/**
 * A simple phenome cache implementation.
 *
 * This cache stores the constant phenome value for each genome.
 *
 * @category Cache
 * @category Strategies
 */
export declare class SimplePhenomeCache implements PhenomeCacheInterface {
    protected readonly cache: Map<number, PhenomeRow>;
    get(genomeId: number, defaultValue?: PhenomeRow): PhenomeRow | undefined;
    getReady(genomeId: number): PhenomeRow | undefined;
    set(genomeId: number, phenome: PhenomeRow): void;
    clear(excludeGenomeIds: number[]): void;
    export(): Record<number, PhenomeRow>;
    import(data: Record<number, PhenomeRow>): void;
}
/**
 * A phenome cache implementation that stores the phenome for each genome as a
 * weighted average of all phenome that have been set for that genome.
 *
 * @category Cache
 * @category Strategies
 */
export declare class AveragePhenomeCache implements PhenomeCacheInterface {
    /**
     * A map of genome IDs to their respective phenome and the number of times they have been set.
     *
     * The key is the genome ID, and the value is an array with two elements. The first element is the
     * current phenome for the genome, and the second element is the number of times the phenome have
     * been set.
     */
    protected readonly cache: Map<number, [PhenomeRow, number]>;
    get(genomeId: number, defaultValue?: PhenomeRow): PhenomeRow | undefined;
    getReady(): PhenomeRow | undefined;
    set(genomeId: number, phenome: PhenomeRow): void;
    clear(excludeGenomeIds: number[]): void;
    export(): Record<number, [PhenomeRow, number]>;
    import(data: Record<number, [PhenomeRow, number]>): void;
}
/**
 * A phenome cache implementation that stores the phenome for each genome as a
 * weighted average of all phenome that have been set for that genome.
 *
 * The closer the genome age is to 0, the closer the phenome are to the average phenome of the population,
 * which helps to combat outliers for new genomes.
 *
 * @category Cache
 * @category Strategies
 */
export declare class WeightedAgeAveragePhenomeCache extends AveragePhenomeCache {
    /**
     * The weight factor used for calculating the weighted average.
     */
    private weight;
    /**
     * The current average phenome row, or undefined if not yet calculated.
     */
    private averageRow;
    /**
     * Constructs a new WeightedAgeAveragePhenomeCache.
     * @param weight The weight factor used for calculating the weighted average.
     */
    constructor(weight: number);
    set(genomeId: number, phenome: PhenomeRow): void;
    get(genomeId: number, defaultValue?: PhenomeRow): PhenomeRow | undefined;
    private refreshAverageRow;
    private resetAverageRow;
    private getPhenomeCount;
}