mt-lang 0.2.0 → 0.2.1

data/std/binary_heap.mt

@@ -0,0 +1,157 @@
+import std.vec as vec
+
+public struct BinaryHeap[T]:
+    values: vec.Vec[T]
+
+public struct Iter[T]:
+    data: ptr[T]?
+    index: ptr_uint
+    len: ptr_uint
+
+
+extending BinaryHeap[T]:
+    public static function create() -> BinaryHeap[T]:
+        return BinaryHeap[T](values = vec.Vec[T].create())
+
+
+    public static function with_capacity(capacity: ptr_uint) -> BinaryHeap[T]:
+        var result = BinaryHeap[T].create()
+        result.reserve(capacity)
+        return result
+
+
+    static function parent_index(index: ptr_uint) -> ptr_uint:
+        return (index - 1) / 2
+
+
+    static function left_child_index(index: ptr_uint) -> ptr_uint:
+        return (index * 2) + 1
+
+
+    static function right_child_index(index: ptr_uint) -> ptr_uint:
+        return (index * 2) + 2
+
+
+    static function slot(current: ref[BinaryHeap[T]], index: ptr_uint) -> ptr[T]:
+        let value = current.values.get(index) else:
+            fatal(c"binary_heap.BinaryHeap.slot missing value")
+
+        return unsafe: ptr[T]<-value
+
+
+    static function swap(current: ref[BinaryHeap[T]], left_index: ptr_uint, right_index: ptr_uint) -> void:
+        current.values.swap(left_index, right_index)
+
+
+    static function sift_up(current: ref[BinaryHeap[T]], start_index: ptr_uint) -> void:
+        var child = start_index
+        while child != 0:
+            let parent = BinaryHeap[T].parent_index(child)
+            let child_value = BinaryHeap[T].slot(current, child)
+            let parent_value = BinaryHeap[T].slot(current, parent)
+            if order[T](child_value, parent_value) <= 0:
+                break
+
+            BinaryHeap[T].swap(current, child, parent)
+            child = parent
+
+
+    static function sift_down(current: ref[BinaryHeap[T]], start_index: ptr_uint) -> void:
+        let length = current.values.len()
+        if length <= 1:
+            return
+
+        var parent = start_index
+        while true:
+            let left = BinaryHeap[T].left_child_index(parent)
+            if left >= length:
+                break
+
+            var candidate = left
+            let right = BinaryHeap[T].right_child_index(parent)
+            if right < length:
+                let left_value = BinaryHeap[T].slot(current, left)
+                let right_value = BinaryHeap[T].slot(current, right)
+                if order[T](right_value, left_value) > 0:
+                    candidate = right
+
+            let parent_value = BinaryHeap[T].slot(current, parent)
+            let candidate_value = BinaryHeap[T].slot(current, candidate)
+            if order[T](candidate_value, parent_value) <= 0:
+                break
+
+            BinaryHeap[T].swap(current, parent, candidate)
+            parent = candidate
+
+
+    public function len() -> ptr_uint:
+        return this.values.len()
+
+
+    public function capacity() -> ptr_uint:
+        return this.values.capacity()
+
+
+    public function is_empty() -> bool:
+        return this.values.is_empty()
+
+
+    public function iter() -> Iter[T]:
+        let view = this.values.as_span()
+        return Iter[T](data = view.data, index = 0, len = view.len)
+
+
+    public function peek() -> const_ptr[T]?:
+        let current = this.values.get(0) else:
+            return null
+
+        unsafe:
+            return const_ptr_of(read(ptr[T]<-current))
+
+
+    public editable function clear() -> void:
+        this.values.clear()
+
+
+    public editable function release() -> void:
+        this.values.release()
+
+
+    public editable function reserve(min_capacity: ptr_uint) -> void:
+        this.values.reserve(min_capacity)
+
+
+    public editable function push(value: T) -> void:
+        this.values.push(value)
+        BinaryHeap[T].sift_up(this, this.values.len() - 1)
+
+
+    public editable function pop() -> Option[T]:
+        let removed = this.values.swap_remove(0)
+        match removed:
+            Option.none:
+                return Option[T].none
+            Option.some as payload:
+                if not this.values.is_empty():
+                    BinaryHeap[T].sift_down(this, 0)
+                return Option[T].some(value = payload.value)
+
+
+extending Iter[T]:
+    public function iter() -> Iter[T]:
+        return this
+
+
+    public editable function next() -> const_ptr[T]?:
+        if this.index >= this.len:
+            return null
+
+        let data = this.data else:
+            fatal(c"binary_heap.Iter.next missing storage")
+
+        let current_index = this.index
+        this.index += 1
+
+        unsafe:
+            let current = ptr[T]<-data + current_index
+            return const_ptr_of(read(current))

