Struct f64x8 Copy item path

Performs a multiply-add operation: self * m + a

When hardware FMA support is available, this computes the result with a single rounding operation. Without FMA support, it falls back to separate multiply and add operations with two roundings.

§Platform-specific behavior

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfmadd (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses (self * m) + a (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

§Examples

let a = f64x8::from([1.0; 8]);
let b = f64x8::from([2.0; 8]);
let c = f64x8::from([10.0; 8]);

let result = a.mul_add(b, c);

let expected = f64x8::from([12.0; 8]);
assert_eq!(result, expected);

Performs a multiply-subtract operation: self * m - s

When hardware FMA support is available, this computes the result with a single rounding operation. Without FMA support, it falls back to separate multiply and subtract operations with two roundings.

§Platform-specific behavior

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfmsub (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses (self * m) - s (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

§Examples

let a = f64x8::from([10.0; 8]);
let b = f64x8::from([3.0; 8]);
let c = f64x8::from([5.0; 8]);

let result = a.mul_sub(b, c);

let expected = f64x8::from([25.0; 8]);
assert_eq!(result, expected);

Performs a negative multiply-add operation: a - (self * m)

When hardware FMA support is available, this computes the result with a single rounding operation. Without FMA support, it falls back to separate operations with two roundings.

§Platform-specific behavior

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfnmadd (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses a - (self * m) (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

§Examples

let a = f64x8::from([4.0; 8]);
let b = f64x8::from([2.0; 8]);
let c = f64x8::from([10.0; 8]);

let result = a.mul_neg_add(b, c);

let expected = f64x8::from([2.0; 8]);
assert_eq!(result, expected);

Performs a negative multiply-subtract operation: -(self * m) - s

When hardware FMA support is available, this computes the result with a single rounding operation. Without FMA support, it falls back to separate operations with two roundings.

§Platform-specific behavior

• On x86/x86_64 with AVX-512F+FMA: Uses 512-bit vfnmsub (single rounding, best accuracy)
• On x86/x86_64 with AVX-512F only: Uses -(self * m) - s (two roundings)
• Other platforms: Delegates to f64x4 (inherits its FMA behavior)

§Examples

let a = f64x8::from([4.0; 8]);
let b = f64x8::from([2.0; 8]);
let c = f64x8::from([1.0; 8]);

let result = a.mul_neg_sub(b, c);

let expected = f64x8::from([-9.0; 8]);
assert_eq!(result, expected);

Calculate the exponent of a packed f64x8

Natural log (ln(x))

Splats the single value given across all lanes.

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.