wehub-resource-sync
e7738de6d2
CI / Deep Native Runtime Cases (1/6) (push) Has been skipped
CI / Native Preflight (push) Failing after 1s
CI / Native Runtime Cases (1/2) (push) Failing after 0s
CI / Native Runtime Cases (2/2) (push) Failing after 1s
CI / Native Metadata Reports (push) Failing after 0s
CI / Native Direct Backend Artifacts (push) Failing after 0s
CI / Native Sanitizer Smoke (push) Failing after 1s
CI / Command Contract Snapshots (push) Failing after 1s
CI / Deep Conformance Suite (push) Has been skipped
CI / Graph Build Perf (push) Failing after 1s
CI / Deep Native Preflight (push) Has been skipped
CI / Deep Native Runtime Cases (2/6) (push) Has been skipped
CI / Deep Native Runtime Cases (3/6) (push) Has been skipped
CI / Conformance Suite (push) Failing after 1s
CI / Workspace Checks (push) Failing after 0s
CI / Deep Native Runtime Cases (5/6) (push) Has been skipped
CI / Deep Native Runtime Cases (6/6) (push) Has been skipped
CI / Deep Native Runtime Cases (4/6) (push) Has been skipped
CI / Deep Graph Build Perf (push) Has been skipped
1008 lines
28 KiB
Plaintext
1008 lines
28 KiB
Plaintext
fn __zero_std_sort_insertion_i32(items: MutSpan<i32>) -> Void {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
let value: i32 = items[index]
|
|
var cursor: usize = index
|
|
while cursor > 0 && items[cursor - 1] > value {
|
|
items[cursor] = items[cursor - 1]
|
|
cursor = cursor - 1
|
|
}
|
|
items[cursor] = value
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_stable_i32(items: MutSpan<i32>) -> Void {
|
|
__zero_std_sort_insertion_i32(items)
|
|
}
|
|
|
|
fn __zero_std_sort_unstable_i32(items: MutSpan<i32>) -> Void {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < std.mem.len(items) {
|
|
if items[scan] < items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: i32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_reverse_i32(items: MutSpan<i32>) -> Void {
|
|
var left: usize = 0
|
|
var right: usize = std.mem.len(items)
|
|
while left < right {
|
|
right = right - 1
|
|
if left < right {
|
|
let value: i32 = items[left]
|
|
items[left] = items[right]
|
|
items[right] = value
|
|
left = left + 1
|
|
}
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_swap_i32(items: MutSpan<i32>, left: usize, right: usize) -> Bool {
|
|
if left >= std.mem.len(items) || right >= std.mem.len(items) {
|
|
return false
|
|
}
|
|
let value: i32 = items[left]
|
|
items[left] = items[right]
|
|
items[right] = value
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_rotate_left_i32(items: MutSpan<i32>, amount: usize) -> Void {
|
|
let len: usize = std.mem.len(items)
|
|
if len == 0 {
|
|
return
|
|
}
|
|
let shift: usize = amount % len
|
|
var step: usize = 0
|
|
while step < shift {
|
|
let first: i32 = items[0]
|
|
var index: usize = 1
|
|
while index < len {
|
|
items[index - 1] = items[index]
|
|
index = index + 1
|
|
}
|
|
items[len - 1] = first
|
|
step = step + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_rotate_right_i32(items: MutSpan<i32>, amount: usize) -> Void {
|
|
let len: usize = std.mem.len(items)
|
|
if len == 0 {
|
|
return
|
|
}
|
|
let shift: usize = amount % len
|
|
if shift > 0 {
|
|
__zero_std_sort_rotate_left_i32(items, len - shift)
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_is_sorted_i32(items: Span<i32>) -> Bool {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < items[index - 1] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_insertion_desc_i32(items: MutSpan<i32>) -> Void {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
let value: i32 = items[index]
|
|
var cursor: usize = index
|
|
while cursor > 0 && items[cursor - 1] < value {
|
|
items[cursor] = items[cursor - 1]
|
|
cursor = cursor - 1
|
|
}
|
|
items[cursor] = value
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_stable_desc_i32(items: MutSpan<i32>) -> Void {
|
|
__zero_std_sort_insertion_desc_i32(items)
|
|
}
|
|
|
|
fn __zero_std_sort_unstable_desc_i32(items: MutSpan<i32>) -> Void {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < std.mem.len(items) {
|
|
if items[scan] > items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: i32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_is_sorted_desc_i32(items: Span<i32>) -> Bool {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > items[index - 1] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_partition_i32(items: MutSpan<i32>, pivot: i32) -> usize {
|
|
var write: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] < pivot {
|
|
let value: i32 = items[index]
|
|
items[index] = items[write]
|
|
items[write] = value
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_is_partitioned_i32(items: Span<i32>, pivot: i32) -> Bool {
|
|
var seen_tail: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] < pivot {
|
|
if seen_tail {
|
|
return false
|
|
}
|
|
} else {
|
|
seen_tail = true
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_partition_desc_i32(items: MutSpan<i32>, pivot: i32) -> usize {
|
|
var write: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] > pivot {
|
|
let value: i32 = items[index]
|
|
items[index] = items[write]
|
|
items[write] = value
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_is_partitioned_desc_i32(items: Span<i32>, pivot: i32) -> Bool {
|
|
var seen_tail: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] > pivot {
|
|
if seen_tail {
|
|
return false
|
|
}
|
|
} else {
|
|
seen_tail = true
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_dedupe_sorted_i32(items: MutSpan<i32>) -> usize {
|
|
if std.mem.len(items) == 0 {
|
|
return 0
|
|
}
|
|
var write: usize = 1
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] != items[write - 1] {
|
|
items[write] = items[index]
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_select_nth_i32(items: MutSpan<i32>, nth: usize) -> Bool {
|
|
let len: usize = std.mem.len(items)
|
|
if nth >= len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index <= nth {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < len {
|
|
if items[scan] < items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: i32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_select_nth_desc_i32(items: MutSpan<i32>, nth: usize) -> Bool {
|
|
let len: usize = std.mem.len(items)
|
|
if nth >= len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index <= nth {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < len {
|
|
if items[scan] > items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: i32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_merge_sorted_i32(dst: MutSpan<i32>, left: Span<i32>, right: Span<i32>) -> usize {
|
|
var written: usize = 0
|
|
var left_index: usize = 0
|
|
var right_index: usize = 0
|
|
let capacity: usize = std.mem.len(dst)
|
|
while written < capacity && left_index < std.mem.len(left) && right_index < std.mem.len(right) {
|
|
if left[left_index] <= right[right_index] {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
} else {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
}
|
|
written = written + 1
|
|
}
|
|
while written < capacity && left_index < std.mem.len(left) {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
written = written + 1
|
|
}
|
|
while written < capacity && right_index < std.mem.len(right) {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
written = written + 1
|
|
}
|
|
return written
|
|
}
|
|
|
|
fn __zero_std_sort_merge_sorted_desc_i32(dst: MutSpan<i32>, left: Span<i32>, right: Span<i32>) -> usize {
|
|
var written: usize = 0
|
|
var left_index: usize = 0
|
|
var right_index: usize = 0
|
|
let capacity: usize = std.mem.len(dst)
|
|
while written < capacity && left_index < std.mem.len(left) && right_index < std.mem.len(right) {
|
|
if left[left_index] >= right[right_index] {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
} else {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
}
|
|
written = written + 1
|
|
}
|
|
while written < capacity && left_index < std.mem.len(left) {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
written = written + 1
|
|
}
|
|
while written < capacity && right_index < std.mem.len(right) {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
written = written + 1
|
|
}
|
|
return written
|
|
}
|
|
|
|
fn __zero_std_sort_insertion_u32(items: MutSpan<u32>) -> Void {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
let value: u32 = items[index]
|
|
var cursor: usize = index
|
|
while cursor > 0 && items[cursor - 1] > value {
|
|
items[cursor] = items[cursor - 1]
|
|
cursor = cursor - 1
|
|
}
|
|
items[cursor] = value
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_stable_u32(items: MutSpan<u32>) -> Void {
|
|
__zero_std_sort_insertion_u32(items)
|
|
}
|
|
|
|
fn __zero_std_sort_unstable_u32(items: MutSpan<u32>) -> Void {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < std.mem.len(items) {
|
|
if items[scan] < items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: u32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_reverse_u32(items: MutSpan<u32>) -> Void {
|
|
var left: usize = 0
|
|
var right: usize = std.mem.len(items)
|
|
while left < right {
|
|
right = right - 1
|
|
if left < right {
|
|
let value: u32 = items[left]
|
|
items[left] = items[right]
|
|
items[right] = value
|
|
left = left + 1
|
|
}
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_swap_u32(items: MutSpan<u32>, left: usize, right: usize) -> Bool {
|
|
if left >= std.mem.len(items) || right >= std.mem.len(items) {
|
|
return false
|
|
}
|
|
let value: u32 = items[left]
|
|
items[left] = items[right]
|
|
items[right] = value
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_rotate_left_u32(items: MutSpan<u32>, amount: usize) -> Void {
|
|
let len: usize = std.mem.len(items)
|
|
if len == 0 {
|
|
return
|
|
}
|
|
let shift: usize = amount % len
|
|
var step: usize = 0
|
|
while step < shift {
|
|
let first: u32 = items[0]
|
|
var index: usize = 1
|
|
while index < len {
|
|
items[index - 1] = items[index]
|
|
index = index + 1
|
|
}
|
|
items[len - 1] = first
|
|
step = step + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_rotate_right_u32(items: MutSpan<u32>, amount: usize) -> Void {
|
|
let len: usize = std.mem.len(items)
|
|
if len == 0 {
|
|
return
|
|
}
|
|
let shift: usize = amount % len
|
|
if shift > 0 {
|
|
__zero_std_sort_rotate_left_u32(items, len - shift)
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_is_sorted_u32(items: Span<u32>) -> Bool {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < items[index - 1] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_insertion_desc_u32(items: MutSpan<u32>) -> Void {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
let value: u32 = items[index]
|
|
var cursor: usize = index
|
|
while cursor > 0 && items[cursor - 1] < value {
|
|
items[cursor] = items[cursor - 1]
|
|
cursor = cursor - 1
|
|
}
|
|
items[cursor] = value
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_stable_desc_u32(items: MutSpan<u32>) -> Void {
|
|
__zero_std_sort_insertion_desc_u32(items)
|
|
}
|
|
|
|
fn __zero_std_sort_unstable_desc_u32(items: MutSpan<u32>) -> Void {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < std.mem.len(items) {
|
|
if items[scan] > items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: u32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_is_sorted_desc_u32(items: Span<u32>) -> Bool {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > items[index - 1] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_partition_u32(items: MutSpan<u32>, pivot: u32) -> usize {
|
|
var write: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] < pivot {
|
|
let value: u32 = items[index]
|
|
items[index] = items[write]
|
|
items[write] = value
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_is_partitioned_u32(items: Span<u32>, pivot: u32) -> Bool {
|
|
var seen_tail: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] < pivot {
|
|
if seen_tail {
|
|
return false
|
|
}
|
|
} else {
|
|
seen_tail = true
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_partition_desc_u32(items: MutSpan<u32>, pivot: u32) -> usize {
|
|
var write: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] > pivot {
|
|
let value: u32 = items[index]
|
|
items[index] = items[write]
|
|
items[write] = value
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_is_partitioned_desc_u32(items: Span<u32>, pivot: u32) -> Bool {
|
|
var seen_tail: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] > pivot {
|
|
if seen_tail {
|
|
return false
|
|
}
|
|
} else {
|
|
seen_tail = true
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_dedupe_sorted_u32(items: MutSpan<u32>) -> usize {
|
|
if std.mem.len(items) == 0 {
|
|
return 0
|
|
}
|
|
var write: usize = 1
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] != items[write - 1] {
|
|
items[write] = items[index]
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_select_nth_u32(items: MutSpan<u32>, nth: usize) -> Bool {
|
|
let len: usize = std.mem.len(items)
|
|
if nth >= len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index <= nth {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < len {
|
|
if items[scan] < items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: u32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_select_nth_desc_u32(items: MutSpan<u32>, nth: usize) -> Bool {
|
|
let len: usize = std.mem.len(items)
|
|
if nth >= len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index <= nth {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < len {
|
|
if items[scan] > items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: u32 = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_merge_sorted_u32(dst: MutSpan<u32>, left: Span<u32>, right: Span<u32>) -> usize {
|
|
var written: usize = 0
|
|
var left_index: usize = 0
|
|
var right_index: usize = 0
|
|
let capacity: usize = std.mem.len(dst)
|
|
while written < capacity && left_index < std.mem.len(left) && right_index < std.mem.len(right) {
|
|
if left[left_index] <= right[right_index] {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
} else {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
}
|
|
written = written + 1
|
|
}
|
|
while written < capacity && left_index < std.mem.len(left) {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
written = written + 1
|
|
}
|
|
while written < capacity && right_index < std.mem.len(right) {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
written = written + 1
|
|
}
|
|
return written
|
|
}
|
|
|
|
fn __zero_std_sort_merge_sorted_desc_u32(dst: MutSpan<u32>, left: Span<u32>, right: Span<u32>) -> usize {
|
|
var written: usize = 0
|
|
var left_index: usize = 0
|
|
var right_index: usize = 0
|
|
let capacity: usize = std.mem.len(dst)
|
|
while written < capacity && left_index < std.mem.len(left) && right_index < std.mem.len(right) {
|
|
if left[left_index] >= right[right_index] {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
} else {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
}
|
|
written = written + 1
|
|
}
|
|
while written < capacity && left_index < std.mem.len(left) {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
written = written + 1
|
|
}
|
|
while written < capacity && right_index < std.mem.len(right) {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
written = written + 1
|
|
}
|
|
return written
|
|
}
|
|
|
|
fn __zero_std_sort_insertion_usize(items: MutSpan<usize>) -> Void {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
let value: usize = items[index]
|
|
var cursor: usize = index
|
|
while cursor > 0 && items[cursor - 1] > value {
|
|
items[cursor] = items[cursor - 1]
|
|
cursor = cursor - 1
|
|
}
|
|
items[cursor] = value
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_stable_usize(items: MutSpan<usize>) -> Void {
|
|
__zero_std_sort_insertion_usize(items)
|
|
}
|
|
|
|
fn __zero_std_sort_unstable_usize(items: MutSpan<usize>) -> Void {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < std.mem.len(items) {
|
|
if items[scan] < items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: usize = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_reverse_usize(items: MutSpan<usize>) -> Void {
|
|
var left: usize = 0
|
|
var right: usize = std.mem.len(items)
|
|
while left < right {
|
|
right = right - 1
|
|
if left < right {
|
|
let value: usize = items[left]
|
|
items[left] = items[right]
|
|
items[right] = value
|
|
left = left + 1
|
|
}
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_swap_usize(items: MutSpan<usize>, left: usize, right: usize) -> Bool {
|
|
if left >= std.mem.len(items) || right >= std.mem.len(items) {
|
|
return false
|
|
}
|
|
let value: usize = items[left]
|
|
items[left] = items[right]
|
|
items[right] = value
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_rotate_left_usize(items: MutSpan<usize>, amount: usize) -> Void {
|
|
let len: usize = std.mem.len(items)
|
|
if len == 0 {
|
|
return
|
|
}
|
|
let shift: usize = amount % len
|
|
var step: usize = 0
|
|
while step < shift {
|
|
let first: usize = items[0]
|
|
var index: usize = 1
|
|
while index < len {
|
|
items[index - 1] = items[index]
|
|
index = index + 1
|
|
}
|
|
items[len - 1] = first
|
|
step = step + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_rotate_right_usize(items: MutSpan<usize>, amount: usize) -> Void {
|
|
let len: usize = std.mem.len(items)
|
|
if len == 0 {
|
|
return
|
|
}
|
|
let shift: usize = amount % len
|
|
if shift > 0 {
|
|
__zero_std_sort_rotate_left_usize(items, len - shift)
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_is_sorted_usize(items: Span<usize>) -> Bool {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] < items[index - 1] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_insertion_desc_usize(items: MutSpan<usize>) -> Void {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
let value: usize = items[index]
|
|
var cursor: usize = index
|
|
while cursor > 0 && items[cursor - 1] < value {
|
|
items[cursor] = items[cursor - 1]
|
|
cursor = cursor - 1
|
|
}
|
|
items[cursor] = value
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_stable_desc_usize(items: MutSpan<usize>) -> Void {
|
|
__zero_std_sort_insertion_desc_usize(items)
|
|
}
|
|
|
|
fn __zero_std_sort_unstable_desc_usize(items: MutSpan<usize>) -> Void {
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < std.mem.len(items) {
|
|
if items[scan] > items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: usize = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
}
|
|
|
|
fn __zero_std_sort_is_sorted_desc_usize(items: Span<usize>) -> Bool {
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] > items[index - 1] {
|
|
return false
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_partition_usize(items: MutSpan<usize>, pivot: usize) -> usize {
|
|
var write: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] < pivot {
|
|
let value: usize = items[index]
|
|
items[index] = items[write]
|
|
items[write] = value
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_is_partitioned_usize(items: Span<usize>, pivot: usize) -> Bool {
|
|
var seen_tail: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] < pivot {
|
|
if seen_tail {
|
|
return false
|
|
}
|
|
} else {
|
|
seen_tail = true
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_partition_desc_usize(items: MutSpan<usize>, pivot: usize) -> usize {
|
|
var write: usize = 0
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] > pivot {
|
|
let value: usize = items[index]
|
|
items[index] = items[write]
|
|
items[write] = value
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_is_partitioned_desc_usize(items: Span<usize>, pivot: usize) -> Bool {
|
|
var seen_tail: Bool = false
|
|
var index: usize = 0
|
|
while index < std.mem.len(items) {
|
|
if items[index] > pivot {
|
|
if seen_tail {
|
|
return false
|
|
}
|
|
} else {
|
|
seen_tail = true
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_dedupe_sorted_usize(items: MutSpan<usize>) -> usize {
|
|
if std.mem.len(items) == 0 {
|
|
return 0
|
|
}
|
|
var write: usize = 1
|
|
var index: usize = 1
|
|
while index < std.mem.len(items) {
|
|
if items[index] != items[write - 1] {
|
|
items[write] = items[index]
|
|
write = write + 1
|
|
}
|
|
index = index + 1
|
|
}
|
|
return write
|
|
}
|
|
|
|
fn __zero_std_sort_select_nth_usize(items: MutSpan<usize>, nth: usize) -> Bool {
|
|
let len: usize = std.mem.len(items)
|
|
if nth >= len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index <= nth {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < len {
|
|
if items[scan] < items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: usize = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_select_nth_desc_usize(items: MutSpan<usize>, nth: usize) -> Bool {
|
|
let len: usize = std.mem.len(items)
|
|
if nth >= len {
|
|
return false
|
|
}
|
|
var index: usize = 0
|
|
while index <= nth {
|
|
var best: usize = index
|
|
var scan: usize = index + 1
|
|
while scan < len {
|
|
if items[scan] > items[best] {
|
|
best = scan
|
|
}
|
|
scan = scan + 1
|
|
}
|
|
if best != index {
|
|
let value: usize = items[index]
|
|
items[index] = items[best]
|
|
items[best] = value
|
|
}
|
|
index = index + 1
|
|
}
|
|
return true
|
|
}
|
|
|
|
fn __zero_std_sort_merge_sorted_usize(dst: MutSpan<usize>, left: Span<usize>, right: Span<usize>) -> usize {
|
|
var written: usize = 0
|
|
var left_index: usize = 0
|
|
var right_index: usize = 0
|
|
let capacity: usize = std.mem.len(dst)
|
|
while written < capacity && left_index < std.mem.len(left) && right_index < std.mem.len(right) {
|
|
if left[left_index] <= right[right_index] {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
} else {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
}
|
|
written = written + 1
|
|
}
|
|
while written < capacity && left_index < std.mem.len(left) {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
written = written + 1
|
|
}
|
|
while written < capacity && right_index < std.mem.len(right) {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
written = written + 1
|
|
}
|
|
return written
|
|
}
|
|
|
|
fn __zero_std_sort_merge_sorted_desc_usize(dst: MutSpan<usize>, left: Span<usize>, right: Span<usize>) -> usize {
|
|
var written: usize = 0
|
|
var left_index: usize = 0
|
|
var right_index: usize = 0
|
|
let capacity: usize = std.mem.len(dst)
|
|
while written < capacity && left_index < std.mem.len(left) && right_index < std.mem.len(right) {
|
|
if left[left_index] >= right[right_index] {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
} else {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
}
|
|
written = written + 1
|
|
}
|
|
while written < capacity && left_index < std.mem.len(left) {
|
|
dst[written] = left[left_index]
|
|
left_index = left_index + 1
|
|
written = written + 1
|
|
}
|
|
while written < capacity && right_index < std.mem.len(right) {
|
|
dst[written] = right[right_index]
|
|
right_index = right_index + 1
|
|
written = written + 1
|
|
}
|
|
return written
|
|
}
|