typegpu 0.10.0 → 0.10.2

package/std/numeric.js

@@ -0,0 +1,847 @@
+import { isHalfPrecisionSchema, isVecInstance } from "../data/wgslTypes.js";
+import { SignatureNotSupportedError } from "../errors.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { abstractFloat, abstractInt, f16, f32, i32, u32 } from "../data/numeric.js";
+import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
+import { abstruct } from "../data/struct.js";
+import { MissingCpuImplError, dualImpl } from "../core/function/dualImpl.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "../data/matrix.js";
+import { smoothstepScalar } from "../data/numberOps.js";
+import { VectorOps } from "../data/vectorOps.js";
+import { mul, sub } from "./operators.js";
+
+//#region src/std/numeric.ts
+const unaryIdentitySignature = (arg) => {
+	return {
+		argTypes: [arg],
+		returnType: arg
+	};
+};
+const variadicUnifySignature = (...args) => {
+	const uargs = unify(args) ?? args;
+	return {
+		argTypes: uargs,
+		returnType: uargs[0]
+	};
+};
+const unifyRestrictedSignature = (restrict) => (...args) => {
+	const uargs = unify(args, restrict);
+	if (!uargs) throw new SignatureNotSupportedError(args, restrict);
+	return {
+		argTypes: uargs,
+		returnType: uargs[0]
+	};
+};
+function variadicReduce(fn) {
+	return (fst, ...rest) => {
+		let acc = fst;
+		for (const r of rest) acc = fn(acc, r);
+		return acc;
+	};
+}
+function variadicStitch(wrapper) {
+	return (_ctx, [fst, ...rest]) => {
+		let acc = stitch`${fst}`;
+		for (const r of rest) acc = stitch`${wrapper}(${acc}, ${r})`;
+		return acc;
+	};
+}
+const anyFloatPrimitive = [
+	f32,
+	f16,
+	abstractFloat
+];
+const anyFloatVec = [
+	vec2f,
+	vec3f,
+	vec4f,
+	vec2h,
+	vec3h,
+	vec4h
+];
+const anyFloat = [...anyFloatPrimitive, ...anyFloatVec];
+const anyConcreteIntegerPrimitive = [i32, u32];
+const anyConcreteIntegerVec = [
+	vec2i,
+	vec3i,
+	vec4i,
+	vec2u,
+	vec3u,
+	vec4u
+];
+const anyConcreteInteger = [...anyConcreteIntegerPrimitive, ...anyConcreteIntegerVec];
+function cpuAbs(value) {
+	if (typeof value === "number") return Math.abs(value);
+	return VectorOps.abs[value.kind](value);
+}
+const abs = dualImpl({
+	name: "abs",
+	signature: unaryIdentitySignature,
+	normalImpl: cpuAbs,
+	codegenImpl: (_ctx, [value]) => stitch`abs(${value})`
+});
+function cpuAcos(value) {
+	if (typeof value === "number") return Math.acos(value);
+	return VectorOps.acos[value.kind](value);
+}
+const acos = dualImpl({
+	name: "acos",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAcos,
+	codegenImpl: (_ctx, [value]) => stitch`acos(${value})`
+});
+function cpuAcosh(value) {
+	if (typeof value === "number") return Math.acosh(value);
+	return VectorOps.acosh[value.kind](value);
+}
+const acosh = dualImpl({
+	name: "acosh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAcosh,
+	codegenImpl: (_ctx, [value]) => stitch`acosh(${value})`
+});
+function cpuAsin(value) {
+	if (typeof value === "number") return Math.asin(value);
+	return VectorOps.asin[value.kind](value);
+}
+const asin = dualImpl({
+	name: "asin",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAsin,
+	codegenImpl: (_ctx, [value]) => stitch`asin(${value})`
+});
+function cpuAsinh(value) {
+	if (typeof value === "number") return Math.asinh(value);
+	return VectorOps.asinh[value.kind](value);
+}
+const asinh = dualImpl({
+	name: "asinh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAsinh,
+	codegenImpl: (_ctx, [value]) => stitch`asinh(${value})`
+});
+function cpuAtan(value) {
+	if (typeof value === "number") return Math.atan(value);
+	return VectorOps.atan[value.kind](value);
+}
+const atan = dualImpl({
+	name: "atan",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAtan,
+	codegenImpl: (_ctx, [value]) => stitch`atan(${value})`
+});
+function cpuAtanh(value) {
+	if (typeof value === "number") return Math.atanh(value);
+	return VectorOps.atanh[value.kind](value);
+}
+const atanh = dualImpl({
+	name: "atanh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAtanh,
+	codegenImpl: (_ctx, [value]) => stitch`atanh(${value})`
+});
+function cpuAtan2(y, x) {
+	if (typeof y === "number" && typeof x === "number") return Math.atan2(y, x);
+	return VectorOps.atan2[y.kind](y, x);
+}
+const atan2 = dualImpl({
+	name: "atan2",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuAtan2,
+	codegenImpl: (_ctx, [y, x]) => stitch`atan2(${y}, ${x})`
+});
+function cpuCeil(value) {
+	if (typeof value === "number") return Math.ceil(value);
+	return VectorOps.ceil[value.kind](value);
+}
+const ceil = dualImpl({
+	name: "ceil",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuCeil,
+	codegenImpl: (_ctx, [value]) => stitch`ceil(${value})`
+});
+function cpuClamp(value, low, high) {
+	if (typeof value === "number") return Math.min(Math.max(low, value), high);
+	return VectorOps.clamp[value.kind](value, low, high);
+}
+const clamp = dualImpl({
+	name: "clamp",
+	signature: variadicUnifySignature,
+	normalImpl: cpuClamp,
+	codegenImpl: (_ctx, [value, low, high]) => stitch`clamp(${value}, ${low}, ${high})`
+});
+function cpuCos(value) {
+	if (typeof value === "number") return Math.cos(value);
+	return VectorOps.cos[value.kind](value);
+}
+const cos = dualImpl({
+	name: "cos",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuCos,
+	codegenImpl: (_ctx, [value]) => stitch`cos(${value})`
+});
+function cpuCosh(value) {
+	if (typeof value === "number") return Math.cosh(value);
+	return VectorOps.cosh[value.kind](value);
+}
+const cosh = dualImpl({
+	name: "cosh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuCosh,
+	codegenImpl: (_ctx, [value]) => stitch`cosh(${value})`
+});
+const countLeadingZeros = dualImpl({
+	name: "countLeadingZeros",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for countLeadingZeros not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`countLeadingZeros(${value})`
+});
+const countOneBits = dualImpl({
+	name: "countOneBits",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for countOneBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`countOneBits(${value})`
+});
+const countTrailingZeros = dualImpl({
+	name: "countTrailingZeros",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for countTrailingZeros not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`countTrailingZeros(${value})`
+});
+const cross = dualImpl({
+	name: "cross",
+	signature: unifyRestrictedSignature([vec3f, vec3h]),
+	normalImpl: (a, b) => VectorOps.cross[a.kind](a, b),
+	codegenImpl: (_ctx, [a, b]) => stitch`cross(${a}, ${b})`
+});
+function cpuDegrees(value) {
+	if (typeof value === "number") return value * 180 / Math.PI;
+	throw new MissingCpuImplError("CPU implementation for degrees on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const degrees = dualImpl({
+	name: "degrees",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuDegrees,
+	codegenImpl: (_ctx, [value]) => stitch`degrees(${value})`
+});
+const determinant = dualImpl({
+	name: "determinant",
+	signature: (arg) => {
+		if (!(arg.type === "mat2x2f" || arg.type === "mat3x3f" || arg.type === "mat4x4f")) throw new SignatureNotSupportedError([arg], [
+			mat2x2f,
+			mat3x3f,
+			mat4x4f
+		]);
+		return {
+			argTypes: [arg],
+			returnType: f32
+		};
+	},
+	normalImpl: "CPU implementation for determinant not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`determinant(${value})`
+});
+function cpuDistance(a, b) {
+	if (typeof a === "number" && typeof b === "number") return Math.abs(a - b);
+	return length(sub(a, b));
+}
+const distance = dualImpl({
+	name: "distance",
+	signature: (...args) => {
+		const uargs = unify(args, anyFloat);
+		if (!uargs) throw new SignatureNotSupportedError(args, anyFloat);
+		return {
+			argTypes: uargs,
+			returnType: isHalfPrecisionSchema(uargs[0]) ? f16 : f32
+		};
+	},
+	normalImpl: cpuDistance,
+	codegenImpl: (_ctx, [a, b]) => stitch`distance(${a}, ${b})`
+});
+const dot = dualImpl({
+	name: "dot",
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: args[0].primitive
+	}),
+	normalImpl: (lhs, rhs) => VectorOps.dot[lhs.kind](lhs, rhs),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`dot(${lhs}, ${rhs})`
+});
+const dot4U8Packed = dualImpl({
+	name: "dot4U8Packed",
+	signature: {
+		argTypes: [u32, u32],
+		returnType: u32
+	},
+	normalImpl: "CPU implementation for dot4U8Packed not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2]) => stitch`dot4U8Packed(${e1}, ${e2})`
+});
+const dot4I8Packed = dualImpl({
+	name: "dot4I8Packed",
+	signature: {
+		argTypes: [u32, u32],
+		returnType: i32
+	},
+	normalImpl: "CPU implementation for dot4I8Packed not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2]) => stitch`dot4I8Packed(${e1}, ${e2})`
+});
+function cpuExp(value) {
+	if (typeof value === "number") return Math.exp(value);
+	return VectorOps.exp[value.kind](value);
+}
+const exp = dualImpl({
+	name: "exp",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuExp,
+	codegenImpl: (_ctx, [value]) => stitch`exp(${value})`
+});
+function cpuExp2(value) {
+	if (typeof value === "number") return 2 ** value;
+	return VectorOps.exp2[value.kind](value);
+}
+const exp2 = dualImpl({
+	name: "exp2",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuExp2,
+	codegenImpl: (_ctx, [value]) => stitch`exp2(${value})`
+});
+const extractBits = dualImpl({
+	name: "extractBits",
+	signature: (arg, _offset, _count) => {
+		const argRestricted = unify([arg], anyConcreteInteger)?.[0];
+		if (!argRestricted) throw new SignatureNotSupportedError([arg], anyConcreteInteger);
+		return {
+			argTypes: [
+				argRestricted,
+				u32,
+				u32
+			],
+			returnType: argRestricted
+		};
+	},
+	normalImpl: "CPU implementation for extractBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e, offset, count]) => stitch`extractBits(${e}, ${offset}, ${count})`
+});
+const faceForward = dualImpl({
+	name: "faceForward",
+	signature: unifyRestrictedSignature(anyFloatVec),
+	normalImpl: "CPU implementation for faceForward not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`faceForward(${e1}, ${e2}, ${e3})`
+});
+const firstLeadingBit = dualImpl({
+	name: "firstLeadingBit",
+	signature: unaryIdentitySignature,
+	normalImpl: "CPU implementation for firstLeadingBit not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`firstLeadingBit(${value})`
+});
+const firstTrailingBit = dualImpl({
+	name: "firstTrailingBit",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for firstTrailingBit not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`firstTrailingBit(${value})`
+});
+function cpuFloor(value) {
+	if (typeof value === "number") return Math.floor(value);
+	return VectorOps.floor[value.kind](value);
+}
+const floor = dualImpl({
+	name: "floor",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuFloor,
+	codegenImpl: (_ctx, [arg]) => stitch`floor(${arg})`
+});
+function cpuFma(e1, e2, e3) {
+	if (typeof e1 === "number") return e1 * e2 + e3;
+	throw new MissingCpuImplError("CPU implementation for fma on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const fma = dualImpl({
+	name: "fma",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuFma,
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`fma(${e1}, ${e2}, ${e3})`
+});
+function cpuFract(value) {
+	if (typeof value === "number") return value - Math.floor(value);
+	return VectorOps.fract[value.kind](value);
+}
+const fract = dualImpl({
+	name: "fract",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuFract,
+	codegenImpl: (_ctx, [a]) => stitch`fract(${a})`
+});
+const FrexpResults = {
+	f32: abstruct({
+		fract: f32,
+		exp: i32
+	}),
+	f16: abstruct({
+		fract: f16,
+		exp: i32
+	}),
+	abstractFloat: abstruct({
+		fract: abstractFloat,
+		exp: abstractInt
+	}),
+	vec2f: abstruct({
+		fract: vec2f,
+		exp: vec2i
+	}),
+	vec3f: abstruct({
+		fract: vec3f,
+		exp: vec3i
+	}),
+	vec4f: abstruct({
+		fract: vec4f,
+		exp: vec4i
+	}),
+	vec2h: abstruct({
+		fract: vec2h,
+		exp: vec2i
+	}),
+	vec3h: abstruct({
+		fract: vec3h,
+		exp: vec3i
+	}),
+	vec4h: abstruct({
+		fract: vec4h,
+		exp: vec4i
+	})
+};
+const frexp = dualImpl({
+	name: "frexp",
+	normalImpl: "CPU implementation for frexp not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	signature: (value) => {
+		const returnType = FrexpResults[value.type];
+		if (!returnType) throw new SignatureNotSupportedError([value], anyFloat);
+		return {
+			argTypes: [value],
+			returnType
+		};
+	},
+	codegenImpl: (_ctx, [value]) => stitch`frexp(${value})`
+});
+const insertBits = dualImpl({
+	name: "insertBits",
+	signature: (e, newbits, _offset, _count) => {
+		const uargs = unify([e, newbits], anyConcreteInteger);
+		if (!uargs) throw new SignatureNotSupportedError([e, newbits], anyConcreteInteger);
+		return {
+			argTypes: [
+				...uargs,
+				u32,
+				u32
+			],
+			returnType: uargs[0]
+		};
+	},
+	normalImpl: "CPU implementation for insertBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e, newbits, offset, count]) => stitch`insertBits(${e}, ${newbits}, ${offset}, ${count})`
+});
+function cpuInverseSqrt(value) {
+	if (typeof value === "number") return 1 / Math.sqrt(value);
+	throw new MissingCpuImplError("CPU implementation for inverseSqrt on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const inverseSqrt = dualImpl({
+	name: "inverseSqrt",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuInverseSqrt,
+	codegenImpl: (_ctx, [value]) => stitch`inverseSqrt(${value})`
+});
+const ldexp = dualImpl({
+	name: "ldexp",
+	signature: (e1, _e2) => {
+		switch (e1.type) {
+			case "abstractFloat": return {
+				argTypes: [e1, abstractInt],
+				returnType: e1
+			};
+			case "f32":
+			case "f16": return {
+				argTypes: [e1, i32],
+				returnType: e1
+			};
+			case "vec2f":
+			case "vec2h": return {
+				argTypes: [e1, vec2i],
+				returnType: e1
+			};
+			case "vec3f":
+			case "vec3h": return {
+				argTypes: [e1, vec3i],
+				returnType: e1
+			};
+			case "vec4f":
+			case "vec4h": return {
+				argTypes: [e1, vec4i],
+				returnType: e1
+			};
+			default: throw new Error(`Unsupported data type for ldexp: ${e1.type}. Supported types are abstractFloat, f32, f16, vec2f, vec2h, vec3f, vec3h, vec4f, vec4h.`);
+		}
+	},
+	normalImpl: "CPU implementation for ldexp not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2]) => stitch`ldexp(${e1}, ${e2})`
+});
+function cpuLength(value) {
+	if (typeof value === "number") return Math.abs(value);
+	return VectorOps.length[value.kind](value);
+}
+const length = dualImpl({
+	name: "length",
+	signature: (arg) => {
+		const uarg = unify([arg], anyFloat);
+		if (!uarg) throw new SignatureNotSupportedError([arg], anyFloat);
+		return {
+			argTypes: uarg,
+			returnType: isHalfPrecisionSchema(uarg[0]) ? f16 : f32
+		};
+	},
+	normalImpl: cpuLength,
+	codegenImpl: (_ctx, [arg]) => stitch`length(${arg})`
+});
+function cpuLog(value) {
+	if (typeof value === "number") return Math.log(value);
+	return VectorOps.log[value.kind](value);
+}
+const log = dualImpl({
+	name: "log",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuLog,
+	codegenImpl: (_ctx, [value]) => stitch`log(${value})`
+});
+function cpuLog2(value) {
+	if (typeof value === "number") return Math.log2(value);
+	return VectorOps.log2[value.kind](value);
+}
+const log2 = dualImpl({
+	name: "log2",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuLog2,
+	codegenImpl: (_ctx, [value]) => stitch`log2(${value})`
+});
+function cpuMax(a, b) {
+	if (typeof a === "number") return Math.max(a, b);
+	return VectorOps.max[a.kind](a, b);
+}
+const max = dualImpl({
+	name: "max",
+	signature: variadicUnifySignature,
+	normalImpl: variadicReduce(cpuMax),
+	codegenImpl: variadicStitch("max")
+});
+function cpuMin(a, b) {
+	if (typeof a === "number") return Math.min(a, b);
+	return VectorOps.min[a.kind](a, b);
+}
+const min = dualImpl({
+	name: "min",
+	signature: variadicUnifySignature,
+	normalImpl: variadicReduce(cpuMin),
+	codegenImpl: variadicStitch("min")
+});
+function cpuMix(e1, e2, e3) {
+	if (typeof e1 === "number") {
+		if (typeof e3 !== "number" || typeof e2 !== "number") throw new Error("When e1 and e2 are numbers, the blend factor must be a number.");
+		return e1 * (1 - e3) + e2 * e3;
+	}
+	if (typeof e1 === "number" || typeof e2 === "number") throw new Error("e1 and e2 need to both be vectors of the same kind.");
+	return VectorOps.mix[e1.kind](e1, e2, e3);
+}
+const mix = dualImpl({
+	name: "mix",
+	signature: (e1, e2, e3) => {
+		if (e1.type.startsWith("vec") && !e3.type.startsWith("vec")) {
+			const uarg = unify([e3], [e1.primitive]);
+			if (!uarg) throw new SignatureNotSupportedError([e3], [e1.primitive]);
+			return {
+				argTypes: [
+					e1,
+					e2,
+					uarg[0]
+				],
+				returnType: e1
+			};
+		}
+		const uargs = unify([
+			e1,
+			e2,
+			e3
+		], anyFloat);
+		if (!uargs) throw new SignatureNotSupportedError([
+			e1,
+			e2,
+			e3
+		], anyFloat);
+		return {
+			argTypes: uargs,
+			returnType: uargs[0]
+		};
+	},
+	normalImpl: cpuMix,
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`mix(${e1}, ${e2}, ${e3})`
+});
+const ModfResult = {
+	f32: abstruct({
+		fract: f32,
+		whole: f32
+	}),
+	f16: abstruct({
+		fract: f16,
+		whole: f16
+	}),
+	abstractFloat: abstruct({
+		fract: abstractFloat,
+		whole: abstractFloat
+	}),
+	vec2f: abstruct({
+		fract: vec2f,
+		whole: vec2f
+	}),
+	vec3f: abstruct({
+		fract: vec3f,
+		whole: vec3f
+	}),
+	vec4f: abstruct({
+		fract: vec4f,
+		whole: vec4f
+	}),
+	vec2h: abstruct({
+		fract: vec2h,
+		whole: vec2h
+	}),
+	vec3h: abstruct({
+		fract: vec3h,
+		whole: vec3h
+	}),
+	vec4h: abstruct({
+		fract: vec4h,
+		whole: vec4h
+	})
+};
+const modf = dualImpl({
+	name: "modf",
+	signature: (e) => {
+		const returnType = ModfResult[e.type];
+		if (!returnType) throw new Error(`Unsupported data type for modf: ${e.type}. Supported types are f32, f16, abstractFloat, vec2f, vec3f, vec4f, vec2h, vec3h, vec4h.`);
+		return {
+			argTypes: [e],
+			returnType
+		};
+	},
+	normalImpl: "CPU implementation for modf not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`modf(${value})`
+});
+const normalize = dualImpl({
+	name: "normalize",
+	signature: unifyRestrictedSignature(anyFloatVec),
+	normalImpl: (v) => VectorOps.normalize[v.kind](v),
+	codegenImpl: (_ctx, [value]) => stitch`normalize(${value})`
+});
+function powCpu(base, exponent) {
+	if (typeof base === "number" && typeof exponent === "number") return base ** exponent;
+	if (isVecInstance(base) && isVecInstance(exponent)) return VectorOps.pow[base.kind](base, exponent);
+	throw new Error(`Invalid arguments to pow(): '${base}' '${exponent}'`);
+}
+const pow = dualImpl({
+	name: "pow",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: powCpu,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`pow(${lhs}, ${rhs})`
+});
+const quantizeToF16 = dualImpl({
+	name: "quantizeToF16",
+	signature: (arg) => {
+		const candidates = [
+			vec2f,
+			vec3f,
+			vec4f,
+			f32
+		];
+		const uarg = unify([arg], candidates)?.[0];
+		if (!uarg) throw new SignatureNotSupportedError([arg], candidates);
+		return {
+			argTypes: [uarg],
+			returnType: uarg
+		};
+	},
+	normalImpl: "CPU implementation for quantizeToF16 not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`quantizeToF16(${value})`
+});
+function cpuRadians(value) {
+	if (typeof value === "number") return value * Math.PI / 180;
+	throw new MissingCpuImplError("CPU implementation for radians on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const radians = dualImpl({
+	name: "radians",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuRadians,
+	codegenImpl: (_ctx, [value]) => stitch`radians(${value})`
+});
+const reflect = dualImpl({
+	name: "reflect",
+	signature: (...args) => {
+		const uargs = unify(args, anyFloatVec);
+		if (!uargs) throw new SignatureNotSupportedError(args, anyFloatVec);
+		return {
+			argTypes: uargs,
+			returnType: uargs[0]
+		};
+	},
+	normalImpl: (e1, e2) => sub(e1, mul(2 * dot(e2, e1), e2)),
+	codegenImpl: (_ctx, [e1, e2]) => stitch`reflect(${e1}, ${e2})`
+});
+const refract = dualImpl({
+	name: "refract",
+	normalImpl: "CPU implementation for refract not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e1, e2, e3]) => stitch`refract(${e1}, ${e2}, ${e3})`,
+	signature: (e1, e2, _e3) => ({
+		argTypes: [
+			e1,
+			e2,
+			isHalfPrecisionSchema(e1) ? f16 : f32
+		],
+		returnType: e1
+	})
+});
+const reverseBits = dualImpl({
+	name: "reverseBits",
+	signature: unifyRestrictedSignature(anyConcreteInteger),
+	normalImpl: "CPU implementation for reverseBits not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`reverseBits(${value})`
+});
+function cpuRound(value) {
+	if (typeof value === "number") {
+		const floor = Math.floor(value);
+		if (value === floor + .5) {
+			if (floor % 2 === 0) return floor;
+			return floor + 1;
+		}
+		return Math.round(value);
+	}
+	throw new MissingCpuImplError("CPU implementation for round on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const round = dualImpl({
+	name: "round",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuRound,
+	codegenImpl: (_ctx, [value]) => stitch`round(${value})`
+});
+function cpuSaturate(value) {
+	if (typeof value === "number") return Math.max(0, Math.min(1, value));
+	throw new MissingCpuImplError("CPU implementation for saturate on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const saturate = dualImpl({
+	name: "saturate",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSaturate,
+	codegenImpl: (_ctx, [value]) => stitch`saturate(${value})`
+});
+function cpuSign(e) {
+	if (typeof e === "number") return Math.sign(e);
+	return VectorOps.sign[e.kind](e);
+}
+const sign = dualImpl({
+	name: "sign",
+	signature: (arg) => {
+		const candidates = [
+			...anyFloat,
+			i32,
+			vec2i,
+			vec3i,
+			vec4i
+		];
+		const uarg = unify([arg], candidates)?.[0];
+		if (!uarg) throw new SignatureNotSupportedError([arg], candidates);
+		return {
+			argTypes: [uarg],
+			returnType: uarg
+		};
+	},
+	normalImpl: cpuSign,
+	codegenImpl: (_ctx, [e]) => stitch`sign(${e})`
+});
+function cpuSin(value) {
+	if (typeof value === "number") return Math.sin(value);
+	return VectorOps.sin[value.kind](value);
+}
+const sin = dualImpl({
+	name: "sin",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSin,
+	codegenImpl: (_ctx, [value]) => stitch`sin(${value})`
+});
+function cpuSinh(value) {
+	if (typeof value === "number") return Math.sinh(value);
+	throw new MissingCpuImplError("CPU implementation for sinh on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const sinh = dualImpl({
+	name: "sinh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSinh,
+	codegenImpl: (_ctx, [value]) => stitch`sinh(${value})`
+});
+function cpuSmoothstep(edge0, edge1, x) {
+	if (typeof x === "number") return smoothstepScalar(edge0, edge1, x);
+	return VectorOps.smoothstep[x.kind](edge0, edge1, x);
+}
+const smoothstep = dualImpl({
+	name: "smoothstep",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSmoothstep,
+	codegenImpl: (_ctx, [edge0, edge1, x]) => stitch`smoothstep(${edge0}, ${edge1}, ${x})`
+});
+function cpuSqrt(value) {
+	if (typeof value === "number") return Math.sqrt(value);
+	return VectorOps.sqrt[value.kind](value);
+}
+const sqrt = dualImpl({
+	name: "sqrt",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuSqrt,
+	codegenImpl: (_ctx, [value]) => stitch`sqrt(${value})`
+});
+function cpuStep(edge, x) {
+	if (typeof edge === "number") return edge <= x ? 1 : 0;
+	throw new MissingCpuImplError("CPU implementation for step on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const step = dualImpl({
+	name: "step",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuStep,
+	codegenImpl: (_ctx, [edge, x]) => stitch`step(${edge}, ${x})`
+});
+function cpuTan(value) {
+	if (typeof value === "number") return Math.tan(value);
+	throw new MissingCpuImplError("CPU implementation for tan on vectors not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues");
+}
+const tan = dualImpl({
+	name: "tan",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuTan,
+	codegenImpl: (_ctx, [value]) => stitch`tan(${value})`
+});
+function cpuTanh(value) {
+	if (typeof value === "number") return Math.tanh(value);
+	return VectorOps.tanh[value.kind](value);
+}
+const tanh = dualImpl({
+	name: "tanh",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: cpuTanh,
+	codegenImpl: (_ctx, [value]) => stitch`tanh(${value})`
+});
+const transpose = dualImpl({
+	name: "transpose",
+	signature: unaryIdentitySignature,
+	normalImpl: "CPU implementation for transpose not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [e]) => stitch`transpose(${e})`
+});
+const trunc = dualImpl({
+	name: "trunc",
+	signature: unifyRestrictedSignature(anyFloat),
+	normalImpl: "CPU implementation for trunc not implemented yet. Please submit an issue at https://github.com/software-mansion/TypeGPU/issues",
+	codegenImpl: (_ctx, [value]) => stitch`trunc(${value})`
+});
+
+//#endregion
+export { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc };