New functions

src/analysis/Extrema.lvt

@@ -0,0 +1,120 @@
+namespace MaxMin
+
+component Extrema {
+
+    public fn max(myarray: int[8]) int {
+
+        var maxValue: int = myarray[0]
+        for (var i: int = 1; i < 8; i++) {
+            if (myarray[i] > maxValue) {
+                maxValue = myarray[i]
+            }
+        }
+        return maxValue
+    }
+
+
+    public fn min(myarray: int[8]) int {
+
+        var minValue: int = myarray[0]
+        for (var i: int = 1; i < 8; i++) {
+            if (myarray[i] < minValue) {
+                minValue = myarray[i]
+            }
+        }
+        return minValue
+    }
+
+    public fn max_uint(myarray: uint[8]) uint {
+
+        var maxValue: uint = myarray[0]
+        for (var i: int = 0; i < 8; i++) {
+            if (myarray[i] > maxValue) {
+                maxValue = myarray[i]
+            }
+        }
+        return maxValue
+    }
+
+    public fn min_uint(myarray: uint[8]) uint {
+
+        var minValue: uint = myarray[0]
+        for (var i: int = 0; i < 8; i++) {
+            if (myarray[i] < minValue) {
+                minValue = myarray[i]
+            }
+        }
+        return minValue
+    }
+
+    public fn max_byte(myarray: byte[8]) byte {
+
+        var maxValue: byte = myarray[0]
+        for (var i: int = 0; i < 8; i++) {
+            if (myarray[i] > maxValue) {
+                maxValue = myarray[i]
+            }
+        }
+        return maxValue
+    }
+
+    public fn min_byte(myarray: byte[8]) byte {
+
+        var minValue: byte = myarray[0]
+        for (var i: int = 0; i < 8; i++) {
+            if (myarray[i] < minValue) {
+                minValue = myarray[i]
+            }
+        }
+        return minValue
+    }
+
+    public fn clampInt(value: int, min: int, max: int) int {
+        if (min > max) {
+            return 0 
+        }
+        if (value < min) {
+            return min
+        } if (value > max) {
+            return max
+        } else {
+            return value
+        }
+    }
+
+    public fn clampUInt(value: uint, min: uint, max: uint) uint {
+        if (min > max) {
+            return 0 
+        }
+        if (value < min) {
+            return min
+        } if (value > max) {
+            return max
+        } else {
+            return value
+        }
+    }
+
+    public fn clampByte(value: byte, min: byte, max: byte) byte {
+        if (min > max) {
+            return 0x00
+        }
+        if (value < min) {
+            return min
+        } if (value > max) {
+            return max
+        } else {
+            return value
+        }
+    }
+
+    public fn abs(value: int) int {
+        if (value < 0) {
+            return -value
+        } else {
+            return value
+        }
+    }
+
+
+}

src/arithmetic/Log.lvt

@@ -0,0 +1,43 @@
+namespace Logarithm
+
+component Log {
+
+    public fn Log2(value: int) int
+    {
+        if (value <= 0)
+        {
+            return -1
+        }
+
+        var result: int = 0
+        var tempValue: int = value
+
+        while (tempValue > 1)
+        {
+            tempValue = tempValue >> 1
+            result = result + 1
+        }
+
+        return result
+    }
+
+@SuppressWarning("variable-divisor")
+    public fn Log(value: int, base: int) int
+    {
+        if (value <= 0 || base <= 1)
+        {
+            return -1
+        }
+
+        var result: int = 0
+        var tempValue: int = value
+
+        while (tempValue >= base)
+        {
+            tempValue = tempValue / base
+            result = result + 1
+        }
+
+        return result
+    }
+}

src/bit_operations/BitManipulation.lvt

@@ -0,0 +1,94 @@
+namespace BitUtils
+
+component BitManipulation {
+
+    public fn ReverseBits(value: int, width: int) int
+    {
+        var pw: int = this.Pow2(width)
+        var result: int = 0
+        var remaining: int = value % pw
+        for (var i = 0; i < width; i++)
+        {
+            var bit: int = remaining % 2
+            var shift: int = width - 1 - i
+            var p: int = this.Pow2(shift)
+            result = result + bit * p
+            remaining = remaining / 2
+        }
+        return result
+    }
+
+     public fn Pow2(n: int) int
+    {
+        var result: int = 1
+        for (var i = 0; i < n; i++)
+        {
+            result = result * 2
+        }
+        return result
+    }
+
+
+    public fn CountLeadingZeros(value: uint) int
+    {
+        if (value == 0) {
+            return 32
+        }
+        var count: int = 0
+        if ((value & 0xFFFF0000) == 0){
+            count += 16
+            value = value << 16
+        }
+        if ((value & 0xFF000000) == 0){
+            count += 8
+           value = value << 8
+        }
+        if ((value & 0xF0000000) == 0){
+            count += 4
+            value = value << 4
+        }
+        if ((value & 0xC0000000) == 0){
+            count += 2
+            value = value << 2
+        }
+        if ((value & 0x80000000) == 0){
+            count += 1
+        }
+        return count
+    }
+
+
+    public fn PopCount(value: int) int 
+    {
+        var x: int = value >> 1
+        x = x & 0x55555555
+        var stepOne: int = value - x
+
+        var y: int = stepOne & 0x33333333
+        var z: int = stepOne >> 2
+        z = z & 0x33333333
+        var stepTwo: int = y + z
+
+        var a: int = stepTwo >> 4
+        a = stepTwo + a
+        var stepThree: int = a & 0x0F0F0F0F
+
+        var stepFour = stepThree * 0x01010101
+        return stepFour >> 24
+    }
+
+
+    public fn rotateLeft(value: int, distance: int) int
+    {
+        distance = distance & 31
+        return (value << distance) | (value >> (32 - distance))
+    }
+
+
+    public fn rotateRight(value: int, distance: int) int
+    {
+        var y: int = distance & 31
+        return (value >> distance) | (value << (32 - distance))
+    }
+}
+