diff options
| -rw-r--r-- | lib/pure/algorithm.nim | 89 | ||||
| -rw-r--r-- | lib/pure/complex.nim | 42 | ||||
| -rw-r--r-- | lib/pure/fenv.nim | 42 | ||||
| -rw-r--r-- | lib/pure/math.nim | 60 | ||||
| -rw-r--r-- | lib/pure/random.nim | 34 | ||||
| -rw-r--r-- | lib/pure/rationals.nim | 95 |
6 files changed, 189 insertions, 173 deletions
diff --git a/lib/pure/algorithm.nim b/lib/pure/algorithm.nim index 002cb3a7a..5d157dfc8 100644 --- a/lib/pure/algorithm.nim +++ b/lib/pure/algorithm.nim @@ -172,8 +172,8 @@ proc binarySearch*[T, K](a: openArray[T], key: K, ## ``cmp`` is the comparator function to use, the expected return values are ## the same as that of system.cmp. runnableExamples: - assert binarySearch(["a","b","c","d"], "d", system.cmp[string]) == 3 - assert binarySearch(["a","b","d","c"], "d", system.cmp[string]) == 2 + assert binarySearch(["a", "b", "c", "d"], "d", system.cmp[string]) == 3 + assert binarySearch(["a", "b", "d", "c"], "d", system.cmp[string]) == 2 if a.len == 0: return -1 @@ -228,7 +228,8 @@ proc smartBinarySearch*[T](a: openArray[T], key: T): int {.deprecated: const onlySafeCode = true -proc lowerBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.closure.}): int = +proc lowerBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {. + closure.}): int = ## Returns a position to the first element in the ``a`` that is greater than ## ``key``, or last if no such element is found. ## In other words if you have a sorted sequence and you call @@ -244,12 +245,12 @@ proc lowerBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.clo ## * `upperBound proc<#upperBound,openArray[T],K,proc(T,K)>`_ sorted by ``cmp`` in the specified order ## * `upperBound proc<#upperBound,openArray[T],T>`_ runnableExamples: - var arr = @[1,2,3,5,6,7,8,9] + var arr = @[1, 2, 3, 5, 6, 7, 8, 9] assert arr.lowerBound(3, system.cmp[int]) == 2 assert arr.lowerBound(4, system.cmp[int]) == 3 assert arr.lowerBound(5, system.cmp[int]) == 3 arr.insert(4, arr.lowerBound(4, system.cmp[int])) - assert arr == [1,2,3,4,5,6,7,8,9] + assert arr == [1, 2, 3, 4, 5, 6, 7, 8, 9] result = a.low var count = a.high - a.low + 1 var step, pos: int @@ -275,7 +276,8 @@ proc lowerBound*[T](a: openArray[T], key: T): int = lowerBound(a, key, cmp[T]) ## * `upperBound proc<#upperBound,openArray[T],K,proc(T,K)>`_ sorted by ``cmp`` in the specified order ## * `upperBound proc<#upperBound,openArray[T],T>`_ -proc upperBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.closure.}): int = +proc upperBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {. + closure.}): int = ## Returns a position to the first element in the ``a`` that is not less ## (i.e. greater or equal to) than ``key``, or last if no such element is found. ## In other words if you have a sorted sequence and you call @@ -291,12 +293,12 @@ proc upperBound*[T, K](a: openArray[T], key: K, cmp: proc(x: T, k: K): int {.clo ## * `lowerBound proc<#lowerBound,openArray[T],K,proc(T,K)>`_ sorted by ``cmp`` in the specified order ## * `lowerBound proc<#lowerBound,openArray[T],T>`_ runnableExamples: - var arr = @[1,2,3,5,6,7,8,9] + var arr = @[1, 2, 3, 5, 6, 7, 8, 9] assert arr.upperBound(2, system.cmp[int]) == 2 assert arr.upperBound(3, system.cmp[int]) == 3 assert arr.upperBound(4, system.cmp[int]) == 3 arr.insert(4, arr.upperBound(3, system.cmp[int])) - assert arr == [1,2,3,4,5,6,7,8,9] + assert arr == [1, 2, 3, 4, 5, 6, 7, 8, 9] result = a.low var count = a.high - a.low + 1 var step, pos: int @@ -422,7 +424,8 @@ func sort*[T](a: var openArray[T], dec(m, s*2) s = s*2 -proc sort*[T](a: var openArray[T], order = SortOrder.Ascending) = sort[T](a, system.cmp[T], order) +proc sort*[T](a: var openArray[T], order = SortOrder.Ascending) = sort[T](a, + system.cmp[T], order) ## Shortcut version of ``sort`` that uses ``system.cmp[T]`` as the comparison function. ## ## **See also:** @@ -492,11 +495,13 @@ template sortedByIt*(seq1, op: untyped): untyped = p2: Person = (name: "p2", age: 20) p3: Person = (name: "p3", age: 30) p4: Person = (name: "p4", age: 30) - people = @[p1,p2,p4,p3] + people = @[p1, p2, p4, p3] - assert people.sortedByIt(it.name) == @[(name: "p1", age: 60), (name: "p2", age: 20), (name: "p3", age: 30), (name: "p4", age: 30)] + assert people.sortedByIt(it.name) == @[(name: "p1", age: 60), (name: "p2", + age: 20), (name: "p3", age: 30), (name: "p4", age: 30)] # Nested sort - assert people.sortedByIt((it.age, it.name)) == @[(name: "p2", age: 20), (name: "p3", age: 30), (name: "p4", age: 30), (name: "p1", age: 60)] + assert people.sortedByIt((it.age, it.name)) == @[(name: "p2", age: 20), + (name: "p3", age: 30), (name: "p4", age: 30), (name: "p1", age: 60)] var result = sorted(seq1, proc(x, y: type(seq1[0])): int = var it {.inject.} = x let a = op @@ -529,7 +534,7 @@ func isSorted*[T](a: openArray[T], assert isSorted(e) == false result = true for i in 0..<len(a)-1: - if cmp(a[i],a[i+1]) * order > 0: + if cmp(a[i], a[i+1]) * order > 0: return false proc isSorted*[T](a: openArray[T], order = SortOrder.Ascending): bool = @@ -665,19 +670,19 @@ proc prevPermutation*[T](x: var openArray[T]): bool {.discardable.} = when isMainModule: # Tests for lowerBound - var arr = @[1,2,3,5,6,7,8,9] + var arr = @[1, 2, 3, 5, 6, 7, 8, 9] assert arr.lowerBound(0) == 0 assert arr.lowerBound(4) == 3 assert arr.lowerBound(5) == 3 assert arr.lowerBound(10) == 8 - arr = @[1,5,10] + arr = @[1, 5, 10] assert arr.lowerBound(4) == 1 assert arr.lowerBound(5) == 1 assert arr.lowerBound(6) == 2 # Tests for isSorted - var srt1 = [1,2,3,4,4,4,4,5] - var srt2 = ["iello","hello"] - var srt3 = [1.0,1.0,1.0] + var srt1 = [1, 2, 3, 4, 4, 4, 4, 5] + var srt2 = ["iello", "hello"] + var srt3 = [1.0, 1.0, 1.0] var srt4: seq[int] assert srt1.isSorted(cmp) == true assert srt2.isSorted(cmp) == false @@ -686,8 +691,8 @@ when isMainModule: var srtseq = newSeq[int]() assert srtseq.isSorted(cmp) == true # Tests for reversed - var arr1 = @[0,1,2,3,4] - assert arr1.reversed() == @[4,3,2,1,0] + var arr1 = @[0, 1, 2, 3, 4] + assert arr1.reversed() == @[4, 3, 2, 1, 0] for i in 0 .. high(arr1): assert arr1.reversed(0, i) == arr1.reversed()[high(arr1) - i .. high(arr1)] assert arr1.reversed(i, high(arr1)) == arr1.reversed()[0 .. high(arr1) - i] @@ -745,7 +750,8 @@ proc rotatedInternal[T](arg: openArray[T]; first, middle, last: int): seq[T] = for i in last ..< arg.len: result[i] = arg[i] -proc rotateLeft*[T](arg: var openArray[T]; slice: HSlice[int, int]; dist: int): int {.discardable.} = +proc rotateLeft*[T](arg: var openArray[T]; slice: HSlice[int, int]; + dist: int): int {.discardable.} = ## Performs a left rotation on a range of elements. If you want to rotate ## right, use a negative ``dist``. Specifically, ``rotateLeft`` rotates ## the elements at ``slice`` by ``dist`` positions. @@ -801,7 +807,8 @@ proc rotateLeft*[T](arg: var openArray[T]; dist: int): int {.discardable.} = let distLeft = ((dist mod arglen) + arglen) mod arglen arg.rotateInternal(0, distLeft, arglen) -proc rotatedLeft*[T](arg: openArray[T]; slice: HSlice[int, int], dist: int): seq[T] = +proc rotatedLeft*[T](arg: openArray[T]; slice: HSlice[int, int], + dist: int): seq[T] = ## Same as ``rotateLeft``, just with the difference that it does ## not modify the argument. It creates a new ``seq`` instead. ## @@ -858,7 +865,7 @@ when isMainModule: doAssert list == expected doAssert list2 == @expected - var s0,s1,s2,s3,s4,s5 = "xxxabcdefgxxx" + var s0, s1, s2, s3, s4, s5 = "xxxabcdefgxxx" doAssert s0.rotateLeft(3 ..< 10, 3) == 7 doAssert s0 == "xxxdefgabcxxx" @@ -876,20 +883,22 @@ when isMainModule: block product: doAssert product(newSeq[seq[int]]()) == newSeq[seq[int]](), "empty input" doAssert product(@[newSeq[int](), @[], @[]]) == newSeq[seq[int]](), "bit more empty input" - doAssert product(@[@[1,2]]) == @[@[1,2]], "a simple case of one element" - doAssert product(@[@[1,2], @[3,4]]) == @[@[2,4],@[1,4],@[2,3],@[1,3]], "two elements" - doAssert product(@[@[1,2], @[3,4], @[5,6]]) == @[@[2,4,6],@[1,4,6],@[2,3,6],@[1,3,6], @[2,4,5],@[1,4,5],@[2,3,5],@[1,3,5]], "three elements" - doAssert product(@[@[1,2], @[]]) == newSeq[seq[int]](), "two elements, but one empty" + doAssert product(@[@[1, 2]]) == @[@[1, 2]], "a simple case of one element" + doAssert product(@[@[1, 2], @[3, 4]]) == @[@[2, 4], @[1, 4], @[2, 3], @[1, + 3]], "two elements" + doAssert product(@[@[1, 2], @[3, 4], @[5, 6]]) == @[@[2, 4, 6], @[1, 4, 6], + @[2, 3, 6], @[1, 3, 6], @[2, 4, 5], @[1, 4, 5], @[2, 3, 5], @[1, 3, 5]], "three elements" + doAssert product(@[@[1, 2], @[]]) == newSeq[seq[int]](), "two elements, but one empty" block lowerBound: - doAssert lowerBound([1,2,4], 3, system.cmp[int]) == 2 - doAssert lowerBound([1,2,2,3], 4, system.cmp[int]) == 4 - doAssert lowerBound([1,2,3,10], 11) == 4 + doAssert lowerBound([1, 2, 4], 3, system.cmp[int]) == 2 + doAssert lowerBound([1, 2, 2, 3], 4, system.cmp[int]) == 4 + doAssert lowerBound([1, 2, 3, 10], 11) == 4 block upperBound: - doAssert upperBound([1,2,4], 3, system.cmp[int]) == 2 - doAssert upperBound([1,2,2,3], 3, system.cmp[int]) == 4 - doAssert upperBound([1,2,3,5], 3) == 3 + doAssert upperBound([1, 2, 4], 3, system.cmp[int]) == 2 + doAssert upperBound([1, 2, 2, 3], 3, system.cmp[int]) == 4 + doAssert upperBound([1, 2, 3, 5], 3) == 3 block fillEmptySeq: var s = newSeq[int]() @@ -901,16 +910,16 @@ when isMainModule: let oneData = @[1] doAssert binarySearch(oneData, 1) == 0 doAssert binarySearch(onedata, 7) == -1 - let someData = @[1,3,4,7] + let someData = @[1, 3, 4, 7] doAssert binarySearch(someData, 1) == 0 doAssert binarySearch(somedata, 7) == 3 doAssert binarySearch(someData, -1) == -1 doAssert binarySearch(someData, 5) == -1 doAssert binarySearch(someData, 13) == -1 - let moreData = @[1,3,5,7,4711] + let moreData = @[1, 3, 5, 7, 4711] doAssert binarySearch(moreData, -1) == -1 - doAssert binarySearch(moreData, 1) == 0 - doAssert binarySearch(moreData, 5) == 2 - doAssert binarySearch(moreData, 6) == -1 - doAssert binarySearch(moreData, 4711) == 4 - doAssert binarySearch(moreData, 4712) == -1 + doAssert binarySearch(moreData, 1) == 0 + doAssert binarySearch(moreData, 5) == 2 + doAssert binarySearch(moreData, 6) == -1 + doAssert binarySearch(moreData, 4711) == 4 + doAssert binarySearch(moreData, 4712) == -1 diff --git a/lib/pure/complex.nim b/lib/pure/complex.nim index 7c669cd6d..6a5e0465e 100644 --- a/lib/pure/complex.nim +++ b/lib/pure/complex.nim @@ -62,12 +62,12 @@ proc `==` *[T](x, y: Complex[T]): bool = ## Compare two complex numbers ``x`` and ``y`` for equality. result = x.re == y.re and x.im == y.im -proc `+` *[T](x: T, y: Complex[T]): Complex[T] = +proc `+` *[T](x: T; y: Complex[T]): Complex[T] = ## Add a real number to a complex number. result.re = x + y.re result.im = y.im -proc `+` *[T](x: Complex[T], y: T): Complex[T] = +proc `+` *[T](x: Complex[T]; y: T): Complex[T] = ## Add a complex number to a real number. result.re = x.re + y result.im = x.im @@ -82,11 +82,11 @@ proc `-` *[T](z: Complex[T]): Complex[T] = result.re = -z.re result.im = -z.im -proc `-` *[T](x: T, y: Complex[T]): Complex[T] = +proc `-` *[T](x: T; y: Complex[T]): Complex[T] = ## Subtract a complex number from a real number. x + (-y) -proc `-` *[T](x: Complex[T], y: T): Complex[T] = +proc `-` *[T](x: Complex[T]; y: T): Complex[T] = ## Subtract a real number from a complex number. result.re = x.re - y result.im = x.im @@ -96,12 +96,12 @@ proc `-` *[T](x, y: Complex[T]): Complex[T] = result.re = x.re - y.re result.im = x.im - y.im -proc `/` *[T](x: Complex[T], y: T): Complex[T] = +proc `/` *[T](x: Complex[T]; y: T): Complex[T] = ## Divide complex number ``x`` by real number ``y``. result.re = x.re / y result.im = x.im / y -proc `/` *[T](x: T, y: Complex[T]): Complex[T] = +proc `/` *[T](x: T; y: Complex[T]): Complex[T] = ## Divide real number ``x`` by complex number ``y``. result = x * inv(y) @@ -119,12 +119,12 @@ proc `/` *[T](x, y: Complex[T]): Complex[T] = result.re = (x.re + r * x.im) / den result.im = (x.im - r * x.re) / den -proc `*` *[T](x: T, y: Complex[T]): Complex[T] = +proc `*` *[T](x: T; y: Complex[T]): Complex[T] = ## Multiply a real number and a complex number. result.re = x * y.re result.im = x * y.im -proc `*` *[T](x: Complex[T], y: T): Complex[T] = +proc `*` *[T](x: Complex[T]; y: T): Complex[T] = ## Multiply a complex number with a real number. result.re = x.re * y result.im = x.im * y @@ -135,23 +135,23 @@ proc `*` *[T](x, y: Complex[T]): Complex[T] = result.im = x.im * y.re + x.re * y.im -proc `+=` *[T](x: var Complex[T], y: Complex[T]) = +proc `+=` *[T](x: var Complex[T]; y: Complex[T]) = ## Add ``y`` to ``x``. x.re += y.re x.im += y.im -proc `-=` *[T](x: var Complex[T], y: Complex[T]) = +proc `-=` *[T](x: var Complex[T]; y: Complex[T]) = ## Subtract ``y`` from ``x``. x.re -= y.re x.im -= y.im -proc `*=` *[T](x: var Complex[T], y: Complex[T]) = +proc `*=` *[T](x: var Complex[T]; y: Complex[T]) = ## Multiply ``y`` to ``x``. let im = x.im * y.re + x.re * y.im x.re = x.re * y.re - x.im * y.im x.im = im -proc `/=` *[T](x: var Complex[T], y: Complex[T]) = +proc `/=` *[T](x: var Complex[T]; y: Complex[T]) = ## Divide ``x`` by ``y`` in place. x = x / y @@ -222,7 +222,7 @@ proc pow*[T](x, y: Complex[T]): Complex[T] = result.re = s * cos(r) result.im = s * sin(r) -proc pow*[T](x: Complex[T], y: T): Complex[T] = +proc pow*[T](x: Complex[T]; y: T): Complex[T] = ## Complex number ``x`` raised to the power ``y``. pow(x, complex[T](y)) @@ -352,18 +352,18 @@ when isMainModule: proc `=~`[T](x, y: Complex[T]): bool = result = abs(x.re-y.re) < 1e-6 and abs(x.im-y.im) < 1e-6 - proc `=~`[T](x: Complex[T], y: T): bool = + proc `=~`[T](x: Complex[T]; y: T): bool = result = abs(x.re-y) < 1e-6 and abs(x.im) < 1e-6 var - z: Complex64 = complex(0.0, 0.0) - oo: Complex64 = complex(1.0, 1.0) - a: Complex64 = complex(1.0, 2.0) - b: Complex64 = complex(-1.0, -2.0) - m1: Complex64 = complex(-1.0, 0.0) - i: Complex64 = complex(0.0, 1.0) + z: Complex64 = complex(0.0, 0.0) + oo: Complex64 = complex(1.0, 1.0) + a: Complex64 = complex(1.0, 2.0) + b: Complex64 = complex(-1.0, -2.0) + m1: Complex64 = complex(-1.0, 0.0) + i: Complex64 = complex(0.0, 1.0) one: Complex64 = complex(1.0, 0.0) - tt: Complex64 = complex(10.0, 20.0) + tt: Complex64 = complex(10.0, 20.0) ipi: Complex64 = complex(0.0, -PI) doAssert(a/2.0 =~ complex(0.5, 1.0)) diff --git a/lib/pure/fenv.nim b/lib/pure/fenv.nim index 6a6d05f2b..6da6aedad 100644 --- a/lib/pure/fenv.nim +++ b/lib/pure/fenv.nim @@ -10,7 +10,7 @@ ## Floating-point environment. Handling of floating-point rounding and ## exceptions (overflow, division by zero, etc.). -{.deadCodeElim: on.} # dce option deprecated +{.deadCodeElim: on.} # dce option deprecated when defined(Posix) and not defined(genode): {.passl: "-lm".} @@ -103,26 +103,26 @@ proc feupdateenv*(envp: ptr Tfenv): cint {.importc, header: "<fenv.h>".} ## according to saved exceptions. const - FLT_RADIX = 2 ## the radix of the exponent representation - - FLT_MANT_DIG = 24 ## the number of base FLT_RADIX digits in the mantissa part of a float - FLT_DIG = 6 ## the number of digits of precision of a float - FLT_MIN_EXP = -125 # the minimum value of base FLT_RADIX in the exponent part of a float - FLT_MAX_EXP = 128 # the maximum value of base FLT_RADIX in the exponent part of a float - FLT_MIN_10_EXP = -37 ## the minimum value in base 10 of the exponent part of a float - FLT_MAX_10_EXP = 38 ## the maximum value in base 10 of the exponent part of a float - FLT_MIN = 1.17549435e-38'f32 ## the minimum value of a float - FLT_MAX = 3.40282347e+38'f32 ## the maximum value of a float - FLT_EPSILON = 1.19209290e-07'f32 ## the difference between 1 and the least value greater than 1 of a float - - DBL_MANT_DIG = 53 ## the number of base FLT_RADIX digits in the mantissa part of a double - DBL_DIG = 15 ## the number of digits of precision of a double - DBL_MIN_EXP = -1021 ## the minimum value of base FLT_RADIX in the exponent part of a double - DBL_MAX_EXP = 1024 ## the maximum value of base FLT_RADIX in the exponent part of a double - DBL_MIN_10_EXP = -307 ## the minimum value in base 10 of the exponent part of a double - DBL_MAX_10_EXP = 308 ## the maximum value in base 10 of the exponent part of a double - DBL_MIN = 2.2250738585072014E-308 ## the minimal value of a double - DBL_MAX = 1.7976931348623157E+308 ## the minimal value of a double + FLT_RADIX = 2 ## the radix of the exponent representation + + FLT_MANT_DIG = 24 ## the number of base FLT_RADIX digits in the mantissa part of a float + FLT_DIG = 6 ## the number of digits of precision of a float + FLT_MIN_EXP = -125 ## the minimum value of base FLT_RADIX in the exponent part of a float + FLT_MAX_EXP = 128 ## the maximum value of base FLT_RADIX in the exponent part of a float + FLT_MIN_10_EXP = -37 ## the minimum value in base 10 of the exponent part of a float + FLT_MAX_10_EXP = 38 ## the maximum value in base 10 of the exponent part of a float + FLT_MIN = 1.17549435e-38'f32 ## the minimum value of a float + FLT_MAX = 3.40282347e+38'f32 ## the maximum value of a float + FLT_EPSILON = 1.19209290e-07'f32 ## the difference between 1 and the least value greater than 1 of a float + + DBL_MANT_DIG = 53 ## the number of base FLT_RADIX digits in the mantissa part of a double + DBL_DIG = 15 ## the number of digits of precision of a double + DBL_MIN_EXP = -1021 ## the minimum value of base FLT_RADIX in the exponent part of a double + DBL_MAX_EXP = 1024 ## the maximum value of base FLT_RADIX in the exponent part of a double + DBL_MIN_10_EXP = -307 ## the minimum value in base 10 of the exponent part of a double + DBL_MAX_10_EXP = 308 ## the maximum value in base 10 of the exponent part of a double + DBL_MIN = 2.2250738585072014E-308 ## the minimal value of a double + DBL_MAX = 1.7976931348623157E+308 ## the minimal value of a double DBL_EPSILON = 2.2204460492503131E-16 ## the difference between 1 and the least value greater than 1 of a double template fpRadix*: int = FLT_RADIX diff --git a/lib/pure/math.nim b/lib/pure/math.nim index 8457b8e0b..79a8675a6 100644 --- a/lib/pure/math.nim +++ b/lib/pure/math.nim @@ -51,7 +51,7 @@ include "system/inclrtl" -{.push debugger:off .} # the user does not want to trace a part +{.push debugger: off.} # the user does not want to trace a part # of the standard library! import bitops @@ -93,39 +93,39 @@ proc fac*(n: int): int = assert(n < factTable.len, $n & " is too large to look up in the table") factTable[n] -{.push checks:off, line_dir:off, stack_trace:off.} +{.push checks: off, line_dir: off, stack_trace: off.} when defined(Posix) and not defined(genode): {.passl: "-lm".} const - PI* = 3.1415926535897932384626433 ## The circle constant PI (Ludolph's number) - TAU* = 2.0 * PI ## The circle constant TAU (= 2 * PI) - E* = 2.71828182845904523536028747 ## Euler's number - - MaxFloat64Precision* = 16 ## Maximum number of meaningful digits - ## after the decimal point for Nim's - ## ``float64`` type. - MaxFloat32Precision* = 8 ## Maximum number of meaningful digits - ## after the decimal point for Nim's - ## ``float32`` type. + PI* = 3.1415926535897932384626433 ## The circle constant PI (Ludolph's number) + TAU* = 2.0 * PI ## The circle constant TAU (= 2 * PI) + E* = 2.71828182845904523536028747 ## Euler's number + + MaxFloat64Precision* = 16 ## Maximum number of meaningful digits + ## after the decimal point for Nim's + ## ``float64`` type. + MaxFloat32Precision* = 8 ## Maximum number of meaningful digits + ## after the decimal point for Nim's + ## ``float32`` type. MaxFloatPrecision* = MaxFloat64Precision ## Maximum number of ## meaningful digits ## after the decimal point ## for Nim's ``float`` type. - RadPerDeg = PI / 180.0 ## Number of radians per degree + RadPerDeg = PI / 180.0 ## Number of radians per degree type FloatClass* = enum ## Describes the class a floating point value belongs to. ## This is the type that is returned by ## `classify proc <#classify,float>`_. - fcNormal, ## value is an ordinary nonzero floating point value - fcSubnormal, ## value is a subnormal (a very small) floating point value - fcZero, ## value is zero - fcNegZero, ## value is the negative zero - fcNan, ## value is Not-A-Number (NAN) - fcInf, ## value is positive infinity - fcNegInf ## value is negative infinity + fcNormal, ## value is an ordinary nonzero floating point value + fcSubnormal, ## value is a subnormal (a very small) floating point value + fcZero, ## value is zero + fcNegZero, ## value is the negative zero + fcNan, ## value is Not-A-Number (NAN) + fcInf, ## value is positive infinity + fcNegInf ## value is negative infinity proc classify*(x: float): FloatClass = ## Classifies a floating point value. @@ -186,7 +186,7 @@ proc nextPowerOfTwo*(x: int): int {.noSideEffect.} = result = result or (result shr 4) result = result or (result shr 2) result = result or (result shr 1) - result += 1 + ord(x<=0) + result += 1 + ord(x <= 0) proc countBits32*(n: int32): int {.noSideEffect, deprecated: "Deprecated since v0.20.0; use 'bitops.countSetBits' instead".} = @@ -472,7 +472,8 @@ when not defined(JS): # C ## .. code-block:: nim ## echo arctan(1.0) ## 0.7853981633974483 ## echo radToDeg(arctan(1.0)) ## 45.0 - proc arctan2*(y, x: float32): float32 {.importc: "atan2f", header: "<math.h>".} + proc arctan2*(y, x: float32): float32 {.importc: "atan2f", + header: "<math.h>".} proc arctan2*(y, x: float64): float64 {.importc: "atan2", header: "<math.h>".} ## Calculate the arc tangent of ``y`` / ``x``. ## @@ -603,9 +604,11 @@ when not defined(JS): # C ## echo gamma(11.0) # 3628800.0 ## echo gamma(-1.0) # nan proc tgamma*(x: float32): float32 - {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead", importc: "tgammaf", header: "<math.h>".} + {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead", + importc: "tgammaf", header: "<math.h>".} proc tgamma*(x: float64): float64 - {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead", importc: "tgamma", header: "<math.h>".} + {.deprecated: "Deprecated since v0.19.0; use 'gamma' instead", + importc: "tgamma", header: "<math.h>".} ## The gamma function proc lgamma*(x: float32): float32 {.importc: "lgammaf", header: "<math.h>".} proc lgamma*(x: float64): float64 {.importc: "lgamma", header: "<math.h>".} @@ -739,8 +742,10 @@ when not defined(JS): # C ## echo trunc(PI) # 3.0 ## echo trunc(-1.85) # -1.0 - proc fmod*(x, y: float32): float32 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead", importc: "fmodf", header: "<math.h>".} - proc fmod*(x, y: float64): float64 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead", importc: "fmod", header: "<math.h>".} + proc fmod*(x, y: float32): float32 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead", + importc: "fmodf", header: "<math.h>".} + proc fmod*(x, y: float64): float64 {.deprecated: "Deprecated since v0.19.0; use 'mod' instead", + importc: "fmod", header: "<math.h>".} ## Computes the remainder of ``x`` divided by ``y``. proc `mod`*(x, y: float32): float32 {.importc: "fmodf", header: "<math.h>".} @@ -779,7 +784,8 @@ else: # JS ## ( 6.5 mod -2.5) == 1.5 ## (-6.5 mod -2.5) == -1.5 -proc round*[T: float32|float64](x: T, places: int): T {.deprecated: "use strformat module instead".} = +proc round*[T: float32|float64](x: T, places: int): T {. + deprecated: "use strformat module instead".} = ## Decimal rounding on a binary floating point number. ## ## This function is NOT reliable. Floating point numbers cannot hold diff --git a/lib/pure/random.nim b/lib/pure/random.nim index 9abbe947e..c3ccd121b 100644 --- a/lib/pure/random.nim +++ b/lib/pure/random.nim @@ -78,10 +78,10 @@ ## <lib.html#pure-libraries-cryptography-and-hashing>`_ ## in the standard library -import algorithm #For upperBound +import algorithm #For upperBound include "system/inclrtl" -{.push debugger:off.} +{.push debugger: off.} when defined(JS): type ui = uint32 @@ -94,18 +94,18 @@ else: type Rand* = object ## State of a random number generator. - ## - ## Create a new Rand state using the `initRand proc<#initRand,int64>`_. - ## - ## The module contains a default Rand state for convenience. - ## It corresponds to the default random number generator's state. - ## The default Rand state always starts with the same values, but the - ## `randomize proc<#randomize>`_ can be used to seed the default generator - ## with a value based on the current time. - ## - ## Many procs have two variations: one that takes in a Rand parameter and - ## another that uses the default generator. The procs that use the default - ## generator are **not** thread-safe! + ## + ## Create a new Rand state using the `initRand proc<#initRand,int64>`_. + ## + ## The module contains a default Rand state for convenience. + ## It corresponds to the default random number generator's state. + ## The default Rand state always starts with the same values, but the + ## `randomize proc<#randomize>`_ can be used to seed the default generator + ## with a value based on the current time. + ## + ## Many procs have two variations: one that takes in a Rand parameter and + ## another that uses the default generator. The procs that use the default + ## generator are **not** thread-safe! a0, a1: ui when defined(JS): @@ -481,7 +481,7 @@ proc sample*[T](a: openArray[T]): T = doAssert sample(marbles) == "red" result = a[rand(a.low..a.high)] -proc sample*[T, U](r: var Rand; a: openArray[T], cdf: openArray[U]): T = +proc sample*[T, U](r: var Rand; a: openArray[T]; cdf: openArray[U]): T = ## Returns an element from ``a`` using a cumulative distribution function ## (CDF) and the given state. ## @@ -509,14 +509,14 @@ proc sample*[T, U](r: var Rand; a: openArray[T], cdf: openArray[U]): T = doAssert r.sample(marbles, cdf) == "red" doAssert r.sample(marbles, cdf) == "green" doAssert r.sample(marbles, cdf) == "blue" - assert(cdf.len == a.len) # Two basic sanity checks. + assert(cdf.len == a.len) # Two basic sanity checks. assert(float(cdf[^1]) > 0.0) #While we could check cdf[i-1] <= cdf[i] for i in 1..cdf.len, that could get #awfully expensive even in debugging modes. let u = r.rand(float(cdf[^1])) a[cdf.upperBound(U(u))] -proc sample*[T, U](a: openArray[T], cdf: openArray[U]): T = +proc sample*[T, U](a: openArray[T]; cdf: openArray[U]): T = ## Returns an element from ``a`` using a cumulative distribution function ## (CDF). ## diff --git a/lib/pure/rationals.nim b/lib/pure/rationals.nim index 76891a830..b668a9f71 100644 --- a/lib/pure/rationals.nim +++ b/lib/pure/rationals.nim @@ -39,7 +39,8 @@ proc toRational*[T: SomeInteger](x: T): Rational[T] = result.num = x result.den = 1 -proc toRational*(x: float, n: int = high(int) shr (sizeof(int) div 2 * 8)): Rational[int] = +proc toRational*(x: float, + n: int = high(int) shr (sizeof(int) div 2 * 8)): Rational[int] = ## Calculates the best rational numerator and denominator ## that approximates to `x`, where the denominator is ## smaller than `n` (default is the largest possible @@ -67,9 +68,9 @@ proc toRational*(x: float, n: int = high(int) shr (sizeof(int) div 2 * 8)): Rati swap m22, m21 m11 = m12 * ai + m11 m21 = m22 * ai + m21 - if x == float(ai): break # division by zero + if x == float(ai): break # division by zero x = 1/(x - float(ai)) - if x > float(high(int32)): break # representation failure + if x > float(high(int32)): break # representation failure ai = int(x) result = m11 // m21 @@ -282,69 +283,69 @@ proc hash*[T](x: Rational[T]): Hash = when isMainModule: var z = Rational[int](num: 0, den: 1) - o = initRational(num=1, den=1) + o = initRational(num = 1, den = 1) a = initRational(1, 2) b = -1 // -2 m1 = -1 // 1 tt = 10 // 2 - assert( a == a ) - assert( (a-a) == z ) - assert( (a+b) == o ) - assert( (a/b) == o ) - assert( (a*b) == 1 // 4 ) - assert( (3/a) == 6 // 1 ) - assert( (a/3) == 1 // 6 ) - assert( a*b == 1 // 4 ) - assert( tt*z == z ) - assert( 10*a == tt ) - assert( a*10 == tt ) - assert( tt/10 == a ) - assert( a-m1 == 3 // 2 ) - assert( a+m1 == -1 // 2 ) - assert( m1+tt == 16 // 4 ) - assert( m1-tt == 6 // -1 ) - - assert( z < o ) - assert( z <= o ) - assert( z == z ) - assert( cmp(z, o) < 0 ) - assert( cmp(o, z) > 0 ) - - assert( o == o ) - assert( o >= o ) - assert( not(o > o) ) - assert( cmp(o, o) == 0 ) - assert( cmp(z, z) == 0 ) - assert( hash(o) == hash(o) ) - - assert( a == b ) - assert( a >= b ) - assert( not(b > a) ) - assert( cmp(a, b) == 0 ) - assert( hash(a) == hash(b) ) + assert(a == a) + assert( (a-a) == z) + assert( (a+b) == o) + assert( (a/b) == o) + assert( (a*b) == 1 // 4) + assert( (3/a) == 6 // 1) + assert( (a/3) == 1 // 6) + assert(a*b == 1 // 4) + assert(tt*z == z) + assert(10*a == tt) + assert(a*10 == tt) + assert(tt/10 == a) + assert(a-m1 == 3 // 2) + assert(a+m1 == -1 // 2) + assert(m1+tt == 16 // 4) + assert(m1-tt == 6 // -1) + + assert(z < o) + assert(z <= o) + assert(z == z) + assert(cmp(z, o) < 0) + assert(cmp(o, z) > 0) + + assert(o == o) + assert(o >= o) + assert(not(o > o)) + assert(cmp(o, o) == 0) + assert(cmp(z, z) == 0) + assert(hash(o) == hash(o)) + + assert(a == b) + assert(a >= b) + assert(not(b > a)) + assert(cmp(a, b) == 0) + assert(hash(a) == hash(b)) var x = 1//3 x *= 5//1 - assert( x == 5//3 ) + assert(x == 5//3) x += 2 // 9 - assert( x == 17//9 ) + assert(x == 17//9) x -= 9//18 - assert( x == 25//18 ) + assert(x == 25//18) x /= 1//2 - assert( x == 50//18 ) + assert(x == 50//18) var y = 1//3 y *= 4 - assert( y == 4//3 ) + assert(y == 4//3) y += 5 - assert( y == 19//3 ) + assert(y == 19//3) y -= 2 - assert( y == 13//3 ) + assert(y == 13//3) y /= 9 - assert( y == 13//27 ) + assert(y == 13//27) assert toRational(5) == 5//1 assert abs(toFloat(y) - 0.4814814814814815) < 1.0e-7 |