Struct libceed::vector::Vector

pub struct Vector<'a> { /* fields omitted */ }

Implementations

impl<'a> Vector<'a>

pub fn create(ceed: &'a Ceed, n: usize) -> Result<Self, CeedError>

pub fn from_slice(ceed: &'a Ceed, v: &[f64]) -> Result<Self, CeedError>

Create a Vector from a slice

arguments

• slice - values to initialize vector with

let vec = vector::Vector::from_slice(&ceed, &[1., 2., 3.]).unwrap();
assert_eq!(vec.length(), 3, "Incorrect length from slice");

pub fn from_array(ceed: &'a Ceed, v: &mut [f64]) -> Result<Self, CeedError>

Create a Vector from a mutable array reference

arguments

• slice - values to initialize vector with

let mut rust_vec = vec![1., 2., 3.];
let vec = libceed::vector::Vector::from_array(&ceed, &mut rust_vec).unwrap();

assert_eq!(vec.length(), 3, "Incorrect length from slice");

pub fn length(&self) -> usize

Returns the length of a CeedVector

let vec = ceed.vector(10).unwrap();

let n = vec.length();
assert_eq!(n, 10, "Incorrect length");

pub fn len(&self) -> usize

Returns the length of a CeedVector

let vec = ceed.vector(10).unwrap();
assert_eq!(vec.len(), 10, "Incorrect length");

pub fn set_value(&mut self, value: f64) -> Result<i32, CeedError>

Set the CeedVector to a constant value

arguments

• val - Value to be used

let len = 10;
let mut vec = ceed.vector(len).unwrap();

let val = 42.0;
vec.set_value(val).unwrap();

vec.view().iter().for_each(|v| {
    assert_eq!(*v, val, "Value not set correctly");
});

pub fn set_slice(&mut self, slice: &[f64]) -> Result<i32, CeedError>

Set values from a slice of the same length

arguments

• slice - values to into self; length must match

let mut vec = ceed.vector(4).unwrap();
vec.set_slice(&[10., 11., 12., 13.]).unwrap();

vec.view().iter().enumerate().for_each(|(i, v)| {
    assert_eq!(*v, 10. + i as f64, "Slice not set correctly");
});

pub fn sync(&self, mtype: MemType) -> Result<i32, CeedError>

Sync the CeedVector to a specified memtype

arguments

• mtype - Memtype to be synced

let len = 10;
let mut vec = ceed.vector(len).unwrap();

let val = 42.0;
vec.set_value(val);
vec.sync(MemType::Host).unwrap();

vec.view().iter().for_each(|v| {
    assert_eq!(*v, val, "Value not set correctly");
});

pub fn view(&self) -> VectorView<'_>

Create an immutable view

let vec = ceed.vector_from_slice(&[10., 11., 12., 13.]).unwrap();

let v = vec.view();
assert_eq!(v[0..2], [10., 11.]);

// It is valid to have multiple immutable views
let w = vec.view();
assert_eq!(v[1..], w[1..]);

pub fn view_mut(&mut self) -> VectorViewMut<'_>

Create an mutable view

let mut vec = ceed.vector_from_slice(&[10., 11., 12., 13.]).unwrap();

{
    let mut v = vec.view_mut();
    v[2] = 9.;
}

let w = vec.view();
assert_eq!(w[2], 9., "View did not mutate data");

pub fn norm(&self, ntype: NormType) -> Result<f64, CeedError>

Return the norm of a CeedVector

arguments

• ntype - Norm type One, Two, or Max

let vec = ceed.vector_from_slice(&[1., 2., 3., 4.]).unwrap();

let max_norm = vec.norm(NormType::Max).unwrap();
assert_eq!(max_norm, 4.0, "Incorrect Max norm");

let l1_norm = vec.norm(NormType::One).unwrap();
assert_eq!(l1_norm, 10., "Incorrect L1 norm");

let l2_norm = vec.norm(NormType::Two).unwrap();
assert!((l2_norm - 5.477) < 1e-3, "Incorrect L2 norm");

pub fn scale(self, alpha: f64) -> Result<Self, CeedError>

Compute x = alpha x for a CeedVector

arguments

• alpha - scaling factor

let mut vec = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();

vec = vec.scale(-1.0).unwrap();
vec.view().iter().enumerate().for_each(|(i, &v)| {
    assert_eq!(v, -(i as f64), "Value not set correctly");
});

pub fn axpy(self, alpha: f64, x: &Vector<'_>) -> Result<Self, CeedError>

Compute y = alpha x + y for a pair of CeedVectors

arguments

• alpha - scaling factor
• x - second vector, must be different than self

let x = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();
let mut y = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();

y = y.axpy(-0.5, &x).unwrap();
y.view().iter().enumerate().for_each(|(i, &v)| {
    assert_eq!(v, (i as f64) / 2.0, "Value not set correctly");
});

pub fn pointwise_mult(
    self,
    x: &Vector<'_>,
    y: &Vector<'_>
) -> Result<Self, CeedError>

Compute the pointwise multiplication w = x .* y for CeedVectors

arguments

• x - first vector for product
• y - second vector for product

let mut w = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();
let x = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();
let y = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();

w = w.pointwise_mult(&x, &y).unwrap();
w.view().iter().enumerate().for_each(|(i, &v)| {
    assert_eq!(v, (i as f64).powf(2.0), "Value not set correctly");
});

pub fn pointwise_scale(self, x: &Vector<'_>) -> Result<Self, CeedError>

Compute the pointwise multiplication w = w .* x for CeedVectors

arguments

• x - second vector for product

let mut w = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();
let x = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();

w = w.pointwise_scale(&x).unwrap();
w.view().iter().enumerate().for_each(|(i, &v)| {
    assert_eq!(v, (i as f64).powf(2.0), "Value not set correctly");
});

pub fn pointwise_square(self) -> Result<Self, CeedError>

Compute the pointwise multiplication w = w .* w for a CeedVector

let mut w = ceed.vector_from_slice(&[0., 1., 2., 3., 4.]).unwrap();

w = w.pointwise_square().unwrap();
w.view().iter().enumerate().for_each(|(i, &v)| {
    assert_eq!(v, (i as f64).powf(2.0), "Value not set correctly");
});

Trait Implementations

impl<'a> Debug for Vector<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Vector<'a>

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

View a Vector

let vec = libceed::vector::Vector::from_slice(&ceed, &[1., 2., 3.]).unwrap();
assert_eq!(
    vec.to_string(),
    "CeedVector length 3
    1.00000000
    2.00000000
    3.00000000
"
)

impl<'a> Drop for Vector<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl From<&'_ Vector<'_>> for *mut CeedVector_private

fn from(vec: &Vector<'_>) -> Self

Performs the conversion.

impl<'a> From<&'a Vector<'_>> for VectorOpt<'a>

Construct a VectorOpt reference from a Vector reference

fn from(vec: &'a Vector<'_>) -> Self

Performs the conversion.