typegpu/std/numeric.d.ts

A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.

import { type AnyFloat32VecInstance, type AnyFloatVecInstance, type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type v2f, type v2h, type v2i, type v3f, type v3h, type v3i, type v4f, type v4h, type v4i, type Vec2f } from '../data/wgslTypes.ts';
import type { Infer } from '../shared/repr.ts';
type NumVec = AnyNumericVecInstance;
declare function cpuAbs(value: number): number;
declare function cpuAbs<T extends NumVec | number>(value: T): T;
export declare const abs: import("../types.ts").DualFn<typeof cpuAbs>;
declare function cpuAcos(value: number): number;
declare function cpuAcos<T extends AnyFloatVecInstance>(value: T): T;
export declare const acos: import("../types.ts").DualFn<typeof cpuAcos>;
declare function cpuAcosh(value: number): number;
declare function cpuAcosh<T extends AnyFloatVecInstance>(value: T): T;
export declare const acosh: import("../types.ts").DualFn<typeof cpuAcosh>;
declare function cpuAsin(value: number): number;
declare function cpuAsin<T extends AnyFloatVecInstance>(value: T): T;
export declare const asin: import("../types.ts").DualFn<typeof cpuAsin>;
declare function cpuAsinh(value: number): number;
declare function cpuAsinh<T extends AnyFloatVecInstance>(value: T): T;
export declare const asinh: import("../types.ts").DualFn<typeof cpuAsinh>;
declare function cpuAtan(value: number): number;
declare function cpuAtan<T extends AnyFloatVecInstance>(value: T): T;
export declare const atan: import("../types.ts").DualFn<typeof cpuAtan>;
declare function cpuAtanh(value: number): number;
declare function cpuAtanh<T extends AnyFloatVecInstance>(value: T): T;
export declare const atanh: import("../types.ts").DualFn<typeof cpuAtanh>;
declare function cpuAtan2(y: number, x: number): number;
declare function cpuAtan2<T extends AnyFloatVecInstance>(y: T, x: T): T;
export declare const atan2: import("../types.ts").DualFn<typeof cpuAtan2>;
declare function cpuCeil(value: number): number;
declare function cpuCeil<T extends AnyFloatVecInstance>(value: T): T;
export declare const ceil: import("../types.ts").DualFn<typeof cpuCeil>;
declare function cpuClamp(value: number, low: number, high: number): number;
declare function cpuClamp<T extends NumVec | number>(value: T, low: T, high: T): T;
export declare const clamp: import("../types.ts").DualFn<typeof cpuClamp>;
declare function cpuCos(value: number): number;
declare function cpuCos<T extends AnyFloatVecInstance>(value: T): T;
export declare const cos: import("../types.ts").DualFn<typeof cpuCos>;
declare function cpuCosh(value: number): number;
declare function cpuCosh<T extends AnyFloatVecInstance>(value: T): T;
export declare const cosh: import("../types.ts").DualFn<typeof cpuCosh>;
declare function cpuCountLeadingZeros(value: number): number;
declare function cpuCountLeadingZeros<T extends AnyIntegerVecInstance>(value: T): T;
export declare const countLeadingZeros: import("../types.ts").DualFn<typeof cpuCountLeadingZeros>;
declare function cpuCountOneBits(value: number): number;
declare function cpuCountOneBits<T extends AnyIntegerVecInstance>(value: T): T;
export declare const countOneBits: import("../types.ts").DualFn<typeof cpuCountOneBits>;
declare function cpuCountTrailingZeros(value: number): number;
declare function cpuCountTrailingZeros<T extends AnyIntegerVecInstance>(value: T): T;
export declare const countTrailingZeros: import("../types.ts").DualFn<typeof cpuCountTrailingZeros>;
export declare const cross: import("../types.ts").DualFn<(<T extends v3f | v3h>(a: T, b: T) => T)>;
declare function cpuDegrees(value: number): number;
declare function cpuDegrees<T extends AnyFloatVecInstance>(value: T): T;
export declare const degrees: import("../types.ts").DualFn<typeof cpuDegrees>;
export declare const determinant: import("../types.ts").DualFn<(value: AnyMatInstance) => number>;
declare function cpuDistance(a: number, b: number): number;
declare function cpuDistance<T extends AnyFloatVecInstance>(a: T, b: T): number;
export declare const distance: import("../types.ts").DualFn<typeof cpuDistance>;
export declare const dot: import("../types.ts").DualFn<(<T extends NumVec>(lhs: T, rhs: T) => number)>;
export declare const dot4U8Packed: import("../types.ts").DualFn<(e1: number, e2: number) => number>;
export declare const dot4I8Packed: import("../types.ts").DualFn<(e1: number, e2: number) => number>;
declare function cpuExp(value: number): number;
declare function cpuExp<T extends AnyFloatVecInstance>(value: T): T;
export declare const exp: import("../types.ts").DualFn<typeof cpuExp>;
declare function cpuExp2(value: number): number;
declare function cpuExp2<T extends AnyFloatVecInstance>(value: T): T;
export declare const exp2: import("../types.ts").DualFn<typeof cpuExp2>;
declare function cpuExtractBits(e: number, offset: number, count: number): number;
declare function cpuExtractBits<T extends AnyIntegerVecInstance>(e: T, offset: number, count: number): T;
export declare const extractBits: import("../types.ts").DualFn<typeof cpuExtractBits>;
export declare const faceForward: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T) => T)>;
declare function cpuFirstLeadingBit(value: number): number;
declare function cpuFirstLeadingBit<T extends AnyIntegerVecInstance>(value: T): T;
export declare const firstLeadingBit: import("../types.ts").DualFn<typeof cpuFirstLeadingBit>;
declare function cpuFirstTrailingBit(value: number): number;
declare function cpuFirstTrailingBit<T extends AnyIntegerVecInstance>(value: T): T;
export declare const firstTrailingBit: import("../types.ts").DualFn<typeof cpuFirstTrailingBit>;
declare function cpuFloor(value: number): number;
declare function cpuFloor<T extends AnyFloatVecInstance>(value: T): T;
export declare const floor: import("../types.ts").DualFn<typeof cpuFloor>;
declare function cpuFma(e1: number, e2: number, e3: number): number;
declare function cpuFma<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
export declare const fma: import("../types.ts").DualFn<typeof cpuFma>;
declare function cpuFract(value: number): number;
declare function cpuFract<T extends AnyFloatVecInstance>(value: T): T;
export declare const fract: import("../types.ts").DualFn<typeof cpuFract>;
declare const FrexpResults: {
    readonly f32: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").F32;
        exp: import("../data/wgslTypes.ts").I32;
    }>;
    readonly f16: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").F16;
        exp: import("../data/wgslTypes.ts").I32;
    }>;
    readonly abstractFloat: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").AbstractFloat;
        exp: import("../data/wgslTypes.ts").AbstractInt;
    }>;
    readonly vec2f: import("../data/wgslTypes.ts").WgslStruct<{
        fract: Vec2f;
        exp: import("../data/wgslTypes.ts").Vec2i;
    }>;
    readonly vec3f: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec3f;
        exp: import("../data/wgslTypes.ts").Vec3i;
    }>;
    readonly vec4f: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec4f;
        exp: import("../data/wgslTypes.ts").Vec4i;
    }>;
    readonly vec2h: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec2h;
        exp: import("../data/wgslTypes.ts").Vec2i;
    }>;
    readonly vec3h: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec3h;
        exp: import("../data/wgslTypes.ts").Vec3i;
    }>;
    readonly vec4h: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec4h;
        exp: import("../data/wgslTypes.ts").Vec4i;
    }>;
};
type FrexpOverload = {
    (value: number): Infer<(typeof FrexpResults)['f32']>;
    <T extends AnyFloatVecInstance>(value: T): Infer<(typeof FrexpResults)[T['kind']]>;
};
export declare const frexp: import("../types.ts").DualFn<FrexpOverload>;
declare function cpuInsertBits(e: number, newbits: number, offset: number, count: number): number;
declare function cpuInsertBits<T extends AnyIntegerVecInstance>(e: T, newbits: T, offset: number, count: number): T;
export declare const insertBits: import("../types.ts").DualFn<typeof cpuInsertBits>;
declare function cpuInverseSqrt(value: number): number;
declare function cpuInverseSqrt<T extends AnyFloatVecInstance>(value: T): T;
export declare const inverseSqrt: import("../types.ts").DualFn<typeof cpuInverseSqrt>;
declare function cpuLdexp(e1: number, e2: number): number;
declare function cpuLdexp<T extends v2f | v2h>(e1: T, e2: v2i): T;
declare function cpuLdexp<T extends v3f | v3h>(e1: T, e2: v3i): T;
declare function cpuLdexp<T extends v4f | v4h>(e1: T, e2: v4i): T;
export declare const ldexp: import("../types.ts").DualFn<typeof cpuLdexp>;
declare function cpuLength(value: number): number;
declare function cpuLength<T extends AnyFloatVecInstance>(value: T): number;
export declare const length: import("../types.ts").DualFn<typeof cpuLength>;
declare function cpuLog(value: number): number;
declare function cpuLog<T extends AnyFloatVecInstance>(value: T): T;
export declare const log: import("../types.ts").DualFn<typeof cpuLog>;
declare function cpuLog2(value: number): number;
declare function cpuLog2<T extends AnyFloatVecInstance>(value: T): T;
export declare const log2: import("../types.ts").DualFn<typeof cpuLog2>;
type VariadicOverload = {
    (fst: number, ...rest: number[]): number;
    <T extends NumVec>(fst: T, ...rest: T[]): T;
};
export declare const max: import("../types.ts").DualFn<VariadicOverload>;
export declare const min: import("../types.ts").DualFn<VariadicOverload>;
declare function cpuMix(e1: number, e2: number, e3: number): number;
declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number): T;
declare function cpuMix<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: T): T;
export declare const mix: import("../types.ts").DualFn<typeof cpuMix>;
declare const ModfResult: {
    readonly f32: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").F32;
        whole: import("../data/wgslTypes.ts").F32;
    }>;
    readonly f16: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").F16;
        whole: import("../data/wgslTypes.ts").F16;
    }>;
    readonly abstractFloat: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").AbstractFloat;
        whole: import("../data/wgslTypes.ts").AbstractFloat;
    }>;
    readonly vec2f: import("../data/wgslTypes.ts").WgslStruct<{
        fract: Vec2f;
        whole: Vec2f;
    }>;
    readonly vec3f: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec3f;
        whole: import("../data/wgslTypes.ts").Vec3f;
    }>;
    readonly vec4f: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec4f;
        whole: import("../data/wgslTypes.ts").Vec4f;
    }>;
    readonly vec2h: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec2h;
        whole: import("../data/wgslTypes.ts").Vec2h;
    }>;
    readonly vec3h: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec3h;
        whole: import("../data/wgslTypes.ts").Vec3h;
    }>;
    readonly vec4h: import("../data/wgslTypes.ts").WgslStruct<{
        fract: import("../data/wgslTypes.ts").Vec4h;
        whole: import("../data/wgslTypes.ts").Vec4h;
    }>;
};
type ModfOverload = {
    (value: number): Infer<(typeof ModfResult)['f32']>;
    <T extends AnyFloatVecInstance>(value: T): Infer<(typeof ModfResult)[T['kind']]>;
};
export declare const modf: ModfOverload;
export declare const normalize: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(v: T) => T)>;
declare function powCpu(base: number, exponent: number): number;
declare function powCpu<T extends AnyFloatVecInstance>(base: T, exponent: T): T;
export declare const pow: import("../types.ts").DualFn<typeof powCpu>;
declare function cpuQuantizeToF16(value: number): number;
declare function cpuQuantizeToF16<T extends AnyFloat32VecInstance>(value: T): T;
export declare const quantizeToF16: import("../types.ts").DualFn<typeof cpuQuantizeToF16>;
declare function cpuRadians(value: number): number;
declare function cpuRadians<T extends AnyFloatVecInstance | number>(value: T): T;
export declare const radians: import("../types.ts").DualFn<typeof cpuRadians>;
export declare const reflect: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T) => T)>;
export declare const refract: import("../types.ts").DualFn<(<T extends AnyFloatVecInstance>(e1: T, e2: T, e3: number) => T)>;
declare function cpuReverseBits(value: number): number;
declare function cpuReverseBits<T extends AnyIntegerVecInstance>(value: T): T;
export declare const reverseBits: import("../types.ts").DualFn<typeof cpuReverseBits>;
declare function cpuRound(value: number): number;
declare function cpuRound<T extends AnyFloatVecInstance>(value: T): T;
export declare const round: import("../types.ts").DualFn<typeof cpuRound>;
declare function cpuSaturate(value: number): number;
declare function cpuSaturate<T extends AnyFloatVecInstance>(value: T): T;
export declare const saturate: import("../types.ts").DualFn<typeof cpuSaturate>;
declare function cpuSign(e: number): number;
declare function cpuSign<T extends AnySignedVecInstance>(e: T): T;
export declare const sign: import("../types.ts").DualFn<typeof cpuSign>;
declare function cpuSin(value: number): number;
declare function cpuSin<T extends AnyFloatVecInstance>(value: T): T;
export declare const sin: import("../types.ts").DualFn<typeof cpuSin>;
declare function cpuSinh(value: number): number;
declare function cpuSinh<T extends AnyFloatVecInstance>(value: T): T;
export declare const sinh: import("../types.ts").DualFn<typeof cpuSinh>;
declare function cpuSmoothstep(edge0: number, edge1: number, x: number): number;
declare function cpuSmoothstep<T extends AnyFloatVecInstance>(edge0: T, edge1: T, x: T): T;
export declare const smoothstep: import("../types.ts").DualFn<typeof cpuSmoothstep>;
declare function cpuSqrt(value: number): number;
declare function cpuSqrt<T extends AnyFloatVecInstance>(value: T): T;
export declare const sqrt: import("../types.ts").DualFn<typeof cpuSqrt>;
declare function cpuStep(edge: number, x: number): number;
declare function cpuStep<T extends AnyFloatVecInstance | number>(edge: T, x: T): T;
export declare const step: import("../types.ts").DualFn<typeof cpuStep>;
declare function cpuTan(value: number): number;
declare function cpuTan<T extends AnyFloatVecInstance>(value: T): T;
export declare const tan: import("../types.ts").DualFn<typeof cpuTan>;
declare function cpuTanh(value: number): number;
declare function cpuTanh<T extends AnyFloatVecInstance>(value: T): T;
export declare const tanh: import("../types.ts").DualFn<typeof cpuTanh>;
declare function cpuTranspose<T extends AnyMatInstance>(value: T): T;
export declare const transpose: import("../types.ts").DualFn<typeof cpuTranspose>;
declare function cpuTrunc(value: number): number;
declare function cpuTrunc<T extends AnyFloatVecInstance>(value: T): T;
export declare const trunc: import("../types.ts").DualFn<typeof cpuTrunc>;
declare function cpuIntdiv(lhs: number, rhs: number): number;
/**
 * Performs integer division on the passed in scalars.
 * Equivalent to `trunc(trunc(lhs) / trunc(rhs))`. Coerces both
 * arguments to integers if they're floating point.
 */
export declare const intdiv: import("../types.ts").DualFn<typeof cpuIntdiv>;
export {};