Struct LVec 

pub struct LVec<T: Clone + Send + Sync + 'static> { /* private fields */ }

A parallelized vector container with deferred execution.

LVec is the main data structure in Leopard. It represents a vector that supports parallel operations through deferred execution. Operations on LVec are recorded when called between LQueue::start and LQueue::end, and executed in bulk when end() is called.

Creating LVec

LVec instances must be created through an LQueue:

use leopard::{LQueue, LVec};

let q = LQueue::new();
let vec: LVec<f64> = q.lvec_with_capacity(1000);

Operations

All operations must be called between q.start() and q.end():

• Initialization: fill, fill_with
• Transformation: map, map_where
• Arithmetic: +, -, *, / operators
• Masking: blend, masked_apply, masked_fill

Retrieving Results

After q.end(), use materialize to get the computed data:

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(10);

q.start();
let x = x.fill_with(|i| i as f64);
q.end();

let data = x.materialize().unwrap();
println!("{:?}", &data[..]);

Pending State

After an operation is recorded, the resulting LVec is in a “pending” state. The actual data is not available until after q.end() is called and materialize is used to retrieve it.

Implementations

impl<T: Clone + Send + Sync + 'static> LVec<T>

pub fn len(&self) -> usize

Returns the length of the vector.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let vec: LVec<f64> = q.lvec_with_capacity(100);
assert_eq!(vec.len(), 100);

pub fn is_empty(&self) -> bool

Returns true if the vector has no elements.

pub fn capacity(&self) -> usize

Returns the capacity of the vector.

pub fn is_pending(&self) -> bool

Returns true if this vector has a pending operation.

A pending vector’s data is not yet available. Call materialize after LQueue::end to retrieve the computed data.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(10);
assert!(!x.is_pending());

q.start();
let y = x.fill(1.0);
assert!(y.is_pending());
q.end();

pub fn materialize(&self) -> Option<Arc<Vec<T>>>

Retrieves the computed data after LQueue::end has been called.

For pending vectors (those created by operations), this returns the computed result. For non-pending vectors, this returns the original data.

Returns

• Some(Arc<Vec<T>>) if the data is available
• None if the vector is pending and q.end() hasn’t been called

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(5);

q.start();
let x = x.fill_with(|i| i as f64 * 2.0);
q.end();

let data = x.materialize().unwrap();
assert_eq!(&data[..], &[0.0, 2.0, 4.0, 6.0, 8.0]);

pub fn as_slice(&self) -> &[T]

Returns the data as a slice.

Warning

For pending vectors, this returns an empty or default-initialized slice, not the computed result. Use materialize after LQueue::end to get the actual computed data.

pub fn fill_with<F>(&self, f: F) -> Self

where F: Fn(usize) -> T + Send + Sync + 'static,

Fills the vector using a closure that takes an index.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• f - A closure that takes an index usize and returns the value T

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(5);

q.start();
let x = x.fill_with(|i| i as f64 * 10.0);
q.end();

let data = x.materialize().unwrap();
assert_eq!(&data[..], &[0.0, 10.0, 20.0, 30.0, 40.0]);

pub fn fill(&self, value: T) -> Self

Fills the vector with a constant value.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• value - The value to fill the vector with

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<i32> = q.lvec_with_capacity(5);

q.start();
let x = x.fill(42);
q.end();

let data = x.materialize().unwrap();
assert_eq!(&data[..], &[42, 42, 42, 42, 42]);

pub fn map<F>(&self, f: F) -> Self

where F: Fn(usize, &T) -> T + Send + Sync + 'static,

Transforms each element using a closure.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• f - A closure that takes an index and a reference to the element, and returns the transformed value

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<f64> = q.lvec_with_capacity(5);

q.start();
let x = x.fill_with(|i| i as f64);
let y = x.map(|_, v| v * v);  // Square each element
q.end();

let data = y.materialize().unwrap();
assert_eq!(&data[..], &[0.0, 1.0, 4.0, 9.0, 16.0]);

pub fn map_where<C, TF, FF>( &self, condition: C, if_true: TF, if_false: FF, ) -> Self

where C: Fn(usize, &T) -> bool + Send + Sync + 'static, TF: Fn(usize, &T) -> T + Send + Sync + 'static, FF: Fn(usize, &T) -> T + Send + Sync + 'static,

Applies different transformations based on a condition.

For each element, if the condition returns true, if_true is applied; otherwise, if_false is applied. This is SIMD-style branchless conditional execution.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• condition - A closure that returns true or false for each element
• if_true - Transformation to apply when condition is true
• if_false - Transformation to apply when condition is false

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<i32> = q.lvec_with_capacity(6);

q.start();
let x = x.fill_with(|i| i as i32 + 1);
let y = x.map_where(
    |_, v| *v % 2 == 0,  // Is even?
    |_, v| v * 10,       // If even: multiply by 10
    |_, v| v + 1000,     // If odd: add 1000
);
q.end();

let data = y.materialize().unwrap();
// [1, 2, 3, 4, 5, 6] -> [1001, 20, 1003, 40, 1005, 60]

pub fn mask<F>(&self, predicate: F) -> LMask

