Struct m128i

#[repr(transparent)]
pub struct m128i(pub __m128i);

Available on crate feature dep_safe_arch only.

safe_arch The data for a 128-bit SSE register of integer data.

Re-exported from the safe_arch crate .

---

The data for a 128-bit SSE 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.

Tuple Fields

0: __m128i

Trait Implementations

impl Binary for m128i

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

Binary formats each i32.

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

impl BitAnd for m128i

type Output = m128i

The resulting type after applying the & operator.

fn bitand(self, rhs: m128i) -> m128i

Performs the & operation.

impl BitAndAssign for m128i

fn bitand_assign(&mut self, rhs: m128i)

Performs the &= operation.

impl BitOr for m128i

type Output = m128i

The resulting type after applying the | operator.

fn bitor(self, rhs: m128i) -> m128i

Performs the | operation.

impl BitOrAssign for m128i

fn bitor_assign(&mut self, rhs: m128i)

Performs the |= operation.

impl BitXor for m128i

type Output = m128i

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: m128i) -> m128i

Performs the ^ operation.

impl BitXorAssign for m128i

fn bitxor_assign(&mut self, rhs: m128i)

Performs the ^= operation.

impl Clone for m128i

fn clone(&self) -> m128i

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for m128i

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

Debug formats each i32.

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

impl Default for m128i

fn default() -> m128i

Returns the “default value” for a type.

impl Display for m128i

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

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

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

impl From<[i16; 8]> for m128i

fn from(arr: [i16; 8]) -> m128i

Converts to this type from the input type.

impl From<[i32; 4]> for m128i

fn from(arr: [i32; 4]) -> m128i

Converts to this type from the input type.

impl From<[i64; 2]> for m128i

fn from(arr: [i64; 2]) -> m128i

Converts to this type from the input type.

impl From<[i8; 16]> for m128i

fn from(arr: [i8; 16]) -> m128i

Converts to this type from the input type.

impl From<[u16; 8]> for m128i

fn from(arr: [u16; 8]) -> m128i

Converts to this type from the input type.

impl From<[u32; 4]> for m128i

fn from(arr: [u32; 4]) -> m128i

Converts to this type from the input type.

impl From<[u64; 2]> for m128i

fn from(arr: [u64; 2]) -> m128i

Converts to this type from the input type.

impl From<[u8; 16]> for m128i

fn from(arr: [u8; 16]) -> m128i

Converts to this type from the input type.

impl From<i128> for m128i

fn from(i: i128) -> m128i

Converts to this type from the input type.

impl From<m128i> for [i16; 8]

fn from(m: m128i) -> [i16; 8]

Converts to this type from the input type.

impl From<m128i> for [i32; 4]

fn from(m: m128i) -> [i32; 4]

Converts to this type from the input type.

impl From<m128i> for [i64; 2]

fn from(m: m128i) -> [i64; 2]

Converts to this type from the input type.

impl From<m128i> for [i8; 16]

fn from(m: m128i) -> [i8; 16]

Converts to this type from the input type.

impl From<m128i> for [u16; 8]

fn from(m: m128i) -> [u16; 8]

Converts to this type from the input type.

impl From<m128i> for [u32; 4]

fn from(m: m128i) -> [u32; 4]

Converts to this type from the input type.

impl From<m128i> for [u64; 2]

fn from(m: m128i) -> [u64; 2]

Converts to this type from the input type.

impl From<m128i> for [u8; 16]

fn from(m: m128i) -> [u8; 16]

Converts to this type from the input type.

impl From<m128i> for i128

fn from(m: m128i) -> i128

Converts to this type from the input type.

impl From<m128i> for u128

fn from(m: m128i) -> u128

Converts to this type from the input type.

impl From<u128> for m128i

fn from(u: u128) -> m128i

Converts to this type from the input type.

impl LowerExp for m128i

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

LowerExp formats each i32.

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

impl LowerHex for m128i

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

LowerHex formats each i32.

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

impl Not for m128i

fn not(self) -> m128i

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.

type Output = m128i

The resulting type after applying the ! operator.

impl Octal for m128i

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

Octal formats each i32.

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

impl PartialEq for m128i

fn eq(&self, other: &m128i) -> bool

Not a direct intrinsic, this is a cmp_eq_mask_i8_m128i and then a move_mask_i8_m128i.

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 TransparentWrapper<__m128i> for m128i

fn wrap(s: Inner) -> Self

where Self: Sized,

Convert the inner type into the wrapper type.

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

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

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

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

where Self: Sized,

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

where Self: Sized,

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

where Self: Sized,

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

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

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

where Self: Sized,

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

where Self: Sized,

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl UpperExp for m128i

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

UpperExp formats each i32.

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

impl UpperHex for m128i

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

UpperHex formats each i32.

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

impl Zeroable for m128i

fn zeroed() -> Self

Calls zeroed.

impl Copy for m128i

impl Eq for m128i

Unlike with the floating types, ints have absolute equality.

impl Pod for m128i