Struct Lane4_i32Example 

pub struct Lane4_i32Example<T>(pub [T; 4]);

Available on crate feature _docs_examples only.

✨ ⌗ ⅀ Example fixed-width pack of 4 × i32 lanes.

---

^{📍 num/grain}

---

Generated with lane!.

Methods

• Common methods for all integers and floating-point primitives

  • from_byte_values.
  • from_slice.
  • splat.
  • add_assign (plain, simd, wide).
  • sub_assign (plain, simd, wide).
  • mul_assign (plain, simd, wide).
  • rem_assign (plain).
  • div_assign (plain, simd).
  • neg_assign.
  • add_scalar_assign (plain).
  • sub_scalar_assign (plain).
  • mul_scalar_assign (plain).
  • rem_scalar_assign (plain).
  • div_scalar_assign (plain).
  • min (plain, wide).
  • max (plain, wide).
  • clamp_assign (plain).
  • min_reduce (plain).
  • max_reduce (plain).
  • sum (plain).

• Methods for integer primitives

  • div_assign.
  • neg_assign_plain.
  • saturating_add_assign_plain.
  • wrapping_add_assign_plain.
  • saturating_sub_assign_plain.
  • wrapping_sub_assign_plain.
  • wrapping_mul_assign_plain.
  • bitand_assign (plain, simd, wide).
  • bitor_assign (plain, simd, wide).
  • bitxor_assign (plain, simd, wide).
  • shl_assign (plain, simd, wide).
  • shr_assign (plain, simd, wide).
  • min_simd.
  • max_simd.

Tuple Fields

0: [T; 4]

Implementations

impl Lane4_i32Example<i32>

Common methods for all integers and floating-point primitives.

pub const fn from_byte_values(bytes: &[u8]) -> Self

Builds a lane pack from the first 4 bytes of a byte slice.

Panics

Panics if bytes.len() < 4.

pub const fn from_slice(slice: &[i32]) -> Self

Builds a lane pack from the first 4 elements of a slice.

Panics

Panics if slice.len() < 4.

pub const fn splat(v: i32) -> Self

Fills all lanes with the same value.

pub fn add_assign(&mut self, rhs: Self)

Adds each lane of rhs to the corresponding lane in self.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn add_assign_plain(&mut self, rhs: Self)

Adds each lane of rhs to the corresponding lane in self.

Panics

Panics on integer overflow (debug and const only).

pub fn add_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Adds each lane of rhs to the corresponding lane in self using SIMD.

Performs elementwise addition with the semantics of the underlying element type.

Integer addition wraps on overflow; floating-point follows IEEE-754 rules.

pub fn add_assign_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Adds each lane of rhs to the corresponding lane in self using SIMD.

Performs elementwise addition with the semantics of the underlying element type.

Integer addition wraps on overflow; floating-point follows IEEE-754 rules.

pub fn sub_assign(&mut self, rhs: Self)

Subtracts each lane of rhs from the corresponding lane in self.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn sub_assign_plain(&mut self, rhs: Self)

Subtracts each lane of rhs from the corresponding lane in self.

Panics

Panics on integer overflow (debug and const only).

pub fn sub_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Subtracts each lane of rhs from the corresponding lane in self using SIMD.

Performs elementwise subtraction with the semantics of the underlying element type.

Integer subtraction wraps on overflow; floating-point follows IEEE-754 rules.

pub fn sub_assign_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Subtracts each lane of rhs from the corresponding lane in self using SIMD.

Performs elementwise subtraction with the semantics of the underlying element type.

Integer subtraction wraps on overflow; floating-point follows IEEE-754 rules.

pub fn mul_assign(&mut self, rhs: Self)

Multiplies each lane of self by the corresponding lane of rhs.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn mul_assign_plain(&mut self, rhs: Self)

Multiplies each lane of self by the corresponding lane of rhs.

Panics

Panics on integer overflow (debug and const only).

pub fn mul_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Multiplies each lane of self by the corresponding lane of rhs using SIMD.

Performs elementwise multiplication with the semantics of the underlying element type.

Integer multiplication wraps on overflow; floating-point follows IEEE-754 rules.

pub fn mul_assign_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Multiplies each lane of self by the corresponding lane of rhs using SIMD.

Performs elementwise multiplication with the semantics of the underlying element type.

