Skip to content

simdDiv ​

simdDiv divide los elementos correspondientes y devuelve un array nuevo en Result<T[], SimdError>.

FirmasimdDiv<T>(left: T[], right: T[]): Result<T[], SimdError>
tyrus
import { simdDiv, SimdError } from "tyrus:simd";

const left: i32[] = [100, 81, 72, 55, 42];
const right: i32[] = [10, 9, 8, 5, 6];
const result: Result<i32[], SimdError> = simdDiv(left, right);

match (result) {
    Ok(values) => {
        print(values); // [10, 9, 9, 11, 7]
    }
    Err(error) => {
        printError(error.code, error.message);
    }
}

Floating-point division follows IEEE behavior. Dividing nonzero values by 0.0 produces infinity, and 0.0 / 0.0 produces NaN; these results are returned in Ok.

La división entera trunca hacia cero. Si cualquier lane entera tiene divisor cero, el resultado es ERR_SIMD_DIVISION_BY_ZERO. El mínimo signed dividido por -1 devuelve ERR_SIMD_INTEGER_OVERFLOW, porque el cociente exacto no cabe en el tipo de la lane. La operación verifica todas las lanes enteras antes de la división, así ninguna lane inválida llega a una división entera. La división de punto flotante sigue IEEE y devuelve infinito o NaN en Ok cuando corresponde. Las diferencias de tamaño dinámico y los fallos al asignar el resultado también devuelven SimdError. Los arrays de tamaño fijo se pueden pasar directamente; las longitudes fijas distintas se rechazan con E0308 en compilación.

División de punto flotante por cero ​

La división de punto flotante por cero sigue IEEE 754 y devuelve estos valores en Ok: 1.0 / 0.0 produce Infinity, -1.0 / 0.0 produce -Infinity y 0.0 / 0.0 produce NaN.

tyrus
import { simdDiv, SimdError } from "tyrus:simd";

const main = (): void => {
    const numerators: f32[] = [1.0, -1.0, 0.0];
    const denominators: f32[] = [0.0; 3];
    const result: Result<f32[], SimdError> = simdDiv(numerators, denominators);

    match (result) {
        Ok(values) => {
            print(values); // [Infinity, -Infinity, NaN]
        }
        Err(error) => {
            printError(error.code, error.message);
        }
    }
};

Errores ​

error

Un divisor entero igual a cero devuelve un error recuperable:

tyrus
import { simdDiv, SimdError } from "tyrus:simd";

const left: i32[] = [100, 81, 72, 55];
const right: i32[] = [10, 0, 8, 5];
const result: Result<i32[], SimdError> = simdDiv(left, right);

match (result) {
    Ok(values) => { print(values); }
    Err(error) => { printError(error.code, error.message); }
}
text
ERR_SIMD_DIVISION_BY_ZERO simdDiv cannot divide an integer lane by zero

error

El mínimo signed dividido por -1 también devuelve un error recuperable:

tyrus
import { simdDiv, SimdError } from "tyrus:simd";

const left: i8[] = [-128; 1];
const right: i8[] = [-1; 1];
const result: Result<i8[], SimdError> = simdDiv(left, right);

match (result) {
    Ok(values) => { print(values); }
    Err(error) => { printError(error.code, error.message); }
}
text
ERR_SIMD_INTEGER_OVERFLOW simdDiv cannot represent the signed minimum divided by -1