Struct safe_arch::m256i

#[repr(transparent)]pub struct m256i(pub __m256i);

The data for a 256-bit AVX register of integer data.

• The exact layout to view the type as depends on the operation used.
• From and Into impls are provided for all the relevant signed integer array types.
• Formatting impls print as four i32 values just because they have to pick something. If you want an alternative you can turn it into an array and print as you like.

Trait Implementations

impl Binary for m256i

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

Binary formats each i32.

let f = format!("{:b}", m256i::default());
assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");

impl BitAnd<m256i> for m256i

type Output = Self

The resulting type after applying the & operator.

#[must_use]fn bitand(self, rhs: Self) -> Self

let a = m256i::from([0_i64, 0, 1, 1]);
let b = m256i::from([0_i64, 1, 0, 1]);
let c: [i64; 4] = (a & b).into();
assert_eq!(c, [0_i64, 0, 0, 1]);

impl BitAndAssign<m256i> for m256i

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<m256i> for m256i

type Output = Self

The resulting type after applying the | operator.

#[must_use]fn bitor(self, rhs: Self) -> Self

let a = m256i::from([0_i64, 0, 1, 1]);
let b = m256i::from([0_i64, 1, 0, 1]);
let c: [i64; 4] = (a | b).into();
assert_eq!(c, [0_i64, 1, 1, 1]);

impl BitOrAssign<m256i> for m256i

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<m256i> for m256i

type Output = Self

The resulting type after applying the ^ operator.

#[must_use]fn bitxor(self, rhs: Self) -> Self

let a = m256i::from([0_i64, 0, 1, 1]);
let b = m256i::from([0_i64, 1, 0, 1]);
let c: [i64; 4] = (a ^ b).into();
assert_eq!(c, [0_i64, 1, 1, 0]);

impl BitXorAssign<m256i> for m256i

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for m256i

#[must_use]fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for m256i

impl Debug for m256i

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

Debug formats each i32.

let f = format!("{:?}", m256i::default());
assert_eq!(&f, "m256i(0, 0, 0, 0, 0, 0, 0, 0)");

impl Default for m256i

#[must_use]fn default() -> Self

Returns the "default value" for a type.

impl Display for m256i

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

Display formats each i32, and leaves the type name off of the font.

let f = format!("{}", m256i::default());
assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");

impl Eq for m256i

impl From<[i128; 2]> for m256i

#[must_use]fn from(i: [i128; 2]) -> Self

Performs the conversion.

impl From<[i16; 16]> for m256i

#[must_use]fn from(arr: [i16; 16]) -> Self

Performs the conversion.

impl From<[i32; 8]> for m256i

#[must_use]fn from(arr: [i32; 8]) -> Self

Performs the conversion.

impl From<[i64; 4]> for m256i

#[must_use]fn from(arr: [i64; 4]) -> Self

Performs the conversion.

impl From<[i8; 32]> for m256i

#[must_use]fn from(arr: [i8; 32]) -> Self

Performs the conversion.

impl From<[u128; 2]> for m256i

#[must_use]fn from(u: [u128; 2]) -> Self

Performs the conversion.

impl From<[u16; 16]> for m256i

#[must_use]fn from(arr: [u16; 16]) -> Self

Performs the conversion.

impl From<[u32; 8]> for m256i

#[must_use]fn from(arr: [u32; 8]) -> Self

Performs the conversion.

impl From<[u64; 4]> for m256i

#[must_use]fn from(arr: [u64; 4]) -> Self

Performs the conversion.

impl From<[u8; 32]> for m256i

#[must_use]fn from(arr: [u8; 32]) -> Self

Performs the conversion.

impl From<m256i> for [i8; 32]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [u8; 32]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [i16; 16]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [u16; 16]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [i32; 8]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [u32; 8]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [i64; 4]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [u64; 4]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [i128; 2]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl From<m256i> for [u128; 2]

#[must_use]fn from(m: m256i) -> Self

Performs the conversion.

impl LowerExp for m256i

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

LowerExp formats each i32.

let f = format!("{:e}", m256i::default());
assert_eq!(&f, "(0e0, 0e0, 0e0, 0e0, 0e0, 0e0, 0e0, 0e0)");

impl LowerHex for m256i

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

LowerHex formats each i32.

let f = format!("{:x}", m256i::default());
assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");

impl Not for m256i

type Output = Self

The resulting type after applying the ! operator.

#[must_use]fn not(self) -> Self

Not a direct intrinsic, but it's very useful and the implementation is simple enough.

Negates the bits by performing an xor with an all-1s bit pattern.

let a = m256i::from([0_u128, 0]);
let c: [u128; 2] = (!a).into();
assert_eq!(c, [u128::MAX, u128::MAX]);

impl Octal for m256i

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

Octal formats each i32.

let f = format!("{:o}", m256i::default());
assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");

impl PartialEq<m256i> for m256i

#[must_use]fn eq(&self, other: &Self) -> bool

let a = m256i::from([0_i64, 0, 1, 1]);
let b = m256i::from([0_i64, 1, 0, 1]);
assert_eq!(a, a);
assert_ne!(a, b);

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Pod for m256i

impl TransparentWrapper<__m256i> for m256i

fn wrap_ref(s: &Wrapped) -> &Self

Convert a reference to a wrapped type into a reference to the wrapper.

fn wrap_mut(s: &mut Wrapped) -> &mut Self

Convert a mut reference to a wrapped type into a mut reference to the wrapper.

impl UpperExp for m256i

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

UpperExp formats each i32.

let f = format!("{:E}", m256i::default());
assert_eq!(&f, "(0E0, 0E0, 0E0, 0E0, 0E0, 0E0, 0E0, 0E0)");

impl UpperHex for m256i

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

UpperHex formats each i32.

let f = format!("{:X}", m256i::default());
assert_eq!(&f, "(0, 0, 0, 0, 0, 0, 0, 0)");

impl Zeroable for m256i

fn zeroed() -> Self

Calls zeroed.