Lines Matching defs:pos
1826 fn pos(n: usize) -> BTreeSet<i32> {
2003 set_bench! {intersection_100_neg_vs_100_pos, intersection, count, [neg(100), pos(100)]}
2004 set_bench! {intersection_100_neg_vs_10k_pos, intersection, count, [neg(100), pos(10_000)]}
2005 set_bench! {intersection_100_pos_vs_100_neg, intersection, count, [pos(100), neg(100)]}
2006 set_bench! {intersection_100_pos_vs_10k_neg, intersection, count, [pos(100), neg(10_000)]}
2007 set_bench! {intersection_10k_neg_vs_100_pos, intersection, count, [neg(10_000), pos(100)]}
2008 set_bench! {intersection_10k_neg_vs_10k_pos, intersection, count, [neg(10_000), pos(10_000)]}
2009 set_bench! {intersection_10k_pos_vs_100_neg, intersection, count, [pos(10_000), neg(100)]}
2010 set_bench! {intersection_10k_pos_vs_10k_neg, intersection, count, [pos(10_000), neg(10_000)]}
2025 set_bench! {is_subset_100_vs_100, is_subset, clone, [pos(100), pos(100)]}
2026 set_bench! {is_subset_100_vs_10k, is_subset, clone, [pos(100), pos(10_000)]}
2027 set_bench! {is_subset_10k_vs_100, is_subset, clone, [pos(10_000), pos(100)]}
2028 set_bench! {is_subset_10k_vs_10k, is_subset, clone, [pos(10_000), pos(10_000)]}
4595 let mut pos = 0;
4599 assert_eq!(c, v[pos]);
4600 pos += 1;
4602 assert_eq!(pos, v.len());
4611 let mut pos = 0;
4615 assert_eq!(c, v[pos]);
4616 pos += 1;
4618 assert_eq!(pos, v.len());
4678 let mut pos = 0;
4681 assert_eq!(b, v[pos]);
4682 pos += 1;
4693 let mut pos = v.len();
4696 pos -= 1;
4697 assert_eq!(b, v[pos]);
4737 let mut pos = 0;
4741 assert_eq!(c, (p[pos], v[pos]));
4742 pos += 1;
4744 assert_eq!(pos, v.len());
4745 assert_eq!(pos, p.len());
4754 let mut pos = 0;
4758 assert_eq!(c, (p[pos], v[pos]));
4759 pos += 1;
4761 assert_eq!(pos, v.len());
4762 assert_eq!(pos, p.len());
15144 let pos = result.len();
15145 let target = result.get_unchecked_mut(pos..reserved_len);
31482 let (kv, pos) = kv.remove_kv_tracking(|| {
31489 self.cur_leaf_edge = Some(pos);
34227 self.visit_nodes_in_order(|pos| match pos {
37419 for pos in 0..=size {
37421 assert!(map.insert(pos * 2, ()).is_none());
37429 for pos in 0..=size {
37437 assert!(map.insert(pos * 2, ()).is_none());
37757 let (old_kv, mut pos) = self.remove();
37758 let len = pos.reborrow().into_node().len();
37760 let idx = pos.idx();
37763 let new_pos = match pos.into_node().forget_type().choose_parent_kv() {
37782 Err(pos) => unsafe { Handle::new_edge(pos, idx) },
37785 pos = unsafe { new_pos.cast_to_leaf_unchecked() };
37790 // SAFETY: We won't destroy or rearrange the leaf where `pos` is at
37794 if let Ok(parent) = unsafe { pos.reborrow_mut() }.into_node().ascend() {
37800 (old_kv, pos)
37820 let pos = internal.next_leaf_edge();
37821 (old_kv, pos)
39656 self.visit_nodes_in_order(|pos| match pos {
44800 /// The caller must guarantee that `pos < self.len()`.
44801 unsafe fn sift_up(&mut self, start: usize, pos: usize) -> usize {
44802 // Take out the value at `pos` and create a hole.
44803 // SAFETY: The caller guarantees that pos < self.len()
44804 let mut hole = unsafe { Hole::new(&mut self.data, pos) };
44806 while hole.pos() > start {
44807 let parent = (hole.pos() - 1) / 2;
44809 // SAFETY: hole.pos() > start >= 0, which means hole.pos() > 0
44810 // and so hole.pos() - 1 can't underflow.
44811 // This guarantees that parent < hole.pos() so
44812 // it's a valid index and also != hole.pos().
44821 hole.pos()
44824 /// Take an element at `pos` and move it down the heap,
44829 /// The caller must guarantee that `pos < end <= self.len()`.
44830 unsafe fn sift_down_range(&mut self, pos: usize, end: usize) {
44831 // SAFETY: The caller guarantees that pos < end <= self.len().
44832 let mut hole = unsafe { Hole::new(&mut self.data, pos) };
44833 let mut child = 2 * hole.pos() + 1;
44835 // Loop invariant: child == 2 * hole.pos() + 1.
44840 // child == 2 * hole.pos() + 1 != hole.pos() and
44841 // child + 1 == 2 * hole.pos() + 2 != hole.pos().
44842 // FIXME: 2 * hole.pos() + 1 or 2 * hole.pos() + 2 could overflow
44848 // We already proven that both are < self.len() and != hole.pos()
44855 child = 2 * hole.pos() + 1;
44862 // child == 2 * hole.pos() + 1 != hole.pos().
44869 /// The caller must guarantee that `pos < self.len()`.
44870 unsafe fn sift_down(&mut self, pos: usize) {
44872 // SAFETY: pos < len is guaranteed by the caller and
44874 unsafe { self.sift_down_range(pos, len) };
44877 /// Take an element at `pos` and move it all the way down the heap,
44885 /// The caller must guarantee that `pos < self.len()`.
44886 unsafe fn sift_down_to_bottom(&mut self, mut pos: usize) {
44888 let start = pos;
44890 // SAFETY: The caller guarantees that pos < self.len().
44891 let mut hole = unsafe { Hole::new(&mut self.data, pos) };
44892 let mut child = 2 * hole.pos() + 1;
44894 // Loop invariant: child == 2 * hole.pos() + 1.
44898 // child == 2 * hole.pos() + 1 != hole.pos() and
44899 // child + 1 == 2 * hole.pos() + 2 != hole.pos().
44900 // FIXME: 2 * hole.pos() + 1 or 2 * hole.pos() + 2 could overflow
44906 child = 2 * hole.pos() + 1;
44911 // and child == 2 * hole.pos() + 1 != hole.pos().
44914 pos = hole.pos();
44917 // SAFETY: pos is the position in the hole and was already proven
44919 unsafe { self.sift_up(start, pos) };
45388 pos: usize,
45392 /// Create a new `Hole` at index `pos`.
45394 /// Unsafe because pos must be within the data slice.
45396 unsafe fn new(data: &'a mut [T], pos: usize) -> Self {
45397 debug_assert!(pos < data.len());
45398 // SAFE: pos should be inside the slice
45399 let elt = unsafe { ptr::read(data.get_unchecked(pos)) };
45400 Hole { data, elt: ManuallyDrop::new(elt), pos }
45404 fn pos(&self) -> usize {
45405 self.pos
45416 /// Unsafe because index must be within the data slice and not equal to pos.
45419 debug_assert!(index != self.pos);
45426 /// Unsafe because index must be within the data slice and not equal to pos.
45429 debug_assert!(index != self.pos);
45434 let hole_ptr = ptr.add(self.pos);
45437 self.pos = index;
45446 let pos = self.pos;
45447 ptr::copy_nonoverlapping(&*self.elt, self.data.get_unchecked_mut(pos), 1);