| /*@ Import Lean | |
| import Algorithms.discretize.lean.helper_lib | |
| open scoped SimpleC | |
| */ | |
| /*@ Extern Coq (permutation : list Z -> list Z -> Prop) */ | |
| /*@ Extern Coq (increasing : list Z -> Prop) */ | |
| /*@ Extern Coq (same_outside_range : list Z -> list Z -> Z -> Z -> Prop) */ | |
| /*@ Extern Coq (partitioned_at : list Z -> Z -> Z -> Z -> Prop) */ | |
| /*@ Extern Coq (sorted_range : list Z -> Z -> Z -> Prop) */ | |
| /*@ Extern Coq (partition_scan_inv : list Z -> list Z -> Z -> Z -> Z -> Z -> Z -> Prop) */ | |
| /*@ Extern Coq (strict_increasing : list Z -> Prop) */ | |
| /*@ Extern Coq (dedup_scan_inv : list Z -> list Z -> list Z -> Z -> Z -> Prop) */ | |
| /*@ Extern Coq (discretize_result : list Z -> Z -> list Z -> Z -> Prop) */ | |
| /*@ Extern Coq (query_forward_result : list Z -> Z -> Z -> Z -> Prop) */ | |
| /*@ Extern Coq (query_forward_search_inv : list Z -> Z -> Z -> Z -> Z -> Prop) */ | |
| void swap(int *arr, int i, int j) | |
| /*@ With n l | |
| Require 0 <= i && i < n && 0 <= j && j < n && | |
| IntArray::full(arr, n, l) | |
| Ensure IntArray::full(arr, n, | |
| replace_Znth(j, Znth(i, l, 0), replace_Znth(i, Znth(j, l, 0), l))) | |
| */ | |
| { | |
| int tmp = arr[i]; | |
| arr[i] = arr[j]; | |
| arr[j] = tmp; | |
| } | |
| int partition(int *arr, int n, int low, int high) | |
| /*@ With l | |
| Require 0 <= low && low <= high && high < n && | |
| IntArray::full(arr, n, l) | |
| Ensure low <= __return && __return <= high && | |
| exists l1, | |
| permutation(l, l1) && | |
| same_outside_range(l, l1, low, high) && | |
| partitioned_at(l1, low, high, __return) && | |
| IntArray::full(arr, n, l1) | |
| */ | |
| { | |
| int pivot = arr[high]; | |
| int i = low - 1; | |
| /*@ Inv Assert | |
| exists l1, | |
| arr == arr@pre && n == n@pre && | |
| low == low@pre && high == high@pre && | |
| pivot == Znth(high, l, 0) && | |
| 0 <= low && low <= high && high < n && | |
| low - 1 <= i && i < j && j <= high && | |
| partition_scan_inv(l, l1, low, high, pivot, i, j) && | |
| IntArray::full(arr, n, l1) | |
| */ | |
| for (int j = low; j < high; j++) { | |
| if (arr[j] <= pivot) { | |
| i++; | |
| swap(arr, i, j); | |
| } | |
| } | |
| swap(arr, i + 1, high); | |
| return i + 1; | |
| } | |
| void quicksort_range(int *arr, int n, int left, int right) | |
| /*@ With l | |
| Require 0 <= n && 0 <= left && -1 <= right && right < n && | |
| IntArray::full(arr, n, l) | |
| Ensure exists l1, | |
| permutation(l, l1) && | |
| same_outside_range(l, l1, left, right) && | |
| sorted_range(l1, left, right) && | |
| IntArray::full(arr, n, l1) | |
| */ | |
| { | |
| if (left < right) { | |
| int p = partition(arr, n, left, right); | |
| if (p > left) { | |
| quicksort_range(arr, n, left, p - 1); | |
| } | |
| if (p < right) { | |
| quicksort_range(arr, n, p + 1, right); | |
| } | |
| } | |
| } | |
| void int_array_quicksort(int *arr, int n) | |
| /*@ With l | |
| Require 1 <= n && n <= 50000 && | |
| IntArray::full(arr, n, l) | |
| Ensure exists l1, | |
| permutation(l, l1) && | |
| increasing(l1) && | |
| IntArray::full(arr, n, l1) | |
| */ | |
| { | |
| quicksort_range(arr, n, 0, n - 1); | |
| } | |
| int discretize(const int *src, int n, int *dest_map) | |
| /*@ With src_l | |
| Require Zlength(src_l) == n && | |
| 1 <= n && n <= 50000 && | |
| IntArray::full(src, n, src_l) * | |
| IntArray::undef_full(dest_map, n) | |
| Ensure exists out_l, | |
| discretize_result(src_l, n, out_l, __return) && | |
| IntArray::full(src, n, src_l) * | |
| IntArray::full(dest_map, n, out_l) | |
| */ | |
| { | |
| /*@ Inv Assert | |
| Zlength(src_l) == n@pre && | |
| 1 <= n@pre && n@pre <= 50000 && | |
| 0 <= i && i <= n@pre && | |
| src == src@pre && dest_map == dest_map@pre && n == n@pre && | |
| IntArray::full(src@pre, n@pre, src_l) * | |
| IntArray::full(dest_map@pre, i, sublist(0, i, src_l)) * | |
| IntArray::undef_seg(dest_map@pre, i, n@pre) | |
| */ | |
| for (int i = 0; i < n; i++) { | |
| dest_map[i] = src[i]; | |
| } | |
| /*@ Assert | |
| Zlength(src_l) == n@pre && | |
| 1 <= n@pre && n@pre <= 50000 && | |
| src == src@pre && dest_map == dest_map@pre && n == n@pre && | |
| IntArray::full(src@pre, n@pre, src_l) * | |
| IntArray::full(dest_map@pre, n@pre, src_l) | |
| */ | |
| int_array_quicksort(dest_map, n); | |
| int slow = 0; | |
| /*@ Inv Assert | |
| exists sorted_l cur_l, | |
| Zlength(src_l) == n@pre && | |
| 1 <= n@pre && n@pre <= 50000 && | |
| src == src@pre && dest_map == dest_map@pre && n == n@pre && | |
| 0 <= slow && slow < fast && 1 <= fast && fast <= n@pre && | |
| dedup_scan_inv(src_l, sorted_l, cur_l, slow, fast) && | |
| IntArray::full(src@pre, n@pre, src_l) * | |
| IntArray::full(dest_map@pre, n@pre, cur_l) | |
| */ | |
| for (int fast = 1; fast < n; fast++) { | |
| if (dest_map[fast] != dest_map[slow]) { | |
| slow++; | |
| dest_map[slow] = dest_map[fast]; | |
| } | |
| } | |
| /*@ Assert | |
| exists out_l, | |
| Zlength(src_l) == n@pre && | |
| 1 <= n@pre && n@pre <= 50000 && | |
| src == src@pre && dest_map == dest_map@pre && n == n@pre && | |
| discretize_result(src_l, n@pre, out_l, slow + 1) && | |
| IntArray::full(src@pre, n@pre, src_l) * | |
| IntArray::full(dest_map@pre, n@pre, out_l) | |
| */ | |
| return slow + 1; | |
| } | |
| int query_forward(const int *map, int map_size, int target) | |
| /*@ With map_l | |
| Require Zlength(map_l) == map_size && | |
| 0 <= map_size && map_size <= 50000 && | |
| strict_increasing(map_l) && | |
| IntArray::full(map, map_size, map_l) | |
| Ensure query_forward_result(map_l, map_size, target, __return) && | |
| IntArray::full(map, map_size, map_l) | |
| */ | |
| { | |
| int low = 0; | |
| int high = map_size - 1; | |
| /*@ Inv Assert | |
| Zlength(map_l) == map_size@pre && | |
| 0 <= map_size@pre && map_size@pre <= 50000 && | |
| strict_increasing(map_l) && | |
| map == map@pre && map_size == map_size@pre && target == target@pre && | |
| 0 <= low && low <= high + 1 && high < map_size@pre && | |
| query_forward_search_inv(map_l, map_size@pre, target@pre, low, high) && | |
| IntArray::full(map@pre, map_size@pre, map_l) | |
| */ | |
| while (low <= high) { | |
| int mid = low + (high - low) / 2; | |
| /*@ Assert | |
| Zlength(map_l) == map_size@pre && | |
| 0 <= map_size@pre && map_size@pre <= 50000 && | |
| strict_increasing(map_l) && | |
| map == map@pre && map_size == map_size@pre && target == target@pre && | |
| 0 <= low && low <= mid && mid <= high && high < map_size@pre && | |
| query_forward_search_inv(map_l, map_size@pre, target@pre, low, high) && | |
| IntArray::full(map@pre, map_size@pre, map_l) | |
| */ | |
| if (map[mid] == target) { | |
| return mid; | |
| } else if (map[mid] < target) { | |
| low = mid + 1; | |
| } else { | |
| high = mid - 1; | |
| } | |
| } | |
| /*@ Assert | |
| Zlength(map_l) == map_size@pre && | |
| 0 <= map_size@pre && map_size@pre <= 50000 && | |
| strict_increasing(map_l) && | |
| map == map@pre && map_size == map_size@pre && target == target@pre && | |
| 0 <= low && low <= high + 1 && high < map_size@pre && | |
| query_forward_search_inv(map_l, map_size@pre, target@pre, low, high) && | |
| query_forward_result(map_l, map_size@pre, target@pre, -1) && | |
| IntArray::full(map@pre, map_size@pre, map_l) | |
| */ | |
| return -1; | |
| } | |