Add a sample of maths basic algorithms

Author: dlesnoff

maths/abs.nim

@@ -0,0 +1,87 @@
+## Absolute value
+{.push raises: [].}
+import std/algorithm
+
+runnableExamples:
+  doAssert absVal(-5.1) == 5.1
+  doAssert absMin(@[-1, 2, -3]) == 1
+  doAssert absMax(@[-1, 2, -3]) == 3
+  doAssert absMaxSort(@[3, -10, -2]) == -10
+
+func absVal(num: float): float =
+  ## Returns the absolute value of a number.
+  return if num < 0.0: -num else: num
+
+# Same for integers but return a Natural
+func absVal(num: int): Natural = (if num < 0: -num else: num)
+
+func absMin(x: seq[int]): Natural {.raises: [ValueError].} =
+  ## Returns the smallest element in absolute value in a sequence.
+  if x.len == 0:
+    raise newException(ValueError, "Cannot find absolute minimum of an empty sequence")
+  result = absVal(x[0])
+  for i in 1 ..< x.len:
+    if absVal(x[i]) < result:
+      result = absVal(x[i])
+
+func absMax(x: seq[int]): Natural {.raises: [ValueError].} =
+  ## Returns the largest element in absolute value in a sequence.
+  if x.len == 0:
+    raise newException(ValueError, "Cannot find absolute maximum of an empty sequence")
+  result = absVal(x[0])
+  for i in 1 ..< x.len:
+    if absVal(x[i]) > result:
+      result = absVal(x[i])
+
+func absMaxSort(x: seq[int]): int {.raises: [ValueError].} =
+  ## Returns the signed element whose absolute value is the largest in a sequence.
+  var x: seq[int] = x
+  if x.len == 0:
+    raise newException(ValueError, "Cannot find absolute maximum of an empty sequence")
+  sort(x, proc (a, b: int): int = int(absVal(b)) - int(absVal(a)))
+  return x[0]
+
+when isMainModule:
+  import std/[unittest, random]
+  randomize()
+
+  suite "Check `absVal`":
+    test "Check `absVal`":
+      check:
+        absVal(11.2) == 11.2
+        absVal(5) == 5
+        absVal(-5.1) == 5.1
+        absVal(-5) == abs_val(5)
+        absVal(0) == 0
+
+  suite "Check `absMin`":
+    test "Check `absMin`":
+      check:
+        absMin(@[-1, 2, -3]) == 1
+        absMin(@[0, 5, 1, 11]) == 0
+        absMin(@[3, -10, -2]) == 2
+    
+    test "`absMin` on empty sequence raises ValueError":
+      doAssertRaises(ValueError):
+        discard absMin(@[])
+  
+  suite "Check `absMax`":
+    test "Check `absMax`":
+      check:
+        absMax(@[0, 5, 1, 11]) == 11
+        absMax(@[3, -10, -2]) == 10
+        absMax(@[-1, 2, -3]) == 3
+    
+    test "`absMax` on empty sequence raises ValueError":
+      doAssertRaises(ValueError):
+        discard absMax(@[])
+  
+  suite "Check `absMaxSort`":
+    test "Check `absMaxSort`":
+      check:
+        absMaxSort(@[3, -2, 1, -4, 5, -6]) == -6
+        absMaxSort(@[0, 5, 1, 11]) == 11
+    
+    test "`absMaxSort` on empty sequence raises ValueError":
+      doAssertRaises(ValueError):
+        discard absMaxSort(@[])

maths/addition_without_arithmetic.nim

