alg_tools: comparison src/bisection

-:495448cca603
+:6aa955ad8122
 ///
 /// For the type and const parameters, see the [module level documentation][super].
 #[derive(Clone, Debug)]
 pub(super) struct Branches<F: Num, D, A: Aggregator, const N: usize, const P: usize> {
 /// Point for subdivision of the (unstored) [`Cube`] corresponding to the node.
-pub(super) branch_at: Loc<F, N>,
+pub(super) branch_at: Loc<N, F>,
 /// Subnodes
 pub(super) nodes: [Node<F, D, A, N, P>; P],
 }
 /// Dirty workaround to broken Rust drop, see [https://github.com/rust-lang/rust/issues/58068]().
 {
 /// Returns the index in {0, …, `P`-1} for the branch to which the point `x` corresponds.
 ///
 /// This only takes the branch subdivision point $d$ into account, so is always succesfull.
 /// Thus, for this point, each branch corresponds to a quadrant of $ℝ^N$ relative to $d$.
-fn get_node_index(&self, x: &Loc<F, N>) -> usize {
+fn get_node_index(&self, x: &Loc<N, F>) -> usize {
 izip!(0..P, x.iter(), self.branch_at.iter())
 .map(|(i, x_i, branch_i)| if x_i > branch_i { 1 << i } else { 0 })
 .sum()
 }
 /// Returns the node within `Self` containing the point `x`.
 ///
 /// This only takes the branch subdivision point $d$ into account, so is always succesfull.
 /// Thus, for this point, each branch corresponds to a quadrant of $ℝ^N$ relative to $d$.
 #[inline]
-fn get_node(&self, x: &Loc<F, N>) -> &Node<F, D, A, N, P> {
+fn get_node(&self, x: &Loc<N, F>) -> &Node<F, D, A, N, P> {
 &self.nodes[self.get_node_index(x)]
 }
 }
 /// An iterator over the $P=2^N$ subcubes of a [`Cube`] subdivided at a point `d`.
 pub(super) struct SubcubeIter<'b, F: Float, const N: usize, const P: usize> {
-domain: &'b Cube<F, N>,
+domain: &'b Cube<N, F>,
-branch_at: Loc<F, N>,
+branch_at: Loc<N, F>,
 index: usize,
 }
 /// Returns the `i`:th subcube of `domain` subdivided at `branch_at`.
 #[inline]
 fn get_subcube<F: Float, const N: usize>(
-branch_at: &Loc<F, N>,
+branch_at: &Loc<N, F>,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 i: usize,
-) -> Cube<F, N> {
+) -> Cube<N, F> {
 map2_indexed(branch_at, domain, move |j, &branch, &[start, end]| {
 if i & (1 << j) != 0 {
 [branch, end]
 } else {
 [start, branch]
 })
 .into()
 }
 impl<'a, 'b, F: Float, const N: usize, const P: usize> Iterator for SubcubeIter<'b, F, N, P> {
-type Item = Cube<F, N>;
+type Item = Cube<N, F>;
 #[inline]
 fn next(&mut self) -> Option<Self::Item> {
 if self.index < P {
 let i = self.index;
 self.index += 1;
 A: Aggregator,
 D: 'static + Copy + Send + Sync,
 {
 /// Creates a new node branching structure, subdividing `domain` based on the
 /// [hint][Support::support_hint] of `support`.
-pub(super) fn new_with<S: LocalAnalysis<F, A, N> + Support<F, N>>(
+pub(super) fn new_with<S: LocalAnalysis<F, A, N> + Support<N, F>>(
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 support: &S,
 ) -> Self {
 let hint = support.bisection_hint(domain);
 let branch_at = map2(&hint, domain, |h, r| {
 h.unwrap_or_else(|| (r[0] + r[1]) / F::TWO)
 }
 /// Returns an iterator over the subcubes of `domain` subdivided at the branching point
 /// of `self`.
 #[inline]
-pub(super) fn iter_subcubes<'b>(&self, domain: &'b Cube<F, N>) -> SubcubeIter<'b, F, N, P> {
+pub(super) fn iter_subcubes<'b>(&self, domain: &'b Cube<N, F>) -> SubcubeIter<'b, F, N, P> {
 SubcubeIter {
 domain: domain,
 branch_at: self.branch_at,
 index: 0,
 }
 }
 /*
 /// Returns an iterator over all nodes and corresponding subcubes of `self`.
 #[inline]
-pub(super) fn nodes_and_cubes<'a, 'b>(&'a self, domain : &'b Cube<F, N>)
+pub(super) fn nodes_and_cubes<'a, 'b>(&'a self, domain : &'b Cube<N, F>)
 -> std::iter::Zip<Iter<'a, Node<F,D,A,N,P>>, SubcubeIter<'b, F, N, P>> {
 self.nodes.iter().zip(self.iter_subcubes(domain))
 }
 */
 /// Mutably iterate over all nodes and corresponding subcubes of `self`.
 #[inline]
 pub(super) fn nodes_and_cubes_mut<'a, 'b>(
 &'a mut self,
-domain: &'b Cube<F, N>,
+domain: &'b Cube<N, F>,
 ) -> std::iter::Zip<IterMut<'a, Node<F, D, A, N, P>>, SubcubeIter<'b, F, N, P>> {
 let subcube_iter = self.iter_subcubes(domain);
 self.nodes.iter_mut().zip(subcube_iter)
 }
 /// Call `f` on all `(subnode, subcube)` pairs in multiple threads, if `guard` so deems.
 #[inline]
 fn recurse<'scope, 'smaller, 'refs>(
 &'smaller mut self,
-domain: &'smaller Cube<F, N>,
+domain: &'smaller Cube<N, F>,
 task_budget: TaskBudget<'scope, 'refs>,
-guard: impl Fn(&Node<F, D, A, N, P>, &Cube<F, N>) -> bool + Send + 'smaller,
+guard: impl Fn(&Node<F, D, A, N, P>, &Cube<N, F>) -> bool + Send + 'smaller,
-mut f: impl for<'a> FnMut(&mut Node<F, D, A, N, P>, &Cube<F, N>, TaskBudget<'smaller, 'a>)
+mut f: impl for<'a> FnMut(&mut Node<F, D, A, N, P>, &Cube<N, F>, TaskBudget<'smaller, 'a>)
 + Send
 + Copy
 + 'smaller,
 ) where
 'scope: 'smaller,
 ///  * `d` is the data to be inserted
 ///  * `new_leaf_depth` is the depth relative to `self` at which the data is to be inserted.
 ///  * `support` is the [`Support`] that is used determine with which subcubes of `domain`
 ///     (at subdivision depth `new_leaf_depth`) the data `d` is to be associated with.
 ///
-pub(super) fn insert<'refs, 'scope, M: Depth, S: LocalAnalysis<F, A, N> + Support<F, N>>(
+pub(super) fn insert<'refs, 'scope, M: Depth, S: LocalAnalysis<F, A, N> + Support<N, F>>(
 &mut self,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 d: D,
 new_leaf_depth: M,
 support: &S,
 task_budget: TaskBudget<'scope, 'refs>,
 ) {
 /// The type parameter `ANew´ is the new aggregator, and needs to be implemented for the
 /// generator's `SupportType`.
 pub(super) fn convert_aggregator<ANew, G>(
 self,
 generator: &G,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 ) -> Branches<F, D, ANew, N, P>
 where
 ANew: Aggregator,
-G: SupportGenerator<F, N, Id = D>,
+G: SupportGenerator<N, F, Id = D>,
 G::SupportType: LocalAnalysis<F, ANew, N>,
 {
 let branch_at = self.branch_at;
 let subcube_iter = self.iter_subcubes(domain);
 let new_nodes = self
 /// The `generator` is used to convert the data of type `D` of the branch into corresponding
 /// [`Support`]s. The `domain` is the cube corresponding to `self`.
 pub(super) fn refresh_aggregator<'refs, 'scope, G>(
 &mut self,
 generator: &G,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 task_budget: TaskBudget<'scope, 'refs>,
 ) where
-G: SupportGenerator<F, N, Id = D>,
+G: SupportGenerator<N, F, Id = D>,
 G::SupportType: LocalAnalysis<F, A, N>,
 {
 self.recurse(
 domain,
 task_budget,
 }
 /*
 /// Get leaf data
 #[inline]
-pub(super) fn get_leaf_data(&self, x : &Loc<F, N>) -> Option<&Vec<D>> {
+pub(super) fn get_leaf_data(&self, x : &Loc<N, F>) -> Option<&Vec<D>> {
 match self.data {
 NodeOption::Uninitialised => None,
 NodeOption::Leaf(ref data) => Some(data),
 NodeOption::Branches(ref b) => b.get_node(x).get_leaf_data(x),
 }
 }*/
 /// Get leaf data iterator
 #[inline]
-pub(super) fn get_leaf_data_iter(&self, x: &Loc<F, N>) -> Option<std::slice::Iter<'_, D>> {
+pub(super) fn get_leaf_data_iter(&self, x: &Loc<N, F>) -> Option<std::slice::Iter<'_, D>> {
 match self.data {
 NodeOption::Uninitialised => None,
 NodeOption::Leaf(ref data) => Some(data.iter()),
 NodeOption::Branches(ref b) => b.get_node(x).get_leaf_data_iter(x),
 }
 ///
 /// If `self` is already [`NodeOption::Leaf`], the data is inserted directly in this node.
 /// If `self` is a [`NodeOption::Branches`], the data is passed to branches whose subcubes
 /// `support` intersects. If an [`NodeOption::Uninitialised`] node is encountered, a new leaf is
 /// created at a minimum depth of `new_leaf_depth`.
-pub(super) fn insert<'refs, 'scope, M: Depth, S: LocalAnalysis<F, A, N> + Support<F, N>>(
+pub(super) fn insert<'refs, 'scope, M: Depth, S: LocalAnalysis<F, A, N> + Support<N, F>>(
 &mut self,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 d: D,
 new_leaf_depth: M,
 support: &S,
 task_budget: TaskBudget<'scope, 'refs>,
 ) {
 /// The type parameter `ANew´ is the new aggregator, and needs to be implemented for the
 /// generator's `SupportType`.
 pub(super) fn convert_aggregator<ANew, G>(
 mut self,
 generator: &G,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 ) -> Node<F, D, ANew, N, P>
 where
 ANew: Aggregator,
-G: SupportGenerator<F, N, Id = D>,
+G: SupportGenerator<N, F, Id = D>,
 G::SupportType: LocalAnalysis<F, ANew, N>,
 {
 // The mem::replace is needed due to the [`Drop`] implementation to extract self.data.
 match std::mem::replace(&mut self.data, NodeOption::Uninitialised) {
 NodeOption::Uninitialised => Node {
 /// The `generator` is used to convert the data of type `D` of the node into corresponding
 /// [`Support`]s. The `domain` is the cube corresponding to `self`.
 pub(super) fn refresh_aggregator<'refs, 'scope, G>(
 &mut self,
 generator: &G,
-domain: &Cube<F, N>,
+domain: &Cube<N, F>,
 task_budget: TaskBudget<'scope, 'refs>,
 ) where
-G: SupportGenerator<F, N, Id = D>,
+G: SupportGenerator<N, F, Id = D>,
 G::SupportType: LocalAnalysis<F, A, N>,
 {
 match &mut self.data {
 NodeOption::Uninitialised => {}
 NodeOption::Leaf(v) => {
 pub struct BTNodeLookup;
 /// Basic interface to a [`BT`] bisection tree.
 ///
 /// Further routines are provided by the [`BTSearch`][super::refine::BTSearch] trait.
-pub trait BTImpl<F: Float, const N: usize>:
+pub trait BTImpl<const N: usize, F: Float = f64>:
 std::fmt::Debug + Clone + GlobalAnalysis<F, Self::Agg>
 {
 /// The data type stored in the tree
 type Data: 'static + Copy + Send + Sync;
 /// The depth type of the tree
 type Depth: Depth;
 /// The type for the [aggregate information][Aggregator] about the `Data` stored in each node
 /// of the tree.
 type Agg: Aggregator;
 /// The type of the tree with the aggregator converted to `ANew`.
-type Converted<ANew>: BTImpl<F, N, Data = Self::Data, Agg = ANew>
+type Converted<ANew>: BTImpl<N, F, Data = Self::Data, Agg = ANew>
 where
 ANew: Aggregator;
 /// Insert the data `d` into the tree for `support`.
 ///
 /// Every leaf node of the tree that intersects the `support` will contain a copy of
 /// `d`.
-fn insert<S: LocalAnalysis<F, Self::Agg, N> + Support<F, N>>(
+fn insert<S: LocalAnalysis<F, Self::Agg, N> + Support<N, F>>(
 &mut self,
 d: Self::Data,
 support: &S,
 );
 /// The `generator` is used to convert the data of type [`Self::Data`] contained in the tree
 /// into corresponding [`Support`]s.
 fn convert_aggregator<ANew, G>(self, generator: &G) -> Self::Converted<ANew>
 where
 ANew: Aggregator,
-G: SupportGenerator<F, N, Id = Self::Data>,
+G: SupportGenerator<N, F, Id = Self::Data>,
 G::SupportType: LocalAnalysis<F, ANew, N>;
 /// Refreshes the aggregator of the three after possible changes to the support generator.
 ///
 /// The `generator` is used to convert the data of type [`Self::Data`] contained in the tree
 /// into corresponding [`Support`]s.
 fn refresh_aggregator<G>(&mut self, generator: &G)
 where
-G: SupportGenerator<F, N, Id = Self::Data>,
+G: SupportGenerator<N, F, Id = Self::Data>,
 G::SupportType: LocalAnalysis<F, Self::Agg, N>;
 /// Returns an iterator over all [`Self::Data`] items at the point `x` of the domain.
-fn iter_at(&self, x: &Loc<F, N>) -> std::slice::Iter<'_, Self::Data>;
+fn iter_at(&self, x: &Loc<N, F>) -> std::slice::Iter<'_, Self::Data>;
 /*
 /// Returns all [`Self::Data`] items at the point `x` of the domain.
-fn data_at(&self, x : &Loc<F,N>) -> Arc<Vec<Self::Data>>;
+fn data_at(&self, x : &Loc<N, F>) -> Arc<Vec<Self::Data>>;
 */
 /// Create a new tree on `domain` of indicated `depth`.
-fn new(domain: Cube<F, N>, depth: Self::Depth) -> Self;
+fn new(domain: Cube<N, F>, depth: Self::Depth) -> Self;
 }
 /// The main bisection tree structure.
 ///
 /// It should be accessed via the [`BTImpl`] trait to hide the `const P : usize` parameter until
 BTNodeLookup: BTNode<F, D, A, N>,
 {
 /// The depth of the tree (initial, before refinement)
 pub(super) depth: M,
 /// The domain of the toplevel node
-pub(super) domain: Cube<F, N>,
+pub(super) domain: Cube<N, F>,
 /// The toplevel node of the tree
 pub(super) topnode: <BTNodeLookup as BTNode<F, D, A, N>>::Node,
 }
 macro_rules! impl_bt {
 D : 'static + Copy + Send + Sync + std::fmt::Debug,
 A : Aggregator {
 type Node = Node<F,D,A,$n,{pow(2, $n)}>;
 }
-impl<M,F,D,A> BTImpl<F,$n> for BT<M,F,D,A,$n>
+impl<M,F,D,A> BTImpl<$n, F> for BT<M,F,D,A,$n>
 where M : Depth,
 F : Float,
 D : 'static + Copy + Send + Sync + std::fmt::Debug,
 A : Aggregator {
 type Data = D;
 type Depth = M;
 type Agg = A;
 type Converted<ANew> = BT<M,F,D,ANew,$n> where ANew : Aggregator;
-fn insert<S: LocalAnalysis<F, A, $n> + Support<F, $n>>(
+fn insert<S: LocalAnalysis<F, A, $n> + Support< $n, F>>(
 &mut self,
 d : D,
 support : &S
 ) {
 with_task_budget(|task_budget|
 )
 }
 fn convert_aggregator<ANew, G>(self, generator : &G) -> Self::Converted<ANew>
 where ANew : Aggregator,
-G : SupportGenerator<F, $n, Id=D>,
+G : SupportGenerator< $n, F, Id=D>,
 G::SupportType : LocalAnalysis<F, ANew, $n> {
 let topnode = self.topnode.convert_aggregator(generator, &self.domain);
 BT {
 depth : self.depth,
 topnode
 }
 }
 fn refresh_aggregator<G>(&mut self, generator : &G)
-where G : SupportGenerator<F, $n, Id=Self::Data>,
+where G : SupportGenerator< $n, F, Id=Self::Data>,
 G::SupportType : LocalAnalysis<F, Self::Agg, $n> {
 with_task_budget(|task_budget|
 self.topnode.refresh_aggregator(generator, &self.domain, task_budget)
 )
 }
-/*fn data_at(&self, x : &Loc<F,$n>) -> Arc<Vec<D>> {
+/*fn data_at(&self, x : &Loc<$n, F>) -> Arc<Vec<D>> {
 self.topnode.get_leaf_data(x).unwrap_or_else(|| Arc::new(Vec::new()))
 }*/
-fn iter_at(&self, x : &Loc<F,$n>) -> std::slice::Iter<'_, D> {
+fn iter_at(&self, x : &Loc<$n, F>) -> std::slice::Iter<'_, D> {
 self.topnode.get_leaf_data_iter(x).unwrap_or_else(|| [].iter())
 }
-fn new(domain : Cube<F, $n>, depth : M) -> Self {
+fn new(domain : Cube<$n, F>, depth : M) -> Self {
 BT {
 depth : depth,
 domain : domain,
 topnode : Node::new(),
 }

comparison: src/bisection_tree/bt.rs

src/bisection_tree/bt.rs

Mercurial > repos > alg_tools / file comparison

comparison: src/bisection_tree/bt.rs

src/bisection_tree/bt.rs