core :: core_arch :: arch :: loongarch64 :: lsx :: m128d

Struct `m128d`

#[repr(simd)]
pub struct m128d(pub(in ::core_arch::loongarch64::lsx::types) [f64; 2]);

128-bit wide set of two f64 values, LoongArch-specific

This type is the same as the __m128d type defined in lsxintrin.h, representing a 128-bit SIMD register which internally consists of two packed f64 instances. Usage of this type typically occurs in conjunction with the lsx and higher target features for LoongArch.

Note that unlike m128i, the integer version of the 128-bit registers, this m128d type has one interpretation. Each instance of m128d always corresponds to f64x2, or two f64 values packed together.

The in-memory representation of this type is the same as the one of an equivalent array (i.e. the in-memory order of elements is the same, and there is no padding); however, the alignment is different and equal to the size of the type. Note that the ABI for function calls may not be the same.

Most intrinsics using m128d are prefixed with lsx_ and are suffixed with "d". Not to be confused with "d" which is used for m128i.

Fields

0: [f64; 2]

Implementations

`impl m128d`

fn splat(value: f64) -> m128d: Put the same value in every lane.
const fn as_array(&self) -> &[f64; 2]: Returns an array reference containing the entire SIMD vector.
fn as_mut_array(&mut self) -> &mut [f64; 2]: Returns a mutable array reference containing the entire SIMD vector.

Trait Implementations

`impl Clone for m128d`

fn clone(&self) -> m128d

`impl Copy for m128d`

`impl Debug for m128d`

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

`impl From<Simd<f64, 2>> for m128d`

fn from(simd: Simd<f64, 2>) -> Self

`impl TrivialClone for m128d`

Auto Trait Implementations

`impl Freeze for m128d`

`impl RefUnwindSafe for m128d`

`impl Send for m128d`

`impl Sync for m128d`

`impl Unpin for m128d`

`impl UnsafeUnpin for m128d`

`impl UnwindSafe for m128d`

Blanket Implementations

`impl<T> Any for m128d where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for m128d where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for m128d where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for m128d where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for m128d`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Printable for m128d where T: Copy + Debug,`

`impl<T> SizeHint for m128d where T: ?Sized,`

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

`impl<T> SizedTypeProperties for m128d`

`impl<T, U> Into for m128d where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

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

`impl<T, U> TryFrom for m128d where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for m128d where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>