faer 0.24.0

linear algebra library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#![allow(non_snake_case)]
use dyn_stack::{MemBuffer, MemStack, StackReq};
use faer::mat::AsMatMut;
use faer::prelude::*;
use faer::{Accum, dyn_stack};
fn foo_scratch(n: usize) -> StackReq {
	let tmp = faer::linalg::temp_mat_scratch::<f64>(n, n);
	let llt = faer::linalg::cholesky::llt::factor::cholesky_in_place_scratch::<
		f64,
	>(n, Par::Seq, default());
	tmp.and(StackReq::any_of(&[tmp.and(llt), tmp]))
}
// A <- A * B
fn foo(mut A: MatMut<'_, f64>, B: MatRef<'_, f64>, stack: &mut MemStack) {
	let n = A.nrows();
	let (mut tmp0, stack) =
		unsafe { faer::linalg::temp_mat_uninit(n, n, stack) };
	let mut tmp0: MatMut<'_, f64> = tmp0.as_mat_mut();
	{
		let (mut tmp1, stack) =
			unsafe { faer::linalg::temp_mat_uninit(n, n, stack) };
		let _tmp1: MatMut<'_, f64> = tmp1.as_mat_mut();
		faer::linalg::matmul::matmul(
			&mut tmp0,
			Accum::Replace,
			&A,
			&B,
			1.0,
			Par::Seq,
		);
		A.copy_from(&tmp0);
		let _ = faer::linalg::cholesky::llt::factor::cholesky_in_place(
			A.rb_mut(),
			default(),
			Par::Seq,
			stack,
			default(),
		);
	}
	let (_tmp1, _) =
		unsafe { faer::linalg::temp_mat_uninit::<f64, _, _>(n, n, stack) };
}
fn main() {
	let n = 128;
	let nthreads = 100;
	let scratch = foo_scratch(n);
	let mut workspace = MemBuffer::new(scratch);
	let stack = MemStack::new(&mut workspace);
	//          stack
	// [....................]
	// let (mut stacks, mut stack) = stack.make_with(nthreads, |_|
	// MemStack::new(&mut [])); stacks    stack
	// [...][.................]
	// for i in 0..nthreads {
	// 	let scratch = foo_scratch(n);
	// 	let new;
	// 	(new, stack) = stack.make_aligned_uninit(scratch.size_bytes(),
	// scratch.align_bytes()); 	// stacks foo_scratch  stack
	// 	// [...][..][..][..][....]
	// 	stacks[i] = MemStack::new(new);
	// }
	// stacks    foo_scratch
	// [...][..][..][..][..][..]
	// use rayon::prelude::*;
	(0..nthreads).into_iter().for_each(|_| {
		let mut A = Mat::zeros(n, n);
		let B = Mat::zeros(n, n);
		foo(A.as_mut(), B.as_ref(), stack);
	});
}