Integer multiplication wraps on overflow; floating-point follows IEEE-754 rules.

pub fn rem_assign(&mut self, rhs: Self)

Applies elementwise modular reduction.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn rem_assign_plain(&mut self, rhs: Self)

Applies elementwise modular reduction.

Panics

Panics if any divisor is zero.

pub const fn div_assign_plain(&mut self, rhs: Self)

Divides each lane by the corresponding lane in rhs (truncating division).

Panics

Panics if any divisor is zero or on signed integer overflow.

pub fn div_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Divides each lane of self by the corresponding lane of rhs using SIMD.

Applies elementwise division following IEEE-754 semantics. Not available for integer types.

pub fn neg_assign(&mut self)

Negates each lane in place.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub fn add_scalar_assign(&mut self, rhs: i32)

Adds the scalar rhs to each lane in self.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn add_scalar_assign_plain(&mut self, rhs: i32)

Adds the scalar rhs to each lane in self.

Panics

Panics on integer overflow (debug and const only).

pub fn sub_scalar_assign(&mut self, rhs: i32)

Subtracts the scalar rhs from each lane in self.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn sub_scalar_assign_plain(&mut self, rhs: i32)

Subtracts the scalar rhs from each lane in self.

Panics

Panics on integer overflow (debug and const only).

pub fn mul_scalar_assign(&mut self, rhs: i32)

Multiplies each lane by the scalar rhs.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn mul_scalar_assign_plain(&mut self, rhs: i32)

Multiplies each lane by the scalar rhs.

Panics

Panics on integer overflow (debug and const only).

pub fn rem_scalar_assign(&mut self, rhs: i32)

Applies scalar modular reduction to each lane.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn rem_scalar_assign_plain(&mut self, rhs: i32)

Applies scalar modular reduction to each lane.

Panics

Panics if rhs == 0.

pub fn div_scalar_assign(&mut self, rhs: i32)

Divides each lane by the scalar rhs (truncating division).

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn div_scalar_assign_plain(&mut self, rhs: i32)

Divides each lane by the scalar rhs (truncating division).

Panics

Panics if rhs == 0 or on signed integer overflow.

pub fn min(&mut self, rhs: Self)

Returns the minimum lane value.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn min_plain(&mut self, rhs: Self)

Returns the minimum lane value.

pub fn min_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Returns the minimum value across all lanes using SIMD acceleration.

Follows the comparison semantics of the underlying element type.

pub fn max(&mut self, rhs: Self)

Returns the maximum lane value.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn max_plain(&mut self, rhs: Self)

Returns the maximum lane value.

pub fn max_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Returns the maximum value across all lanes using SIMD acceleration.

Follows the comparison semantics of the underlying element type.

pub fn clamp_assign(&mut self, lo: i32, hi: i32)

Clamps each lane to the inclusive [lo, hi] range.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn clamp_assign_plain(&mut self, lo: i32, hi: i32)

Clamps each lane to the inclusive [lo, hi] range.

pub const fn min_reduce_plain(&self) -> i32

Returns the horizontal minimum of all lanes.

pub const fn max_reduce_plain(&self) -> i32

Returns the horizontal maximum of all lanes.

pub fn sum(&mut self)

Returns the sum of all lanes.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn sum_plain(&self) -> i32

Returns the sum of all lanes.

impl Lane4_i32Example<i32>

Methods for integer primitives.

pub fn div_assign(&mut self, rhs: Self)

Divides each lane by the corresponding lane in rhs (truncating division).

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn neg_assign_plain(&mut self)

Negates each lane in place.

Panics

Panics on integer overflow (debug and const only).

For signed integers, overflow occurs when the value is the minimum representable integer. Unsigned integers wrap according to two’s complement semantics.

pub const fn saturating_add_assign_plain(&mut self, rhs: Self)

Adds each lane of rhs to the corresponding lane in self, saturating on overflow.

pub const fn wrapping_add_assign_plain(&mut self, rhs: Self)

Adds each lane of rhs to the corresponding lane in self, wrapping on overflow.

pub const fn saturating_sub_assign_plain(&mut self, rhs: Self)

Subtracts each lane of rhs from the corresponding lane in self, saturating on overflow.

pub const fn wrapping_sub_assign_plain(&mut self, rhs: Self)

Subtracts each lane of rhs from the corresponding lane in self, wrapping on overflow.

