core :: core_arch :: arch :: loongarch64 :: lasx :: m256d

Struct `m256d`

#[repr(simd)]
pub struct m256d(pub(in ::core_arch::loongarch64::lasx::types) [f64; 4]);

256-bit wide set of four f64 values, LoongArch-specific

This type is the same as the __m256d type defined in lasxintrin.h, representing a 256-bit SIMD register which internally consists of four packed f64 instances. Usage of this type typically occurs in conjunction with the lasx target features for LoongArch.

Note that unlike m256i, the integer version of the 256-bit registers, this m256d type has one interpretation. Each instance of m256d always corresponds to f64x4, or four 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 m256d are prefixed with lasx_ and are suffixed with "d". Not to be confused with "d" which is used for m256i.

Fields

0: [f64; 4]

Implementations

`impl m256d`

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

Trait Implementations

`impl Clone for m256d`

fn clone(&self) -> m256d

`impl Copy for m256d`

`impl Debug for m256d`

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

`impl From<Simd<f64, 4>> for m256d`

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

`impl TrivialClone for m256d`

Auto Trait Implementations

`impl Freeze for m256d`

`impl RefUnwindSafe for m256d`

`impl Send for m256d`

`impl Sync for m256d`

`impl Unpin for m256d`

`impl UnsafeUnpin for m256d`

`impl UnwindSafe for m256d`

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

`impl<T> From<T> for m256d`

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

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

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

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

`impl<T> SizedTypeProperties for m256d`

`impl<T, U> Into for m256d 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 m256d where U: Into<T>,`

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

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

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