Lines Matching refs:time
1276 // Disabling on android for the time being
2484 // This comparison should be true only 1% of the time.
2558 use std::{collections::VecDeque, time::Instant};
15106 // only user of this function. It is left in place for the time when that is fixed.
16291 /// Indexing is intended to be a constant-time operation, but UTF-8 encoding
16363 /// let story = String::from("Once upon a time...");
16381 /// assert_eq!(String::from("Once upon a time..."), s);
18216 /// every operation, which would lead to *O*(*n*^2) running time when building an *n*-byte string by
19514 //! will check *at compile time* that you are not sending [`Rc`]s between
19850 /// stored for use at a later time.
19887 // else the memory might be freed by the time `data_fn` returns. If
21585 /// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this
22343 /// heapsort, while achieving linear time on slices with certain patterns. It uses some
22999 /// The invariants ensure that the total running time is *O*(*n* \* log(*n*)) worst-case.
23450 // unhappy if a thread outlives the main thread and then exits at the same time
23613 /// stored for use at a later time.
23646 // else the memory might be freed by the time `data_fn` returns. If
24173 /// Another thread can change the weak count at any time,
24202 /// Another thread can change the strong count at any time,
24307 // Destroy the data at this time, even though we may not free the box
24997 /// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this
25292 // If we find out that we were the last weak pointer, then its time to
25847 //! iterator over the argument. Each time a "next argument" specifier is seen,
25854 //! The internal iterator over the argument has not been advanced by the time
25861 //! compile-time error. You may refer to the same argument more than once in the
26948 //! in constant time.
26976 /// in constant time.
27196 // This method takes care not to create multiple mutable references to whole nodes at the same time,
27345 /// This operation should compute in *O*(1) time and *O*(1) memory.
27502 /// This operation should compute in *O*(1) time.
27523 /// This operation should compute in *O*(1) time.
27550 /// This operation should compute in *O*(*n*) time.
27693 /// This operation should compute in *O*(1) time.
27716 /// This operation should compute in *O*(1) time.
27739 /// This operation should compute in *O*(1) time.
27759 /// This operation should compute in *O*(1) time.
27780 /// This operation should compute in *O*(*n*) time.
27836 /// This operation should compute in *O*(*n*) time.
29208 // We prepare to merge `left` and `right` into a sorted sequence in linear time.
29211 // Meanwhile, we build a tree from the sorted sequence in linear time.
31251 // don't have to care about panics this time (they'll abort).
36349 // Has proper order the first time asked, then flips around.
38633 // We don't need the full generality of `#[derive(Clone)]`, as the only time `Node` will be
42657 /// Takes `*O*(min(mid, len() - mid))` time and no extra space.
42700 /// Takes `*O*(min(k, len() - k))` time and no extra space.
44270 //! Insertion and popping the largest element have *O*(log(*n*)) time complexity.
44672 /// If the item is modified then the worst case time complexity is *O*(log(*n*)),
44734 /// The time complexity degrades if elements are pushed in predominantly
45726 /// This conversion happens in-place, and has *O*(*n*) time complexity.
45739 /// constant time complexity.
48177 // the stack and in the vector at the same time.
51939 // exponentially. At the time of writing this test grow