pub const fn wrapping_mul_assign_plain(&mut self, rhs: Self)

Multiplies each lane of rhs by the corresponding lane in self, wrapping on overflow.

pub fn bitand_assign(&mut self, rhs: Self)

Bitwise AND each lane with the corresponding lane in rhs.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn bitand_assign_plain(&mut self, rhs: Self)

Bitwise AND each lane with the corresponding lane in rhs.

pub fn bitand_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Applies a bitwise AND between each lane of self and rhs using SIMD.

pub fn bitand_assign_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Applies a bitwise AND between each lane of self and rhs using SIMD.

pub fn bitor_assign(&mut self, rhs: Self)

Bitwise OR each lane with the corresponding lane in rhs.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn bitor_assign_plain(&mut self, rhs: Self)

Bitwise OR each lane with the corresponding lane in rhs.

pub fn bitor_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Applies a bitwise OR between each lane of self and rhs using SIMD.

pub fn bitor_assign_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Applies a bitwise OR between each lane of self and rhs using SIMD.

pub fn bitxor_assign(&mut self, rhs: Self)

Bitwise XOR each lane with the corresponding lane in rhs.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn bitxor_assign_plain(&mut self, rhs: Self)

Bitwise XOR each lane with the corresponding lane in rhs.

pub fn bitxor_assign_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Applies a bitwise XOR between each lane of self and rhs using SIMD.

pub fn bitxor_assign_wide(&mut self, rhs: Self)

Available on crate feature dep_wide only.

Applies a bitwise XOR between each lane of self and rhs using SIMD.

pub fn shl_assign(&mut self, n: i32)

Shifts each lane left by n.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn shl_assign_plain(&mut self, n: i32)

Shifts each lane left by n.

pub fn shl_assign_simd(&mut self, n: i32)

Available on nightly_simd only.

Shifts each lane in self left by the scalar amount rhs using SIMD.

Uses the shift semantics of the underlying integer type.

pub fn shl_assign_wide(&mut self, n: i32)

Available on crate feature dep_wide only.

Shifts each lane in self left by the scalar amount rhs using SIMD.

Uses the shift semantics of the underlying integer type.

pub fn shr_assign(&mut self, n: i32)

Shifts each lane right by n.

This method is a thin wrapper over the best available alternative (simd→wide→plain)

pub const fn shr_assign_plain(&mut self, n: i32)

Shifts each lane right by n.

Performs an arithmetic right shift for signed integers, and a logical right shift for unsigned integers.

pub fn shr_assign_simd(&mut self, n: i32)

Available on nightly_simd only.

Shifts each lane in self right by the scalar amount rhs using SIMD.

Applies arithmetic right shift for signed integers and logical right shift for unsigned integers.

pub fn shr_assign_wide(&mut self, n: i32)

Available on crate feature dep_wide only.

Shifts each lane in self right by the scalar amount rhs using SIMD.

Applies arithmetic right shift for signed integers and logical right shift for unsigned integers.

pub fn min_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Returns the minimum value across all lanes using SIMD acceleration.

Follows the comparison semantics of the underlying element type.

pub fn max_simd(&mut self, rhs: Self)

Available on nightly_simd only.

Returns the maximum value across all lanes using SIMD acceleration.

Follows the comparison semantics of the underlying element type.

Trait Implementations

impl AddAssign for Lane4_i32Example<i32>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AddAssign<i32> for Lane4_i32Example<i32>

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<T: Clone> Clone for Lane4_i32Example<T>

fn clone(&self) -> Lane4_i32Example<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: ConstInit> ConstInit for Lane4_i32Example<T>

const INIT: Self

Returns the compile-time “initial value” for a type.

impl<T: Copy> Copy for Lane4_i32Example<T>

impl<T: Debug> Debug for Lane4_i32Example<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MulAssign for Lane4_i32Example<i32>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<i32> for Lane4_i32Example<i32>

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<T: PartialEq> PartialEq for Lane4_i32Example<T>

fn eq(&self, other: &Lane4_i32Example<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RemAssign for Lane4_i32Example<i32>

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl RemAssign<i32> for Lane4_i32Example<i32>

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<T> StructuralPartialEq for Lane4_i32Example<T>

impl SubAssign for Lane4_i32Example<i32>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubAssign<i32> for Lane4_i32Example<i32>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.