data/std/bitset.mt

@@ -0,0 +1,239 @@
+import std.mem.heap as heap
+
+public struct Bitset:
+    words: ptr[ptr_uint]?
+    word_count: ptr_uint
+    bit_count: ptr_uint
+
+const WORD_BITS: ptr_uint = 8 * size_of(ptr_uint)
+
+
+function word_index(bit_index: ptr_uint) -> ptr_uint:
+    return bit_index / WORD_BITS
+
+
+function bit_offset(bit_index: ptr_uint) -> ptr_uint:
+    return bit_index % WORD_BITS
+
+
+function popcount_word(word: ptr_uint) -> ptr_uint:
+    var count: ptr_uint = 0
+    var value = word
+    while value != 0:
+        count += 1
+        value = value & value - 1
+    return count
+
+
+function find_first_set_in_word(word: ptr_uint) -> Option[ptr_uint]:
+    if word == 0:
+        return Option[ptr_uint].none
+    var index: ptr_uint = 0
+    var value = word
+    while (value & ptr_uint<-1) == 0:
+        value = value >> ptr_uint<-1
+        index += 1
+    return Option[ptr_uint].some(value = index)
+
+
+public function create() -> Bitset:
+    return Bitset(words = null, word_count = 0, bit_count = 0)
+
+
+public function with_capacity(min_bits: ptr_uint) -> Bitset:
+    var result = create()
+    result.reserve(min_bits)
+    return result
+
+
+extending Bitset:
+    public function len() -> ptr_uint:
+        return this.bit_count
+
+
+    public function is_empty() -> bool:
+        return this.bit_count == 0
+
+
+    public editable function set(index: ptr_uint) -> void:
+        let wi = word_index(index)
+        if wi >= this.word_count:
+            this.reserve(index + 1)
+        let words = this.words else:
+            fatal(c"bitset.set missing storage")
+        let bit = bit_offset(index)
+        unsafe:
+            let word_ptr = words + wi
+            read(word_ptr) = read(word_ptr) | ptr_uint<-1 << bit
+
+
+    public editable function clear(index: ptr_uint) -> void:
+        let wi = word_index(index)
+        if wi >= this.word_count:
+            return
+        let words = this.words else:
+            return
+        let bit = bit_offset(index)
+        unsafe:
+            let word_ptr = words + wi
+            read(word_ptr) = read(word_ptr) & ~(ptr_uint<-1 << bit)
+
+
+    public function test(index: ptr_uint) -> bool:
+        let wi = word_index(index)
+        if wi >= this.word_count:
+            return false
+        let words = this.words else:
+            return false
+        let bit = bit_offset(index)
+        unsafe:
+            let word_ptr = words + wi
+            return (read(word_ptr) >> bit & ptr_uint<-1) != 0
+
+
+    public editable function toggle(index: ptr_uint) -> void:
+        let wi = word_index(index)
+        if wi >= this.word_count:
+            this.reserve(index + 1)
+        let words = this.words else:
+            fatal(c"bitset.toggle missing storage")
+        let bit = bit_offset(index)
+        unsafe:
+            let word_ptr = words + wi
+            read(word_ptr) = read(word_ptr) ^ ptr_uint<-1 << bit
+
+
+    public function count() -> ptr_uint:
+        if this.words == null:
+            return 0
+        var total: ptr_uint = 0
+        unsafe:
+            var wi: ptr_uint = 0
+            while wi < this.word_count:
+                let w = read(ptr[ptr_uint]<-this.words + wi)
+                total += popcount_word(w)
+                wi += 1
+        return total
+
+
+    public function any() -> bool:
+        if this.words == null:
+            return false
+        unsafe:
+            var wi: ptr_uint = 0
+            while wi < this.word_count:
+                let w = read(ptr[ptr_uint]<-this.words + wi)
+                if w != 0:
+                    return true
+                wi += 1
+        return false
+
+
+    public function all() -> bool:
+        if this.bit_count == 0:
+            return false
+        if this.words == null:
+            return false
+        let full_words = this.word_count - 1
+        let remaining_bits = this.bit_count - full_words * WORD_BITS
+        unsafe:
+            var wi: ptr_uint = 0
+            while wi < full_words:
+                let w = read(ptr[ptr_uint]<-this.words + wi)
+                if w != ~ptr_uint<-0:
+                    return false
+                wi += 1
+            if remaining_bits > 0:
+                let last = read(ptr[ptr_uint]<-this.words + full_words)
+                let mask = (ptr_uint<-1 << remaining_bits) - ptr_uint<-1
+                if last != mask:
+                    return false
+        return true
+
+
+    public function none() -> bool:
+        return not this.any()
+
+
+    public function find_first_set() -> Option[ptr_uint]:
+        if this.words == null:
+            return Option[ptr_uint].none
+        unsafe:
+            var wi: ptr_uint = 0
+            while wi < this.word_count:
+                let w = read(ptr[ptr_uint]<-this.words + wi)
+                let found = find_first_set_in_word(w)
+                match found:
+                    Option.some as payload:
+                        return Option[ptr_uint].some(value = wi * WORD_BITS + payload.value)
+                    Option.none:
+                        pass
+                wi += 1
+        return Option[ptr_uint].none
+
+
+    public function find_first_clear() -> Option[ptr_uint]:
+        if this.bit_count == 0:
+            return Option[ptr_uint].some(value = 0)
+        if this.words == null:
+            return Option[ptr_uint].some(value = 0)
+        let full_words = this.word_count - 1
+        let remaining_bits = this.bit_count - full_words * WORD_BITS
+        unsafe:
+            var wi: ptr_uint = 0
+            while wi < full_words:
+                let w = read(ptr[ptr_uint]<-this.words + wi)
+                if w != ~ptr_uint<-0:
+                    let inverted = ~w
+                    let found = find_first_set_in_word(inverted)
+                    match found:
+                        Option.some as payload:
+                            return Option[ptr_uint].some(value = wi * WORD_BITS + payload.value)
+                        Option.none:
+                            pass
+                wi += 1
+            if remaining_bits > 0:
+                let last = read(ptr[ptr_uint]<-this.words + full_words)
+                let mask = (ptr_uint<-1 << remaining_bits) - ptr_uint<-1
+                if last != mask:
+                    let inverted = ~last & mask
+                    let found = find_first_set_in_word(inverted)
+                    match found:
+                        Option.some as payload:
+                            return Option[ptr_uint].some(value = full_words * WORD_BITS + payload.value)
+                        Option.none:
+                            pass
+        return Option[ptr_uint].some(value = this.bit_count)
+
+
+    public editable function clear_all() -> void:
+        if this.words == null:
+            return
+        unsafe:
+            var wi: ptr_uint = 0
+            while wi < this.word_count:
+                read(ptr[ptr_uint]<-this.words + wi) = 0
+                wi += 1
+
+
+    public editable function reserve(min_bits: ptr_uint) -> void:
+        if min_bits <= this.bit_count:
+            return
+        let new_word_count = word_index(min_bits + WORD_BITS - 1)
+        let resized = heap.resize[ptr_uint](this.words, new_word_count) else:
+            fatal(c"bitset.reserve out of memory")
+        this.words = resized
+        unsafe:
+            var wi = this.word_count
+            while wi < new_word_count:
+                read(ptr[ptr_uint]<-this.words + wi) = 0
+                wi += 1
+        this.word_count = new_word_count
+        this.bit_count = new_word_count * WORD_BITS
+
+
+    public editable function release() -> void:
+        heap.release(this.words)
+        this.words = null
+        this.word_count = 0
+        this.bit_count = 0