where F: Fn(usize, &T) -> bool,

Creates a mask from a predicate applied to each element.

Unlike other operations, this executes immediately (not recorded) because masks are needed to define subsequent masking operations.

Arguments

• predicate - A closure that returns true or false for each element

Warning

This only works on non-pending vectors. For pending vectors, use LMask::from_fn with the appropriate pattern.

Examples

use leopard::{LQueue, LVec};

let q = LQueue::new();
let x: LVec<i32> = q.lvec_with_capacity(10);

// Note: mask() works on the initial (non-pending) vector
let mask = x.mask(|i, _| i >= 5);

pub fn blend(&self, other: &Self, mask: &LMask) -> Self

Blends two vectors using a mask (SIMD-style select).

For each element, if the mask is true, the value from other is used; otherwise, the value from self is used.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• other - The vector to blend with
• mask - The mask determining which vector to select from

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec, LMask};

let q = LQueue::new();
let a: LVec<i32> = q.lvec_with_capacity(5);
let b: LVec<i32> = q.lvec_with_capacity(5);
let mask = LMask::from_fn(5, |i| i >= 3);

q.start();
let a = a.fill(1);
let b = b.fill(100);
let c = a.blend(&b, &mask);
q.end();

let data = c.materialize().unwrap();
// mask: [false, false, false, true, true]
// result: [1, 1, 1, 100, 100]

pub fn select(mask: &LMask, if_true: &Self, if_false: &Self) -> Self

Selects between two vectors based on a mask.

This is equivalent to if_false.blend(if_true, mask).

Arguments

• mask - The mask determining which vector to select from
• if_true - Values to use where mask is true
• if_false - Values to use where mask is false

Panics

Panics if called outside of a start()/end() block.

pub fn masked_apply<F>(&self, mask: &LMask, f: F) -> Self

where F: Fn(usize, &T) -> T + Send + Sync + 'static,

Applies a function only where the mask is true.

Elements where the mask is false retain their original values.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• mask - The mask determining where to apply the function
• f - The function to apply

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec, LMask};

let q = LQueue::new();
let x: LVec<i32> = q.lvec_with_capacity(5);
let mask = LMask::from_fn(5, |i| i >= 3);

q.start();
let x = x.fill_with(|i| i as i32);
let y = x.masked_apply(&mask, |_, v| v * 100);
q.end();

let data = y.materialize().unwrap();
// [0, 1, 2, 3, 4] with mask [F, F, F, T, T]
// result: [0, 1, 2, 300, 400]

pub fn masked_fill(&self, mask: &LMask, value: T) -> Self

where T: 'static,

Fills with a constant value only where the mask is true.

Elements where the mask is false retain their original values.

This is a recorded operation that must be called between LQueue::start and LQueue::end.

Arguments

• mask - The mask determining where to fill
• value - The value to fill with

Panics

Panics if called outside of a start()/end() block.

Examples

use leopard::{LQueue, LVec, LMask};

let q = LQueue::new();
let x: LVec<i32> = q.lvec_with_capacity(5);
let mask = LMask::from_fn(5, |i| i >= 3);

q.start();
let x = x.fill_with(|i| i as i32);
let y = x.masked_fill(&mask, 999);
q.end();

let data = y.materialize().unwrap();
// [0, 1, 2, 3, 4] with mask [F, F, F, T, T]
// result: [0, 1, 2, 999, 999]

Trait Implementations

impl<T> Add for &LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn add(self, other: Self) -> Self::Output

Adds two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the + operator.

impl<T> Add for LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn add(self, other: Self) -> Self::Output

Adds two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the + operator.

impl<T: Clone + Clone + Send + Sync + 'static> Clone for LVec<T>

fn clone(&self) -> LVec<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone + Send + Sync + Debug + 'static> Debug for LVec<T>

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

Formats the value using the given formatter.

impl<T: Clone + Send + Sync + Default + 'static> Default for LVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Div for &LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn div(self, other: Self) -> Self::Output

Divides two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the / operator.

impl<T> Div for LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn div(self, other: Self) -> Self::Output

Divides two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the / operator.

impl<T: Clone + Send + Sync + 'static> Index<usize> for LVec<T>

fn index(&self, index: usize) -> &Self::Output

Accesses the element at the given index.

Warning

For pending vectors, this accesses the original (uncomputed) data, not the result of the pending operation. Use materialize after LQueue::end to get the computed data.

Panics

Panics if index >= self.len().

type Output = T

The returned type after indexing.

impl<T> Mul for &LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn mul(self, other: Self) -> Self::Output

Multiplies two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the * operator.

impl<T> Mul for LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn mul(self, other: Self) -> Self::Output

Multiplies two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the * operator.

impl<T> Sub for &LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn sub(self, other: Self) -> Self::Output

Subtracts two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the - operator.

impl<T> Sub for LVec<T>

where T: Clone + Send + Sync + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Div<Output = T> + 'static,

fn sub(self, other: Self) -> Self::Output

Subtracts two vectors element-wise (recorded operation).

type Output = LVec<T>

The resulting type after applying the - operator.