agentjs-core/dist/utils/MathUtils.d.ts

A comprehensive agent-based modeling framework with built-in p5.js visualization

/**
 * Mathematical utility functions for AgentJS framework
 */
export declare class Vector2D {
    x: number;
    y: number;
    constructor(x?: number, y?: number);
    static from(obj: {
        x: number;
        y: number;
    }): Vector2D;
    add(other: Vector2D): Vector2D;
    subtract(other: Vector2D): Vector2D;
    multiply(scalar: number): Vector2D;
    divide(scalar: number): Vector2D;
    magnitude(): number;
    normalize(): Vector2D;
    distance(other: Vector2D): number;
    dot(other: Vector2D): number;
    angle(): number;
    rotate(angle: number): Vector2D;
    clone(): Vector2D;
    equals(other: Vector2D, tolerance?: number): boolean;
    toString(): string;
}
export declare class MathUtils {
    /**
     * Clamp a value between min and max
     */
    static clamp(value: number, min: number, max: number): number;
    /**
     * Linear interpolation between two values
     */
    static lerp(a: number, b: number, t: number): number;
    /**
     * Map a value from one range to another
     */
    static map(value: number, fromMin: number, fromMax: number, toMin: number, toMax: number): number;
    /**
     * Convert degrees to radians
     */
    static degToRad(degrees: number): number;
    /**
     * Convert radians to degrees
     */
    static radToDeg(radians: number): number;
    /**
     * Calculate distance between two points
     */
    static distance(x1: number, y1: number, x2: number, y2: number): number;
    /**
     * Calculate squared distance (faster than distance for comparisons)
     */
    static distanceSquared(x1: number, y1: number, x2: number, y2: number): number;
    /**
     * Generate random number between min and max
     */
    static random(min?: number, max?: number): number;
    /**
     * Generate random integer between min and max (inclusive)
     */
    static randomInt(min: number, max: number): number;
    /**
     * Generate random boolean
     */
    static randomBoolean(probability?: number): boolean;
    /**
     * Generate random number from normal distribution (Box-Muller transform)
     */
    static randomNormal(mean?: number, stdDev?: number): number;
    /**
     * Select random element from array
     */
    static randomChoice<T>(array: T[]): T;
    /**
     * Shuffle array in place (Fisher-Yates algorithm)
     */
    static shuffle<T>(array: T[]): T[];
    /**
     * Calculate weighted random selection
     */
    static weightedRandom<T>(items: T[], weights: number[]): T;
    /**
     * Check if point is inside circle
     */
    static pointInCircle(px: number, py: number, cx: number, cy: number, radius: number): boolean;
    /**
     * Check if point is inside rectangle
     */
    static pointInRect(px: number, py: number, x: number, y: number, width: number, height: number): boolean;
    /**
     * Calculate angle between two points
     */
    static angleBetween(x1: number, y1: number, x2: number, y2: number): number;
    /**
     * Normalize angle to [0, 2π] range
     */
    static normalizeAngle(angle: number): number;
    /**
     * Calculate shortest angular difference between two angles
     */
    static angleDifference(angle1: number, angle2: number): number;
    /**
     * Round number to specified decimal places
     */
    static round(value: number, decimals?: number): number;
    /**
     * Check if number is approximately equal to another
     */
    static approximately(a: number, b: number, tolerance?: number): boolean;
    /**
     * Calculate mean of array
     */
    static mean(values: number[]): number;
    /**
     * Calculate median of array
     */
    static median(values: number[]): number;
    /**
     * Calculate standard deviation of array
     */
    static standardDeviation(values: number[]): number;
    /**
     * Calculate percentile of array
     */
    static percentile(values: number[], percentile: number): number;
    /**
     * Generate UUID v4
     */
    static generateUUID(): string;
    /**
     * Deep clone an object
     */
    static deepClone<T>(obj: T): T;
    /**
     * Debounce function calls
     */
    static debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
    /**
     * Throttle function calls
     */
    static throttle<T extends (...args: any[]) => any>(func: T, limit: number): (...args: Parameters<T>) => void;
    /**
     * Format number with specified precision
     */
    static formatNumber(value: number, precision?: number): string;
    /**
     * Format number as percentage
     */
    static formatPercentage(value: number, precision?: number): string;
    /**
     * Validate if value is a finite number
     */
    static isValidNumber(value: any): value is number;
    /**
     * Ensure value is within bounds, wrapping if necessary
     */
    static wrap(value: number, min: number, max: number): number;
    /**
     * Calculate Euclidean distance in N dimensions
     */
    static distanceND(point1: number[], point2: number[]): number;
    /**
     * Calculate Manhattan distance in N dimensions
     */
    static manhattanDistance(point1: number[], point2: number[]): number;
}
//# sourceMappingURL=MathUtils.d.ts.map