diff --git a/Cargo.toml b/Cargo.toml index 2173b12..0ab511f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,9 +2,8 @@ nightly = ["pulp/nightly"] # Treat warnings as a build error. strict = [] -sleef = ["rlst/sleef"] default = [] -mpi = ["dep:mpi", "dep:bempp-distributed-tools", "rlst/mpi"] +mpi = ["dep:mpi", "rlst/mpi"] [package] @@ -28,23 +27,21 @@ crate-type = ["lib", "staticlib", "cdylib"] paste = "1.*" libc = "0.2" approx = { version = "0.5", features = ["num-complex"] } -rayon = "1.9" +rayon = "1.11" num = "0.4" num_cpus = "1" rlst = { git = "https://github.com/linalg-rs/rlst.git" } -# rlst = { path = "../rlst", features = ["mpi"] } -rand = "0.8.5" -itertools = { version = "0.13.0", default-features = false } +rand = "0.9" +itertools = { version = "0.14", default-features = false } coe-rs = "0.1.2" -pulp = { version = "0.21" } -bytemuck = "1.16.0" +pulp = { version = "0.22" } +bytemuck = "1.24.0" hexf = "0.2.1" -mpi = { version = "0.8.*", optional = true } -bempp-distributed-tools = { git = "https://github.com/bempp/distributed_tools.git", optional = true } +mpi = { git = "https://github.com/rsmpi/rsmpi.git", optional = true } [dev-dependencies] -criterion = { version = "0.5.1", features = ["html_reports"] } -rand_chacha = "0.3" +criterion = { version = "0.7", features = ["html_reports"] } +rand_chacha = "0.9" [package.metadata.docs.rs] cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"] @@ -53,12 +50,12 @@ cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"] wildcard_imports = "forbid" [target.aarch64-apple-darwin.dev-dependencies] -blas-src = { version = "0.10", features = ["accelerate"]} -lapack-src = { version = "0.10", features = ["accelerate"]} +blas-src = { version = "0.14", features = ["accelerate"]} +lapack-src = { version = "0.13", features = ["accelerate"]} [target.x86_64-unknown-linux-gnu.dev-dependencies] -blas-src = { version = "0.10", features = ["blis"]} -lapack-src = { version = "0.10", features = ["netlib"]} +blas-src = { version = "0.14", features = ["blis"]} +lapack-src = { version = "0.13", features = ["netlib"]} [[bench]] diff --git a/benches/helmholtz_c32.rs b/benches/helmholtz_c32.rs index 78eaa5a..7029536 100644 --- a/benches/helmholtz_c32.rs +++ b/benches/helmholtz_c32.rs @@ -3,28 +3,28 @@ use criterion::{criterion_group, criterion_main, Criterion}; extern crate blas_src; extern crate lapack_src; -use rlst::prelude::*; - use green_kernels::helmholtz_3d::Helmholtz3dKernel; use green_kernels::traits::Kernel; use green_kernels::types::GreenKernelEvalType; use rand::SeedableRng; +use rlst::c32; +use rlst::rlst_dynamic_array; const NPOINTS: usize = 1000; pub fn helmholtz_c32_test_standard(c: &mut Criterion) { let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, NPOINTS]); - let mut targets = rlst_dynamic_array2!(f32, [3, NPOINTS]); + let mut sources = rlst_dynamic_array!(f32, [3, NPOINTS]); + let mut targets = rlst_dynamic_array!(f32, [3, NPOINTS]); - let mut charges = rlst_dynamic_array1!(c32, [NPOINTS]); + let mut charges = rlst_dynamic_array!(c32, [NPOINTS]); - let mut result = rlst_dynamic_array1!(c32, [NPOINTS]); + let mut result = rlst_dynamic_array!(c32, [NPOINTS]); sources.fill_from_equally_distributed(&mut rng); - targets.fill_from(sources.r()); + targets.fill_from(&sources); charges.fill_from_standard_normal(&mut rng); @@ -32,10 +32,10 @@ pub fn helmholtz_c32_test_standard(c: &mut Criterion) { b.iter(|| { Helmholtz3dKernel::::new(1.0).evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + result.data_mut().unwrap(), ); }) }); diff --git a/benches/helmholtz_c64.rs b/benches/helmholtz_c64.rs index d2292dc..30f7f86 100644 --- a/benches/helmholtz_c64.rs +++ b/benches/helmholtz_c64.rs @@ -3,7 +3,8 @@ use criterion::{criterion_group, criterion_main, Criterion}; extern crate blas_src; extern crate lapack_src; -use rlst::prelude::*; +use rlst::c64; +use rlst::rlst_dynamic_array; use green_kernels::helmholtz_3d::Helmholtz3dKernel; use green_kernels::traits::Kernel; @@ -16,15 +17,15 @@ const NPOINTS: usize = 1000; pub fn helmholtz_c64_test_standard(c: &mut Criterion) { let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, NPOINTS]); - let mut targets = rlst_dynamic_array2!(f64, [3, NPOINTS]); + let mut sources = rlst_dynamic_array!(f64, [3, NPOINTS]); + let mut targets = rlst_dynamic_array!(f64, [3, NPOINTS]); - let mut charges = rlst_dynamic_array1!(c64, [NPOINTS]); + let mut charges = rlst_dynamic_array!(c64, [NPOINTS]); - let mut result = rlst_dynamic_array1!(c64, [NPOINTS]); + let mut result = rlst_dynamic_array!(c64, [NPOINTS]); sources.fill_from_equally_distributed(&mut rng); - targets.fill_from(sources.r()); + targets.fill_from(&sources); charges.fill_from_standard_normal(&mut rng); @@ -32,10 +33,10 @@ pub fn helmholtz_c64_test_standard(c: &mut Criterion) { b.iter(|| { Helmholtz3dKernel::::new(1.0).evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + result.data_mut().unwrap(), ); }) }); diff --git a/benches/laplace_f32.rs b/benches/laplace_f32.rs index 4f75d3d..a3c6130 100644 --- a/benches/laplace_f32.rs +++ b/benches/laplace_f32.rs @@ -3,28 +3,27 @@ use criterion::{criterion_group, criterion_main, Criterion}; extern crate blas_src; extern crate lapack_src; -use rlst::prelude::*; - use green_kernels::laplace_3d::Laplace3dKernel; use green_kernels::traits::Kernel; use green_kernels::types::GreenKernelEvalType; use rand::SeedableRng; +use rlst::rlst_dynamic_array; const NPOINTS: usize = 1000; pub fn laplace_f32_test_standard(c: &mut Criterion) { let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, NPOINTS]); - let mut targets = rlst_dynamic_array2!(f32, [3, NPOINTS]); + let mut sources = rlst_dynamic_array!(f32, [3, NPOINTS]); + let mut targets = rlst_dynamic_array!(f32, [3, NPOINTS]); - let mut charges = rlst_dynamic_array1!(f32, [NPOINTS]); + let mut charges = rlst_dynamic_array!(f32, [NPOINTS]); - let mut result = rlst_dynamic_array1!(f32, [NPOINTS]); + let mut result = rlst_dynamic_array!(f32, [NPOINTS]); sources.fill_from_equally_distributed(&mut rng); - targets.fill_from(sources.r()); + targets.fill_from(&sources); charges.fill_from_standard_normal(&mut rng); @@ -32,10 +31,10 @@ pub fn laplace_f32_test_standard(c: &mut Criterion) { b.iter(|| { Laplace3dKernel::::new().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + result.data_mut().unwrap(), ); }) }); diff --git a/benches/laplace_f64.rs b/benches/laplace_f64.rs index cf612f4..efd486b 100644 --- a/benches/laplace_f64.rs +++ b/benches/laplace_f64.rs @@ -3,28 +3,27 @@ use criterion::{criterion_group, criterion_main, Criterion}; extern crate blas_src; extern crate lapack_src; -use rlst::prelude::*; - use green_kernels::laplace_3d::Laplace3dKernel; use green_kernels::traits::Kernel; use green_kernels::types::GreenKernelEvalType; use rand::SeedableRng; +use rlst::rlst_dynamic_array; const NPOINTS: usize = 1000; pub fn laplace_f64_test_standard(c: &mut Criterion) { let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, NPOINTS]); - let mut targets = rlst_dynamic_array2!(f64, [3, NPOINTS]); + let mut sources = rlst_dynamic_array!(f64, [3, NPOINTS]); + let mut targets = rlst_dynamic_array!(f64, [3, NPOINTS]); - let mut charges = rlst_dynamic_array1!(f64, [NPOINTS]); + let mut charges = rlst_dynamic_array!(f64, [NPOINTS]); - let mut result = rlst_dynamic_array1!(f64, [NPOINTS]); + let mut result = rlst_dynamic_array!(f64, [NPOINTS]); sources.fill_from_equally_distributed(&mut rng); - targets.fill_from(sources.r()); + targets.fill_from(&sources); charges.fill_from_standard_normal(&mut rng); @@ -32,10 +31,10 @@ pub fn laplace_f64_test_standard(c: &mut Criterion) { b.iter(|| { Laplace3dKernel::::new().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + result.data_mut().unwrap(), ); }) }); diff --git a/examples/evaluate_distributed.rs b/examples/evaluate_distributed.rs index 5099ad0..ce6431d 100644 --- a/examples/evaluate_distributed.rs +++ b/examples/evaluate_distributed.rs @@ -1,12 +1,14 @@ //! Distributed evaluation of sources and targets. -use green_kernels::traits::*; -use green_kernels::{laplace_3d::Laplace3dKernel, types::GreenKernelEvalType}; +use green_kernels::{ + laplace_3d::Laplace3dKernel, + traits::{DistributedKernelEvaluator, Kernel}, + types::GreenKernelEvalType, +}; use mpi::traits::{Communicator, Root}; use rand::prelude::*; use rand_chacha::ChaCha8Rng; -use rlst::prelude::*; -use rlst::{assert_array_relative_eq, rlst_dynamic_array1, RawAccess, RawAccessMut}; +use rlst::{assert_array_relative_eq, rlst_dynamic_array}; fn main() { // Create the MPI communicator @@ -24,23 +26,23 @@ fn main() { // Create a Laplace kernel. let kernel = Laplace3dKernel::::default(); - let mut sources = rlst_dynamic_array1!(f64, [3 * n_sources]); - let mut targets = rlst_dynamic_array1!(f64, [3 * n_targets]); - let mut charges = rlst_dynamic_array1!(f64, [n_sources]); + let mut sources = rlst_dynamic_array!(f64, [3 * n_sources]); + let mut targets = rlst_dynamic_array!(f64, [3 * n_targets]); + let mut charges = rlst_dynamic_array!(f64, [n_sources]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); charges.fill_from_equally_distributed(&mut rng); // Create the result vector. - let mut result = rlst_dynamic_array1!(f64, [n_targets]); + let mut result = rlst_dynamic_array!(f64, [n_targets]); kernel.evaluate_distributed( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + result.data_mut().unwrap(), false, &world, ); @@ -50,51 +52,51 @@ fn main() { if world.rank() != 0 { let root_process = world.process_at_rank(0); - root_process.gather_into(sources.data()); - root_process.gather_into(targets.data()); - root_process.gather_into(charges.data()); - root_process.gather_into(result.data()); + root_process.gather_into(sources.data().unwrap()); + root_process.gather_into(targets.data().unwrap()); + root_process.gather_into(charges.data().unwrap()); + root_process.gather_into(result.data().unwrap()); } else { let sources = { - let mut tmp = rlst_dynamic_array1!(f64, [3 * n_sources * world.size() as usize]); + let mut tmp = rlst_dynamic_array!(f64, [3 * n_sources * world.size() as usize]); world .this_process() - .gather_into_root(sources.data(), tmp.data_mut()); + .gather_into_root(sources.data().unwrap(), tmp.data_mut().unwrap()); tmp }; let targets = { - let mut tmp = rlst_dynamic_array1!(f64, [3 * n_targets * world.size() as usize]); + let mut tmp = rlst_dynamic_array!(f64, [3 * n_targets * world.size() as usize]); world .this_process() - .gather_into_root(targets.data(), tmp.data_mut()); + .gather_into_root(targets.data().unwrap(), tmp.data_mut().unwrap()); tmp }; let charges = { - let mut tmp = rlst_dynamic_array1!(f64, [n_sources * world.size() as usize]); + let mut tmp = rlst_dynamic_array!(f64, [n_sources * world.size() as usize]); world .this_process() - .gather_into_root(charges.data(), tmp.data_mut()); + .gather_into_root(charges.data().unwrap(), tmp.data_mut().unwrap()); tmp }; let result = { - let mut tmp = rlst_dynamic_array1!(f64, [n_targets * world.size() as usize]); + let mut tmp = rlst_dynamic_array!(f64, [n_targets * world.size() as usize]); world .this_process() - .gather_into_root(result.data(), tmp.data_mut()); + .gather_into_root(result.data().unwrap(), tmp.data_mut().unwrap()); tmp }; - let mut expected = rlst_dynamic_array1!(f64, [n_targets * world.size() as usize]); + let mut expected = rlst_dynamic_array!(f64, [n_targets * world.size() as usize]); kernel.evaluate_mt( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - expected.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + expected.data_mut().unwrap(), ); assert_array_relative_eq!(result, expected, 1e-13); diff --git a/examples/kernel_accuracy.rs b/examples/kernel_accuracy.rs index 5e025ac..720be16 100644 --- a/examples/kernel_accuracy.rs +++ b/examples/kernel_accuracy.rs @@ -3,35 +3,36 @@ const NSAMPLES: usize = 100; use num::{traits::FloatConst, Float}; use rand::prelude::*; -use rlst::{dense::tools::RandScalar, prelude::*}; use green_kernels::{ helmholtz_3d::Helmholtz3dKernel, laplace_3d::Laplace3dKernel, modified_helmholtz_3d::ModifiedHelmholtz3dKernel, traits::Kernel, types::GreenKernelEvalType, }; +use rlst::{c32, c64, rlst_dynamic_array, AbsSquare, DynArray, RandScalar, RlstScalar}; fn benchmark_kernel_laplace>( kernel: &K, - sources: &DynamicArray, - targets: &DynamicArray, + sources: &DynArray, + targets: &DynArray, ) -> T::Real where T::Real: num::Float, + T::Real: AbsSquare, { - let mut result = rlst_dynamic_array2!(T, [NSAMPLES, NSAMPLES]); + let mut result = rlst_dynamic_array!(T, [NSAMPLES, NSAMPLES]); kernel.assemble_mt( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); let mut rel_error: T::Real = ::default(); for (source_index, source) in sources.col_iter().enumerate() { for (target_index, target) in targets.col_iter().enumerate() { - let diff_norm = (source.r() - target.r()).norm_2(); + let diff_norm = (source.r() - target.r()).norm_2().unwrap(); let green = result[[source_index, target_index]]; let green_exact = T::one() / (num::cast::(4.0 * f64::PI()).unwrap() @@ -47,26 +48,27 @@ where fn benchmark_kernel_modified_helmholtz>( kernel: &K, - sources: &DynamicArray, - targets: &DynamicArray, + sources: &DynArray, + targets: &DynArray, ) -> T::Real where T::Real: num::Float, + T::Real: AbsSquare, { - let mut result = rlst_dynamic_array2!(T, [NSAMPLES, NSAMPLES]); + let mut result = rlst_dynamic_array!(T, [NSAMPLES, NSAMPLES]); kernel.assemble_mt( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); let mut rel_error: T::Real = ::default(); for (source_index, source) in sources.col_iter().enumerate() { for (target_index, target) in targets.col_iter().enumerate() { - let diff_norm = (source.r() - target.r()).norm_2(); + let diff_norm = (source.r() - target.r()).norm_2().unwrap(); let green = result[[source_index, target_index]]; let green_exact = T::exp(T::from_real( num::cast::(-1.5).unwrap() * diff_norm, @@ -83,26 +85,27 @@ where fn benchmark_kernel_helmholtz + RandScalar, K: Kernel>( kernel: &K, - sources: &DynamicArray, - targets: &DynamicArray, + sources: &DynArray, + targets: &DynArray, ) -> T::Real where T::Real: num::Float, + T::Real: AbsSquare, { - let mut result = rlst_dynamic_array2!(T, [NSAMPLES, NSAMPLES]); + let mut result = rlst_dynamic_array!(T, [NSAMPLES, NSAMPLES]); kernel.assemble_mt( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); let mut rel_error: T::Real = ::default(); for (source_index, source) in sources.col_iter().enumerate() { for (target_index, target) in targets.col_iter().enumerate() { - let diff_norm = (source.r() - target.r()).norm_2(); + let diff_norm = (source.r() - target.r()).norm_2().unwrap(); let green = result[[source_index, target_index]]; let green_exact = T::complex( T::cos(T::from_real( @@ -125,10 +128,10 @@ where fn main() { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources_f32 = rlst_dynamic_array2!(f32, [3, NSAMPLES]); - let mut targets_f32 = rlst_dynamic_array2!(f32, [3, NSAMPLES]); - let mut sources_f64 = rlst_dynamic_array2!(f64, [3, NSAMPLES]); - let mut targets_f64 = rlst_dynamic_array2!(f64, [3, NSAMPLES]); + let mut sources_f32 = rlst_dynamic_array!(f32, [3, NSAMPLES]); + let mut targets_f32 = rlst_dynamic_array!(f32, [3, NSAMPLES]); + let mut sources_f64 = rlst_dynamic_array!(f64, [3, NSAMPLES]); + let mut targets_f64 = rlst_dynamic_array!(f64, [3, NSAMPLES]); sources_f32.fill_from_equally_distributed(&mut rng); targets_f32.fill_from_equally_distributed(&mut rng); diff --git a/src/c_abi.rs b/src/c_abi.rs index b0f6779..5f19d87 100644 --- a/src/c_abi.rs +++ b/src/c_abi.rs @@ -1,8 +1,7 @@ //! C Interface use coe; -use rlst::prelude::*; -use rlst::RlstScalar; +use rlst::{c32, c64, RlstScalar}; use std::{ffi::c_void, mem::ManuallyDrop}; use crate::helmholtz_3d::Helmholtz3dKernel; diff --git a/src/helmholtz_3d.rs b/src/helmholtz_3d.rs index 259d98c..0ea83ca 100644 --- a/src/helmholtz_3d.rs +++ b/src/helmholtz_3d.rs @@ -11,8 +11,9 @@ use pulp::Simd; use rayon::prelude::*; use rlst::c32; use rlst::c64; +use rlst::simd::SimdFor; use rlst::RlstScalar; -use rlst::{RlstSimd, SimdFor}; +use rlst::RlstSimd; use std::marker::PhantomData; /// Kernel for Helmholtz in 3D @@ -1401,8 +1402,9 @@ mod test { use super::*; use approx::assert_relative_eq; - use rand::prelude::*; - use rlst::prelude::*; + use rand::SeedableRng; + use rand_chacha::{self, ChaCha8Rng}; + use rlst::rlst_dynamic_array; #[test] fn test_helmholtz_3d_f32() { @@ -1413,12 +1415,12 @@ mod test { let nsources = 19; let ntargets = 7; - let mut rng = rand::rngs::StdRng::seed_from_u64(0); + let mut rng = ChaCha8Rng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f32, [3, ntargets]); - let mut charges = rlst_dynamic_array1!(c32, [nsources]); - let mut green_value = rlst_dynamic_array1!(c32, [ntargets]); + let mut sources = rlst_dynamic_array!(f32, [3, nsources]); + let mut targets = rlst_dynamic_array!(f32, [3, ntargets]); + let mut charges = rlst_dynamic_array!(c32, [nsources]); + let mut green_value = rlst_dynamic_array!(c32, [ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); @@ -1426,21 +1428,21 @@ mod test { Helmholtz3dKernel::::new(wavenumber).evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + green_value.data_mut().unwrap(), ); - let mut expected_val = rlst_dynamic_array1!(c32, [ntargets]); - let mut expected_deriv = rlst_dynamic_array2!(c32, [4, ntargets]); + let mut expected_val = rlst_dynamic_array!(c32, [ntargets]); + let mut expected_deriv = rlst_dynamic_array!(c32, [4, ntargets]); for (val, mut deriv, target) in itertools::izip!( expected_val.iter_mut(), expected_deriv.col_iter_mut(), targets.col_iter(), ) { - for (charge, source) in itertools::izip!(charges.iter(), sources.col_iter_mut()) { + for (charge, source) in itertools::izip!(charges.iter_value(), sources.col_iter_mut()) { let mut res: [c32; 1] = [c32::from_real(0.0)]; let mut res_deriv: [c32; 4] = [ c32::from_real(0.0), @@ -1448,18 +1450,19 @@ mod test { c32::from_real(0.0), c32::from_real(0.0), ]; + Helmholtz3dKernel::new(wavenumber).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res.as_mut_slice(), ); *val += charge * res[0]; Helmholtz3dKernel::new(wavenumber).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res_deriv.as_mut_slice(), ); @@ -1478,14 +1481,14 @@ mod test { ); } - let mut actual = rlst::rlst_dynamic_array2!(c32, [4, ntargets]); + let mut actual = rlst::rlst_dynamic_array!(c32, [4, ntargets]); Helmholtz3dKernel::::new(wavenumber).evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - actual.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + actual.data_mut().unwrap(), ); for target_index in 0..ntargets { @@ -1525,10 +1528,10 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f64, [3, ntargets]); - let mut charges = rlst_dynamic_array1!(c64, [nsources]); - let mut green_value = rlst_dynamic_array1!(c64, [ntargets]); + let mut sources = rlst_dynamic_array!(f64, [3, nsources]); + let mut targets = rlst_dynamic_array!(f64, [3, ntargets]); + let mut charges = rlst_dynamic_array!(c64, [nsources]); + let mut green_value = rlst_dynamic_array!(c64, [ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); @@ -1536,21 +1539,21 @@ mod test { Helmholtz3dKernel::::new(wavenumber).evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + green_value.data_mut().unwrap(), ); - let mut expected_val = rlst_dynamic_array1!(c64, [ntargets]); - let mut expected_deriv = rlst_dynamic_array2!(c64, [4, ntargets]); + let mut expected_val = rlst_dynamic_array!(c64, [ntargets]); + let mut expected_deriv = rlst_dynamic_array!(c64, [4, ntargets]); for (val, mut deriv, target) in itertools::izip!( expected_val.iter_mut(), expected_deriv.col_iter_mut(), targets.col_iter(), ) { - for (charge, source) in itertools::izip!(charges.iter(), sources.col_iter_mut()) { + for (charge, source) in itertools::izip!(charges.iter_value(), sources.col_iter_mut()) { let mut res: [c64; 1] = [c64::from_real(0.0)]; let mut res_deriv: [c64; 4] = [ c64::from_real(0.0), @@ -1560,16 +1563,16 @@ mod test { ]; Helmholtz3dKernel::new(wavenumber).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res.as_mut_slice(), ); *val += charge * res[0]; Helmholtz3dKernel::new(wavenumber).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res_deriv.as_mut_slice(), ); @@ -1588,14 +1591,14 @@ mod test { ); } - let mut actual = rlst::rlst_dynamic_array2!(c64, [4, ntargets]); + let mut actual = rlst::rlst_dynamic_array!(c64, [4, ntargets]); Helmholtz3dKernel::::new(wavenumber).evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - actual.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + actual.data_mut().unwrap(), ); for target_index in 0..ntargets { @@ -1635,18 +1638,18 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f64, [3, ntargets]); - let mut result = rlst_dynamic_array2!(c64, [nsources, ntargets]); + let mut sources = rlst_dynamic_array!(f64, [3, nsources]); + let mut targets = rlst_dynamic_array!(f64, [3, ntargets]); + let mut result = rlst_dynamic_array!(c64, [nsources, ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); for (target_index, target) in targets.col_iter().enumerate() { @@ -1655,8 +1658,8 @@ mod test { Helmholtz3dKernel::::new(wavenumber).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected.as_mut_slice(), ); @@ -1680,18 +1683,18 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f32, [3, ntargets]); - let mut result = rlst_dynamic_array2!(c32, [nsources, ntargets]); + let mut sources = rlst_dynamic_array!(f32, [3, nsources]); + let mut targets = rlst_dynamic_array!(f32, [3, ntargets]); + let mut result = rlst_dynamic_array!(c32, [nsources, ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); for (target_index, target) in targets.col_iter().enumerate() { @@ -1700,8 +1703,8 @@ mod test { Helmholtz3dKernel::::new(wavenumber).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected.as_mut_slice(), ); @@ -1725,18 +1728,18 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f32, [3, ntargets]); - let mut result = rlst_dynamic_array2!(c32, [4 * nsources, ntargets]); + let mut sources = rlst_dynamic_array!(f32, [3, nsources]); + let mut targets = rlst_dynamic_array!(f32, [3, ntargets]); + let mut result = rlst_dynamic_array!(c32, [4 * nsources, ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); for (target_index, target) in targets.col_iter().enumerate() { @@ -1750,8 +1753,8 @@ mod test { Helmholtz3dKernel::::new(wavenumber).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected.as_mut_slice(), ); @@ -1777,18 +1780,18 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f64, [3, ntargets]); - let mut result = rlst_dynamic_array2!(c64, [4 * nsources, ntargets]); + let mut sources = rlst_dynamic_array!(f64, [3, nsources]); + let mut targets = rlst_dynamic_array!(f64, [3, ntargets]); + let mut result = rlst_dynamic_array!(c64, [4 * nsources, ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - result.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result.data_mut().unwrap(), ); for (target_index, target) in targets.col_iter().enumerate() { @@ -1802,8 +1805,8 @@ mod test { Helmholtz3dKernel::::new(wavenumber).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected.as_mut_slice(), ); @@ -1825,47 +1828,47 @@ mod test { let wavenumber: f32 = 1.5; - let mut sources = rlst_dynamic_array2!(f32, [nsources, 3]); - let mut targets = rlst_dynamic_array2!(f32, [ntargets, 3]); + let mut sources = rlst_dynamic_array!(f32, [nsources, 3]); + let mut targets = rlst_dynamic_array!(f32, [ntargets, 3]); sources.fill_from_seed_equally_distributed(1); targets.fill_from_seed_equally_distributed(2); - let mut green_value_diag = rlst_dynamic_array1!(c32, [ntargets]); - let mut green_value_diag_deriv = rlst_dynamic_array2!(c32, [4, ntargets]); + let mut green_value_diag = rlst_dynamic_array!(c32, [ntargets]); + let mut green_value_diag_deriv = rlst_dynamic_array!(c32, [4, ntargets]); Helmholtz3dKernel::::new(wavenumber).assemble_pairwise_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value_diag.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag.data_mut().unwrap(), ); Helmholtz3dKernel::::new(wavenumber).assemble_pairwise_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_diag_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag_deriv.data_mut().unwrap(), ); - let mut green_value = rlst_dynamic_array2!(c32, [nsources, ntargets]); + let mut green_value = rlst_dynamic_array!(c32, [nsources, ntargets]); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, // second row to the second target and so on. - let mut green_value_deriv = rlst_dynamic_array2!(c32, [4 * nsources, ntargets]); + let mut green_value_deriv = rlst_dynamic_array!(c32, [4 * nsources, ntargets]); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_deriv.data_mut().unwrap(), ); for index in 0..nsources { @@ -1907,47 +1910,47 @@ mod test { let wavenumber: f64 = 1.5; - let mut sources = rlst_dynamic_array2!(f64, [nsources, 3]); - let mut targets = rlst_dynamic_array2!(f64, [ntargets, 3]); + let mut sources = rlst_dynamic_array!(f64, [nsources, 3]); + let mut targets = rlst_dynamic_array!(f64, [ntargets, 3]); sources.fill_from_seed_equally_distributed(1); targets.fill_from_seed_equally_distributed(2); - let mut green_value_diag = rlst_dynamic_array1!(c64, [ntargets]); - let mut green_value_diag_deriv = rlst_dynamic_array2!(c64, [4, ntargets]); + let mut green_value_diag = rlst_dynamic_array!(c64, [ntargets]); + let mut green_value_diag_deriv = rlst_dynamic_array!(c64, [4, ntargets]); Helmholtz3dKernel::::new(wavenumber).assemble_pairwise_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value_diag.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag.data_mut().unwrap(), ); Helmholtz3dKernel::::new(wavenumber).assemble_pairwise_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_diag_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag_deriv.data_mut().unwrap(), ); - let mut green_value = rlst_dynamic_array2!(c64, [nsources, ntargets]); + let mut green_value = rlst_dynamic_array!(c64, [nsources, ntargets]); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, // second row to the second target and so on. - let mut green_value_deriv = rlst_dynamic_array2!(c64, [4 * nsources, ntargets]); + let mut green_value_deriv = rlst_dynamic_array!(c64, [4 * nsources, ntargets]); Helmholtz3dKernel::::new(wavenumber).assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_deriv.data_mut().unwrap(), ); for index in 0..nsources { diff --git a/src/laplace_3d.rs b/src/laplace_3d.rs index 83db775..36e0d50 100644 --- a/src/laplace_3d.rs +++ b/src/laplace_3d.rs @@ -6,7 +6,8 @@ use crate::traits::Kernel; use crate::types::GreenKernelEvalType; use num::traits::FloatConst; use rayon::prelude::*; -use rlst::{RlstScalar, RlstSimd, SimdFor}; +use rlst::simd::SimdFor; +use rlst::{RlstScalar, RlstSimd}; use std::marker::PhantomData; /// Kernel for Laplace in 3D @@ -964,9 +965,7 @@ mod test { use super::*; use approx::assert_relative_eq; use rand::prelude::*; - use rlst::prelude::*; - - use rlst::{rlst_dynamic_array1, rlst_dynamic_array2}; + use rlst::rlst_dynamic_array; #[test] fn test_laplace_3d_value_f32() { @@ -974,21 +973,21 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, nparticles]); - let mut targets = rlst_dynamic_array2!(f32, [3, nparticles]); - let mut charges = rlst_dynamic_array1!(f32, [nparticles]); - let mut green_value = rlst_dynamic_array1!(f32, [nparticles]); + let mut sources = rlst_dynamic_array!(f32, [3, nparticles]); + let mut targets = rlst_dynamic_array!(f32, [3, nparticles]); + let mut charges = rlst_dynamic_array!(f32, [nparticles]); + let mut green_value = rlst_dynamic_array!(f32, [nparticles]); sources.fill_from_equally_distributed(&mut rng); - targets.fill_from(sources.r()); + targets.fill_from(&sources); charges.fill_from_equally_distributed(&mut rng); Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + green_value.data_mut().unwrap(), ); for target_index in 0..nparticles { @@ -1013,21 +1012,21 @@ mod test { let nparticles = 13; let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, nparticles]); - let mut targets = rlst_dynamic_array2!(f64, [3, nparticles]); - let mut charges = rlst_dynamic_array1!(f64, [nparticles]); - let mut green_value = rlst_dynamic_array1!(f64, [nparticles]); + let mut sources = rlst_dynamic_array!(f64, [3, nparticles]); + let mut targets = rlst_dynamic_array!(f64, [3, nparticles]); + let mut charges = rlst_dynamic_array!(f64, [nparticles]); + let mut green_value = rlst_dynamic_array!(f64, [nparticles]); sources.fill_from_equally_distributed(&mut rng); - targets.fill_from(sources.r()); + targets.fill_from(&sources); charges.fill_from_equally_distributed(&mut rng); Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + green_value.data_mut().unwrap(), ); for target_index in 0..nparticles { @@ -1050,8 +1049,8 @@ mod test { #[test] fn test_laplace_green_f32() { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut source = rlst_dynamic_array1!(f32, [3]); - let mut target = rlst_dynamic_array1!(f32, [3]); + let mut source = rlst_dynamic_array!(f32, [3]); + let mut target = rlst_dynamic_array!(f32, [3]); source.fill_from_equally_distributed(&mut rng); target.fill_from_equally_distributed(&mut rng); @@ -1063,15 +1062,15 @@ mod test { Laplace3dKernel::::default().greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), result.as_mut_slice(), ); Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), charge.as_slice(), expect.as_mut_slice(), ); @@ -1083,15 +1082,15 @@ mod test { Laplace3dKernel::::default().greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), result.as_mut_slice(), ); Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), charge.as_slice(), expect.as_mut_slice(), ); @@ -1104,8 +1103,8 @@ mod test { #[test] fn test_laplace_green_f64() { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut source = rlst_dynamic_array1!(f64, [3]); - let mut target = rlst_dynamic_array1!(f64, [3]); + let mut source = rlst_dynamic_array!(f64, [3]); + let mut target = rlst_dynamic_array!(f64, [3]); source.fill_from_equally_distributed(&mut rng); target.fill_from_equally_distributed(&mut rng); @@ -1117,15 +1116,15 @@ mod test { Laplace3dKernel::::default().greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), result.as_mut_slice(), ); Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), charge.as_slice(), expect.as_mut_slice(), ); @@ -1137,15 +1136,15 @@ mod test { Laplace3dKernel::::default().greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), result.as_mut_slice(), ); Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), charge.as_slice(), expect.as_mut_slice(), ); @@ -1164,10 +1163,10 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f32, [3, ntargets]); - let mut charges = rlst_dynamic_array1!(f32, [nsources]); - let mut green_value = rlst_dynamic_array1!(f32, [ntargets]); + let mut sources = rlst_dynamic_array!(f32, [3, nsources]); + let mut targets = rlst_dynamic_array!(f32, [3, ntargets]); + let mut charges = rlst_dynamic_array!(f32, [nsources]); + let mut green_value = rlst_dynamic_array!(f32, [ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); @@ -1175,21 +1174,21 @@ mod test { Laplace3dKernel::::new().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + green_value.data_mut().unwrap(), ); - let mut expected_val = rlst_dynamic_array1!(f32, [ntargets]); - let mut expected_deriv = rlst_dynamic_array2!(f32, [4, ntargets]); + let mut expected_val = rlst_dynamic_array!(f32, [ntargets]); + let mut expected_deriv = rlst_dynamic_array!(f32, [4, ntargets]); for (val, mut deriv, target) in itertools::izip!( expected_val.iter_mut(), expected_deriv.col_iter_mut(), targets.col_iter(), ) { - for (charge, source) in itertools::izip!(charges.iter(), sources.col_iter_mut()) { + for (charge, source) in itertools::izip!(charges.iter_value(), sources.col_iter_mut()) { let mut res: [f32; 1] = [f32::from_real(0.0)]; let mut res_deriv: [f32; 4] = [ f32::from_real(0.0), @@ -1199,16 +1198,16 @@ mod test { ]; Laplace3dKernel::new().greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res.as_mut_slice(), ); *val += charge * res[0]; Laplace3dKernel::new().greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res_deriv.as_mut_slice(), ); @@ -1227,14 +1226,14 @@ mod test { ); } - let mut actual = rlst::rlst_dynamic_array2!(f32, [4, ntargets]); + let mut actual = rlst::rlst_dynamic_array!(f32, [4, ntargets]); Laplace3dKernel::::new().evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - actual.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + actual.data_mut().unwrap(), ); for target_index in 0..ntargets { @@ -1272,10 +1271,10 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f64, [3, ntargets]); - let mut charges = rlst_dynamic_array1!(f64, [nsources]); - let mut green_value = rlst_dynamic_array1!(f64, [ntargets]); + let mut sources = rlst_dynamic_array!(f64, [3, nsources]); + let mut targets = rlst_dynamic_array!(f64, [3, ntargets]); + let mut charges = rlst_dynamic_array!(f64, [nsources]); + let mut green_value = rlst_dynamic_array!(f64, [ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); @@ -1283,21 +1282,21 @@ mod test { Laplace3dKernel::::new().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + green_value.data_mut().unwrap(), ); - let mut expected_val = rlst_dynamic_array1!(f64, [ntargets]); - let mut expected_deriv = rlst_dynamic_array2!(f64, [4, ntargets]); + let mut expected_val = rlst_dynamic_array!(f64, [ntargets]); + let mut expected_deriv = rlst_dynamic_array!(f64, [4, ntargets]); for (val, mut deriv, target) in itertools::izip!( expected_val.iter_mut(), expected_deriv.col_iter_mut(), targets.col_iter(), ) { - for (charge, source) in itertools::izip!(charges.iter(), sources.col_iter_mut()) { + for (charge, source) in itertools::izip!(charges.iter_value(), sources.col_iter_mut()) { let mut res: [f64; 1] = [f64::from_real(0.0)]; let mut res_deriv: [f64; 4] = [ f64::from_real(0.0), @@ -1307,16 +1306,16 @@ mod test { ]; Laplace3dKernel::new().greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res.as_mut_slice(), ); *val += charge * res[0]; Laplace3dKernel::new().greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res_deriv.as_mut_slice(), ); @@ -1335,14 +1334,14 @@ mod test { ); } - let mut actual = rlst::rlst_dynamic_array2!(f64, [4, ntargets]); + let mut actual = rlst::rlst_dynamic_array!(f64, [4, ntargets]); Laplace3dKernel::::new().evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - actual.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + actual.data_mut().unwrap(), ); for target_index in 0..ntargets { @@ -1376,34 +1375,34 @@ mod test { let ntargets = 5; let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f64, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f64, [3, ntargets]); - let mut green_value = rlst_dynamic_array2!(f64, [nsources, ntargets]); + let mut sources = rlst_dynamic_array!(f64, [3, nsources]); + let mut targets = rlst_dynamic_array!(f64, [3, ntargets]); + let mut green_value = rlst_dynamic_array!(f64, [nsources, ntargets]); targets.fill_from_equally_distributed(&mut rng); sources.fill_from_equally_distributed(&mut rng); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, // second row to the second target and so on. for charge_index in 0..nsources { - let mut charges = rlst_dynamic_array1![f64, [nsources]]; - let mut expected = rlst_dynamic_array1![f64, [ntargets]]; + let mut charges = rlst_dynamic_array![f64, [nsources]]; + let mut expected = rlst_dynamic_array![f64, [ntargets]]; charges[[charge_index]] = 1.0; Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - expected.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + expected.data_mut().unwrap(), ); for target_index in 0..ntargets { @@ -1415,29 +1414,29 @@ mod test { } } - let mut green_value_deriv = rlst_dynamic_array2!(f64, [4 * nsources, ntargets]); + let mut green_value_deriv = rlst_dynamic_array!(f64, [4 * nsources, ntargets]); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_deriv.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, etc. for charge_index in 0..nsources { - let mut charges = rlst_dynamic_array1![f64, [nsources]]; - let mut expected = rlst_dynamic_array2!(f64, [4, ntargets]); + let mut charges = rlst_dynamic_array![f64, [nsources]]; + let mut expected = rlst_dynamic_array!(f64, [4, ntargets]); charges[[charge_index]] = 1.0; Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - expected.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + expected.data_mut().unwrap(), ); for deriv_index in 0..4 { @@ -1458,34 +1457,34 @@ mod test { let ntargets = 5; let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!(f32, [3, nsources]); - let mut targets = rlst_dynamic_array2!(f32, [3, ntargets]); - let mut green_value = rlst_dynamic_array2!(f32, [nsources, ntargets]); + let mut sources = rlst_dynamic_array!(f32, [3, nsources]); + let mut targets = rlst_dynamic_array!(f32, [3, ntargets]); + let mut green_value = rlst_dynamic_array!(f32, [nsources, ntargets]); targets.fill_from_equally_distributed(&mut rng); sources.fill_from_equally_distributed(&mut rng); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, // second row to the second target and so on. for charge_index in 0..nsources { - let mut charges = rlst_dynamic_array1![f32, [nsources]]; - let mut expected = rlst_dynamic_array1![f32, [ntargets]]; + let mut charges = rlst_dynamic_array![f32, [nsources]]; + let mut expected = rlst_dynamic_array![f32, [ntargets]]; charges[[charge_index]] = 1.0; Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - expected.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + expected.data_mut().unwrap(), ); for target_index in 0..ntargets { @@ -1497,29 +1496,29 @@ mod test { } } - let mut green_value_deriv = rlst_dynamic_array2!(f32, [4 * nsources, ntargets]); + let mut green_value_deriv = rlst_dynamic_array!(f32, [4 * nsources, ntargets]); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_deriv.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, etc. for charge_index in 0..nsources { - let mut charges = rlst_dynamic_array1![f32, [nsources]]; - let mut expected = rlst_dynamic_array2!(f32, [4, ntargets]); + let mut charges = rlst_dynamic_array![f32, [nsources]]; + let mut expected = rlst_dynamic_array!(f32, [4, ntargets]); charges[[charge_index]] = 1.0; Laplace3dKernel::::default().evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - expected.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + expected.data_mut().unwrap(), ); for deriv_index in 0..4 { @@ -1539,47 +1538,47 @@ mod test { let nsources = 19; let ntargets = 19; - let mut sources = rlst_dynamic_array2!(f64, [nsources, 3]); - let mut targets = rlst_dynamic_array2!(f64, [ntargets, 3]); + let mut sources = rlst_dynamic_array!(f64, [nsources, 3]); + let mut targets = rlst_dynamic_array!(f64, [ntargets, 3]); sources.fill_from_seed_equally_distributed(1); targets.fill_from_seed_equally_distributed(2); - let mut green_value_diag = rlst_dynamic_array1!(f64, [ntargets]); - let mut green_value_diag_deriv = rlst_dynamic_array2!(f64, [4, ntargets]); + let mut green_value_diag = rlst_dynamic_array!(f64, [ntargets]); + let mut green_value_diag_deriv = rlst_dynamic_array!(f64, [4, ntargets]); Laplace3dKernel::::default().assemble_pairwise_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value_diag.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag.data_mut().unwrap(), ); Laplace3dKernel::::default().assemble_pairwise_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_diag_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag_deriv.data_mut().unwrap(), ); - let mut green_value = rlst_dynamic_array2!(f64, [nsources, ntargets]); + let mut green_value = rlst_dynamic_array!(f64, [nsources, ntargets]); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, // second row to the second target and so on. - let mut green_value_deriv = rlst_dynamic_array2!(f64, [4 * nsources, ntargets]); + let mut green_value_deriv = rlst_dynamic_array!(f64, [4 * nsources, ntargets]); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_deriv.data_mut().unwrap(), ); for index in 0..nsources { @@ -1620,47 +1619,47 @@ mod test { let nsources = 19; let ntargets = 19; - let mut sources = rlst_dynamic_array2!(f32, [nsources, 3]); - let mut targets = rlst_dynamic_array2!(f32, [ntargets, 3]); + let mut sources = rlst_dynamic_array!(f32, [nsources, 3]); + let mut targets = rlst_dynamic_array!(f32, [ntargets, 3]); sources.fill_from_seed_equally_distributed(1); targets.fill_from_seed_equally_distributed(2); - let mut green_value_diag = rlst_dynamic_array1!(f32, [ntargets]); - let mut green_value_diag_deriv = rlst_dynamic_array2!(f32, [4, ntargets]); + let mut green_value_diag = rlst_dynamic_array!(f32, [ntargets]); + let mut green_value_diag_deriv = rlst_dynamic_array!(f32, [4, ntargets]); Laplace3dKernel::::default().assemble_pairwise_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value_diag.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag.data_mut().unwrap(), ); Laplace3dKernel::::default().assemble_pairwise_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_diag_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_diag_deriv.data_mut().unwrap(), ); - let mut green_value = rlst_dynamic_array2!(f32, [nsources, ntargets]); + let mut green_value = rlst_dynamic_array!(f32, [nsources, ntargets]); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - green_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value.data_mut().unwrap(), ); // The matrix needs to be transposed so that the first row corresponds to the first target, // second row to the second target and so on. - let mut green_value_deriv = rlst_dynamic_array2!(f32, [4 * nsources, ntargets]); + let mut green_value_deriv = rlst_dynamic_array!(f32, [4 * nsources, ntargets]); Laplace3dKernel::::default().assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - green_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + green_value_deriv.data_mut().unwrap(), ); for index in 0..nsources { diff --git a/src/modified_helmholtz_3d.rs b/src/modified_helmholtz_3d.rs index 2ec1896..8e5cc5e 100644 --- a/src/modified_helmholtz_3d.rs +++ b/src/modified_helmholtz_3d.rs @@ -6,7 +6,8 @@ use crate::traits::Kernel; use crate::types::GreenKernelEvalType; use num::traits::FloatConst; use rayon::prelude::*; -use rlst::{RlstScalar, RlstSimd, SimdFor}; +use rlst::simd::SimdFor; +use rlst::{RlstScalar, RlstSimd}; /// Kernel for Modified Helmholtz in 3D #[derive(Clone, Copy)] @@ -1100,9 +1101,7 @@ mod test { use itertools::izip; use paste::paste; use rand::prelude::*; - use rlst::prelude::*; - - use rlst::rlst_dynamic_array1; + use rlst::rlst_dynamic_array; macro_rules! impl_modified_helmholtz_tests { ($scalar:ty, $delta:expr, $deriv_eps:expr, $eps:expr) => { @@ -1117,8 +1116,8 @@ mod test { let omega = 1.5; let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut source = rlst_dynamic_array1!($scalar, [3]); - let mut target = rlst_dynamic_array1!($scalar, [3]); + let mut source = rlst_dynamic_array!($scalar, [3]); + let mut target = rlst_dynamic_array!($scalar, [3]); source.fill_from_equally_distributed(&mut rng); target.fill_from_equally_distributed(&mut rng); @@ -1131,25 +1130,25 @@ mod test { ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), actual_value.as_mut_slice(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), actual_deriv.as_mut_slice(), ); - let mut target_x = rlst_dynamic_array1!($scalar, [3]); - let mut target_y = rlst_dynamic_array1!($scalar, [3]); - let mut target_z = rlst_dynamic_array1!($scalar, [3]); + let mut target_x = rlst_dynamic_array!($scalar, [3]); + let mut target_y = rlst_dynamic_array!($scalar, [3]); + let mut target_z = rlst_dynamic_array!($scalar, [3]); - target_y.fill_from(target.r()); - target_z.fill_from(target.r()); - target_x.fill_from(target.r()); + target_y.fill_from(&target); + target_z.fill_from(&target); + target_x.fill_from(&target); target_x[[0]] += delta; target_y[[1]] += delta; @@ -1157,22 +1156,22 @@ mod test { ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - source.data(), - target_x.data(), + source.data().unwrap(), + target_x.data().unwrap(), expected_deriv_x.as_mut_slice(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - source.data(), - target_y.data(), + source.data().unwrap(), + target_y.data().unwrap(), expected_deriv_y.as_mut_slice(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - source.data(), - target_z.data(), + source.data().unwrap(), + target_z.data().unwrap(), expected_deriv_z.as_mut_slice(), ); @@ -1205,8 +1204,8 @@ mod test { let omega = 0.0; let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut source = rlst_dynamic_array1!($scalar, [3]); - let mut target = rlst_dynamic_array1!($scalar, [3]); + let mut source = rlst_dynamic_array!($scalar, [3]); + let mut target = rlst_dynamic_array!($scalar, [3]); source.fill_from_equally_distributed(&mut rng); target.fill_from_equally_distributed(&mut rng); @@ -1216,15 +1215,15 @@ mod test { ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), actual_deriv.as_mut_slice(), ); Laplace3dKernel::<$scalar>::new().greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected_deriv.as_mut_slice(), ); @@ -1242,33 +1241,33 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!($scalar, [3, npoints]); - let mut targets = rlst_dynamic_array2!($scalar, [3, npoints]); + let mut sources = rlst_dynamic_array!($scalar, [3, npoints]); + let mut targets = rlst_dynamic_array!($scalar, [3, npoints]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); - let mut result_value = rlst_dynamic_array1!($scalar, [npoints]); - let mut result_value_deriv = rlst_dynamic_array2!($scalar, [4, npoints]); + let mut result_value = rlst_dynamic_array!($scalar, [npoints]); + let mut result_value_deriv = rlst_dynamic_array!($scalar, [4, npoints]); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).assemble_pairwise_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - result_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result_value.data_mut().unwrap(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).assemble_pairwise_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - result_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + result_value_deriv.data_mut().unwrap(), ); for (s, t, res_value, res_deriv) in izip!( sources.col_iter(), targets.col_iter(), - result_value.iter(), + result_value.iter_value(), result_value_deriv.col_iter() ) { let mut expected_val = [0.0; 1]; @@ -1276,21 +1275,21 @@ mod test { ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - s.data(), - t.data(), + s.data().unwrap(), + t.data().unwrap(), expected_val.as_mut_slice(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::ValueDeriv, - s.data(), - t.data(), + s.data().unwrap(), + t.data().unwrap(), expected_deriv.as_mut_slice(), ); assert_relative_eq!(res_value, expected_val[0], max_relative = eps); - for (a, &e) in izip!(res_deriv.iter(), expected_val.iter()) { + for (a, &e) in izip!(res_deriv.iter_value(), expected_val.iter()) { assert_relative_eq!(a, e, max_relative = eps); } } @@ -1306,9 +1305,9 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!($scalar, [3, nsources]); - let mut targets = rlst_dynamic_array2!($scalar, [3, ntargets]); - let mut charges = rlst_dynamic_array1!($scalar, [nsources]); + let mut sources = rlst_dynamic_array!($scalar, [3, nsources]); + let mut targets = rlst_dynamic_array!($scalar, [3, ntargets]); + let mut charges = rlst_dynamic_array!($scalar, [nsources]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); @@ -1316,27 +1315,27 @@ mod test { // Evaluate expected contribution. - let mut expected_value = rlst_dynamic_array1!($scalar, [ntargets]); - let mut expected_value_deriv = rlst_dynamic_array2!($scalar, [4, ntargets]); + let mut expected_value = rlst_dynamic_array!($scalar, [ntargets]); + let mut expected_value_deriv = rlst_dynamic_array!($scalar, [4, ntargets]); for (e_val, target, mut e_val_deriv) in izip!( expected_value.iter_mut(), targets.col_iter(), expected_value_deriv.col_iter_mut() ) { - for (source, charge) in izip!(sources.col_iter(), charges.iter()) { + for (source, charge) in izip!(sources.col_iter(), charges.iter_value()) { let mut res_val = [0.0]; let mut res_val_deriv = [0.0; 4]; ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res_val.as_mut_slice(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), res_val_deriv.as_mut_slice(), ); @@ -1350,28 +1349,28 @@ mod test { // Now compute the actual contribution - let mut actual_value = rlst_dynamic_array1!($scalar, [ntargets]); - let mut actual_value_deriv = rlst_dynamic_array2!($scalar, [4, ntargets]); + let mut actual_value = rlst_dynamic_array!($scalar, [ntargets]); + let mut actual_value_deriv = rlst_dynamic_array!($scalar, [4, ntargets]); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).evaluate_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - charges.data(), - actual_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + actual_value.data_mut().unwrap(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).evaluate_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - charges.data(), - actual_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + charges.data().unwrap(), + actual_value_deriv.data_mut().unwrap(), ); - for (a, e) in izip!(actual_value.iter(), expected_value.iter()) { + for (a, e) in izip!(actual_value.iter_value(), expected_value.iter_value()) { assert_relative_eq!(a, e, max_relative = eps); } - for (a, e) in izip!(actual_value_deriv.iter(), expected_value_deriv.iter()) { + for (a, e) in izip!(actual_value_deriv.iter_value(), expected_value_deriv.iter_value()) { assert_relative_eq!(a, e, max_relative = eps); } } @@ -1386,28 +1385,28 @@ mod test { let mut rng = rand::rngs::StdRng::seed_from_u64(0); - let mut sources = rlst_dynamic_array2!($scalar, [3, nsources]); - let mut targets = rlst_dynamic_array2!($scalar, [3, ntargets]); + let mut sources = rlst_dynamic_array!($scalar, [3, nsources]); + let mut targets = rlst_dynamic_array!($scalar, [3, ntargets]); sources.fill_from_equally_distributed(&mut rng); targets.fill_from_equally_distributed(&mut rng); // Now compute the actual contribution - let mut actual_value = rlst_dynamic_array2!($scalar, [nsources, ntargets]); - let mut actual_value_deriv = rlst_dynamic_array2!($scalar, [4 * nsources, ntargets]); + let mut actual_value = rlst_dynamic_array!($scalar, [nsources, ntargets]); + let mut actual_value_deriv = rlst_dynamic_array!($scalar, [4 * nsources, ntargets]); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).assemble_st( GreenKernelEvalType::Value, - sources.data(), - targets.data(), - actual_value.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + actual_value.data_mut().unwrap(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).assemble_st( GreenKernelEvalType::ValueDeriv, - sources.data(), - targets.data(), - actual_value_deriv.data_mut(), + sources.data().unwrap(), + targets.data().unwrap(), + actual_value_deriv.data_mut().unwrap(), ); // Evaluate expected contribution. @@ -1418,14 +1417,14 @@ mod test { let mut expected_val_deriv = [0.0; 4]; ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::Value, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected_val.as_mut_slice(), ); ModifiedHelmholtz3dKernel::<$scalar>::new(omega).greens_fct( GreenKernelEvalType::ValueDeriv, - source.data(), - target.data(), + source.data().unwrap(), + target.data().unwrap(), expected_val_deriv.as_mut_slice(), ); diff --git a/src/traits.rs b/src/traits.rs index c1cedfa..a34459f 100644 --- a/src/traits.rs +++ b/src/traits.rs @@ -4,8 +4,6 @@ use crate::types::GreenKernelEvalType; #[cfg(feature = "mpi")] use mpi::traits::{Communicator, Equivalence, Root}; use rlst::RlstScalar; -#[cfg(feature = "mpi")] -use rlst::{rlst_dynamic_array1, RawAccess, RawAccessMut}; /// Interface to evaluating Green's functions for given sources and targets. pub trait Kernel: Sync { @@ -24,17 +22,17 @@ pub trait Kernel: Sync { /// Single threaded evaluation of Green's functions. /// /// - `eval_type`: Either [EvalType::Value] to only return Green's function values - /// or [EvalType::ValueDeriv] to return values and derivatives. + /// or [EvalType::ValueDeriv] to return values and derivatives. /// - `sources`: A slice defining the source points. The points must be given in the form - /// `[x_1, x_2, ... x_N, y_1, y_2, ..., y_N, z_1, z_2, ..., z_N]`, that is - /// the value for each dimension must be continuously contained in the slice. + /// `[x_1, x_2, ... x_N, y_1, y_2, ..., y_N, z_1, z_2, ..., z_N]`, that is + /// the value for each dimension must be continuously contained in the slice. /// - `targets`: A slice defining the targets. The memory layout is the same as for sources. /// - `charges`: A slice defining the charges. For each source point there needs to be one charge. /// - `result`: The result array. If the kernel is RlstScalar and `eval_type` has the value [EvalType::Value] - /// then `result` has the same number of elemens as there are targets. For a RlstScalar kernel - /// in three dimensional space if [EvalType::ValueDeriv] was chosen then `result` contains - /// for each target in consecutive order the value of the kernel and the three components - /// of its derivative. + /// then `result` has the same number of elemens as there are targets. For a RlstScalar kernel + /// in three dimensional space if [EvalType::ValueDeriv] was chosen then `result` contains + /// for each target in consecutive order the value of the kernel and the three components + /// of its derivative. /// fn evaluate_st( &self, @@ -61,18 +59,18 @@ pub trait Kernel: Sync { /// Single threaded assembly of a kernel matrix. /// /// - `eval_type`: Either [EvalType::Value] to only return Green's function values - /// or [EvalType::ValueDeriv] to return values and derivatives. + /// or [EvalType::ValueDeriv] to return values and derivatives. /// - `sources`: A slice defining the source points. The points must be given in the form - /// `[x_1, x_2, ... x_N, y_1, y_2, ..., y_N, z_1, z_2, ..., z_N]`, that is - /// the value for each dimension must be continuously contained in the slice. + /// `[x_1, x_2, ... x_N, y_1, y_2, ..., y_N, z_1, z_2, ..., z_N]`, that is + /// the value for each dimension must be continuously contained in the slice. /// - `targets`: A slice defining the targets. The memory layout is the same as for sources. /// - `result`: The result array. If the kernel is RlstScalar and `eval_type` has the value [EvalType::Value] - /// then `result` is equivalent to a column major matrix of dimension [S, T], where S is the number of sources and - /// T is the number of targets. Hence, for each target all corresponding source evaluations are consecutively in memory. - /// For a RlstScalar kernel in three dimensional space if [EvalType::ValueDeriv] was chosen then `result` is equivalent - /// to a column-major matrix of dimension [4 * S, T], where the first 4 rows are the values of Green's fct. value and - /// derivatives for the first source and all targets. The next 4 rows correspond to values and derivatives of second source - /// with all targets and so on. + /// then `result` is equivalent to a column major matrix of dimension [S, T], where S is the number of sources and + /// T is the number of targets. Hence, for each target all corresponding source evaluations are consecutively in memory. + /// For a RlstScalar kernel in three dimensional space if [EvalType::ValueDeriv] was chosen then `result` is equivalent + /// to a column-major matrix of dimension [4 * S, T], where the first 4 rows are the values of Green's fct. value and + /// derivatives for the first source and all targets. The next 4 rows correspond to values and derivatives of second source + /// with all targets and so on. /// fn assemble_st( &self, @@ -126,6 +124,7 @@ pub trait Kernel: Sync { /// Otherwise, the evaluation on each rank is single-threaded. #[cfg(feature = "mpi")] pub trait DistributedKernelEvaluator: Kernel { + #[allow(clippy::too_many_arguments)] fn evaluate_distributed( &self, eval_type: GreenKernelEvalType, @@ -158,6 +157,8 @@ pub trait DistributedKernelEvaluator: Kernel { // Communicate the sources and charges from `rank` to all ranks. // We first need to tell all ranks how many sources and charges we have. + + use rlst::rlst_dynamic_array; let root_process = comm.process_at_rank(rank as i32); let nsources = { @@ -172,33 +173,33 @@ pub trait DistributedKernelEvaluator: Kernel { }; let mut root_sources = - rlst_dynamic_array1!(::Real, [3 * nsources]); - let mut root_charges = rlst_dynamic_array1!(Self::T, [nsources]); + rlst_dynamic_array!(::Real, [3 * nsources]); + let mut root_charges = rlst_dynamic_array!(Self::T, [nsources]); if comm.rank() == rank as i32 { - root_sources.data_mut().copy_from_slice(sources); - root_charges.data_mut().copy_from_slice(charges); + root_sources.data_mut().unwrap().copy_from_slice(sources); + root_charges.data_mut().unwrap().copy_from_slice(charges); } - root_process.broadcast_into(&mut root_sources.data_mut()[..]); - root_process.broadcast_into(&mut root_charges.data_mut()[..]); + root_process.broadcast_into(&mut root_sources.data_mut().unwrap()[..]); + root_process.broadcast_into(&mut root_charges.data_mut().unwrap()[..]); // We now have the sources and charges on all ranks. We can now simply evaluate. if use_multithreaded { self.evaluate_mt( eval_type, - &root_sources.data()[..], + root_sources.data().unwrap(), targets, - &root_charges.data()[..], + root_charges.data().unwrap(), result, ); } else { self.evaluate_st( eval_type, - &root_sources.data()[..], + root_sources.data().unwrap(), targets, - &root_charges.data()[..], + root_charges.data().unwrap(), result, ); }