@@ -0,0 +1,36 @@
+## Illustrate how to add the integer without arithmetic operation
+runnableExamples:
+  import std/strformat
+  var
+    a = 5
+    b = 6
+  echo fmt"The sum of {a} and {b} is {add(a,b)}"
+
+func add(first: int, second: int): int =
+  ## Implementation of addition of integer with `and`, `xor` and `shl`
+  ## boolean operators.
+  var first = first
+  var second = second
+  while second != 0:
+    var c = first and second
+    first = first xor second
+    second = c shl 1
+  return first
+
+when isMainModule:
+  import std/unittest
+
+  suite "Check addition":
+    test "Addition of two positive numbers":
+      check:
+        add(3, 5) == 8
+        add(13, 5) == 18
+    test "Addition of two negative numbers":
+      check:
+        add(-7, -2) == -9
+        add(-321, -0) == -321
+    test "Addition of one positive and one negative number":
+      check:
+        add(-7, 2) == -5
+        add(-13, 5) == -8
+        add(13, -5) == 8

maths/aliquot_sum.nim

@@ -0,0 +1,31 @@
+{.push raises: [].}
+
+runnableExamples:
+  import std/strformat
+  for number in [12, 100]:
+    echo fmt"The sum of all the proper divisors of {number} is {aliquotSum(number)}"
+
+func aliquotSum(number: Natural): Natural {.raises: [ValueError].} =
+  ## Returns the sum of all the proper divisors of the number
+  ## Example: aliquotSum(12) = 1 + 2 + 3 + 4 + 6 = 16
+  if number == 0:
+    raise newException(ValueError, "Input number must be strictly positive")
+  result = 0
+  for divisor in 1 .. (number div 2) :
+    if number mod divisor == 0:
+      result += divisor
+
+when isMainModule:
+  import std/unittest
+  suite "Check `aliquotSum`":
+    test "`aliquotSum` on small values":
+      var
+        input = @[1, 2, 9, 12, 27, 100]
+        expected = @[0, 1, 4, 16, 13, 117]
+      for i in 0 ..< input.len:
+        check:
+          aliquotSum(input[i]) == expected[i]
+  
+    test "`aliquotSum` raises ValueError on non-positive entries":
+      doAssertRaises(ValueError):
+        discard aliquotSum(0)

maths/allocation_number.nim

@@ -0,0 +1,52 @@
+## In a multi-threaded download, this algorithmm could be used to provide
+## each worker thread with a block of non-overlapping bytes to download.
+
+runnableExamples:
+  let numBytes = 100
+  let numPartitions = 5
+  let allocations = allocationNum(numBytes, numPartitions)
+  doAssert allocations == @[
+    0 .. 19,
+    20 .. 39,
+    40 .. 59,
+    60 .. 79,
+    80 .. 100
+  ]
+  
+func allocationNum(numBytes: Natural, numPartitions: Natural): seq[Slice[Natural]] =
+  ## Divide `numBytes` bytes into `numPartitions` non-overlapping partitions.
+  if numPartitions <= 0:
+    raise newException(ValueError, "numPartitions must be > 0")
+  if numPartitions > numBytes:
+    raise newException(ValueError, "numPartitions must be <= numBytes")
+  var
+    bytesPerPartition = numBytes div numPartitions
+    allocation_list: seq[Slice[Natural]] = @[]
+  for i in Natural(0) ..< numPartitions:
+    if i == numPartitions-1:
+      allocation_list.add(Natural(i*bytesPerPartition) .. numBytes)
+    else:
+      allocation_list.add(Natural(i*bytesPerPartition) .. Natural((i+1)*bytesPerPartition-1))
+  return allocation_list
+
+when isMainModule:
+  import std/unittest
+
+  suite "Test `allocationNum`":
+    test "Test `allocationNum`":
+      let allocations: seq[Slice[Natural]] = allocationNum(100, 5)
+      check allocations == @[
+        Natural(0) .. 19,
+        Natural(20) .. 39,
+        Natural(40) .. 59,
+        Natural(60) .. 79,
+        Natural(80) .. 100
+      ]
+    
+    test "`allocationNum` on 0 partitions":
+      doAssertRaises(ValueError): discard allocationNum(5, 0)
+    
+    test "`allocationNum` on more partitions than bytes":
+      doAssertRaises(ValueError): discard allocationNum(0, 5)
+  
+  echo allocationNum(0, 5)