jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update the changelog

Browse source
This commit is contained in:
Andreas Rumpf 2018-05-06 08:17:32 +02:00
commit cd0985df06
2 changed files with 3 additions and 432 deletions
Download patch file Download diff file Expand all files Collapse all files

3
changelog.md
View file

@ -41,6 +41,9 @@
#### Breaking changes in the compiler #### Breaking changes in the compiler
- The undocumented ``#? braces`` parsing mode was removed.
- The undocumented PHP backend was removed.
### Library additions ### Library additions
- ``re.split`` now also supports the ``maxsplit`` parameter for consistency - ``re.split`` now also supports the ``maxsplit`` parameter for consistency

432
tests/parser/tbraces.nim
View file

@ -1,432 +0,0 @@
#? braces
#
#
# Nim's Runtime Library
# (c) Copyright 2015 Andreas Rumpf
#
# See the file "copying.txt", included in this
# distribution, for details about the copyright.
#
## This module implements some common generic algorithms.
type
SortOrder* = enum { ## sort order
Descending, Ascending
}
type(
DummyAlias = int
OtherAlias = distinct char
SomeObject = object of RootObj { ## declaration here
fieldA, fieldB: int
case order: SortOrder {
of Descending {a: string}
of Ascending {b: seq[char]}
}
}
MyConcept = concept x {
x is int
}
)
{.deprecated: [TSortOrder: SortOrder].}
proc `*`*(x: int, order: SortOrder): int @inline {
## flips `x` if ``order == Descending``;
## if ``order == Ascending`` then `x` is returned.
## `x` is supposed to be the result of a comparator, ie ``< 0`` for
## *less than*, ``== 0`` for *equal*, ``> 0`` for *greater than*.
var y = order.ord - 1
result = (x xor y) - y
}
proc fill*[T](a: var openArray[T], first, last: Natural, value: T) {
## fills the array ``a[first..last]`` with `value`.
var x = first
while x <= last {
a[x] = value
inc(x)
}
}
proc fill*[T](a: var openArray[T], value: T) {
## fills the array `a` with `value`.
fill(a, 0, a.high, value)
}
proc reverse*[T](a: var openArray[T], first, last: Natural) {
## reverses the array ``a[first..last]``.
var x = first
var y = last
while x < y {
swap(a[x], a[y])
dec(y)
inc(x)
}
}
proc reverse*[T](a: var openArray[T]) {
## reverses the array `a`.
reverse(a, 0, a.high)
}
proc reversed*[T](a: openArray[T], first: Natural, last: int): seq[T] {
## returns the reverse of the array `a[first..last]`.
assert last >= first-1
var i = last - first
var x = first.int
result = newSeq[T](i + 1)
while i >= 0 {
result[i] = a[x]
dec(i)
inc(x)
}
}
proc reversed*[T](a: openArray[T]): seq[T] {
## returns the reverse of the array `a`.
reversed(a, 0, a.high)
}
proc binarySearch*[T](a: openArray[T], key: T): int {
## binary search for `key` in `a`. Returns -1 if not found.
var b = len(a)
while result < b {
var mid = (result + b) div 2
if a[mid] < key { result = mid + 1 } else { b = mid }
}
if result >= len(a) or a[result] != key { result = -1 }
}
proc smartBinarySearch*[T](a: openArray[T], key: T): int {
## ``a.len`` must be a power of 2 for this to work.
var step = a.len div 2
while step > 0 {
if a[result or step] <= key { result = result or step }
step = step shr 1
}
if a[result] != key { result = -1 }
}
const (
onlySafeCode = true
)
proc lowerBound*[T](a: openArray[T], key: T, cmp: proc(x,y: T): int @closure): int {
## same as binarySearch except that if key is not in `a` then this
## returns the location where `key` would be if it were. In other
## words if you have a sorted sequence and you call
## insert(thing, elm, lowerBound(thing, elm))
## the sequence will still be sorted.
##
## `cmp` is the comparator function to use, the expected return values are
## the same as that of system.cmp.
##
## example::
##
## var arr = @[1,2,3,5,6,7,8,9]
## arr.insert(4, arr.lowerBound(4))
## # after running the above arr is `[1,2,3,4,5,6,7,8,9]`
result = a.low
var count = a.high - a.low + 1
var step, pos: int
while count != 0 {
step = count div 2
pos = result + step
if cmp(a[pos], key) < 0 {
result = pos + 1
count -= step + 1
} else {
count = step
}
}
}
proc lowerBound*[T](a: openArray[T], key: T): int { lowerBound(a, key, cmp[T]) }
proc merge[T](a, b: var openArray[T], lo, m, hi: int,
cmp: proc (x, y: T): int @closure, order: SortOrder) {
template `<-` (a, b) {
when false {
a = b
} elif onlySafeCode {
shallowCopy(a, b)
} else {
copyMem(addr(a), addr(b), sizeof(T))
}
}
# optimization: If max(left) <= min(right) there is nothing to do!
# 1 2 3 4 ## 5 6 7 8
# -> O(n) for sorted arrays.
# On random data this safes up to 40% of merge calls
if cmp(a[m], a[m+1]) * order <= 0 { return }
var j = lo
# copy a[j..m] into b:
assert j <= m
when onlySafeCode {
var bb = 0
while j <= m {
b[bb] <- a[j]
inc(bb)
inc(j)
}
} else {
copyMem(addr(b[0]), addr(a[j]), sizeof(T)*(m-j+1))
j = m+1
}
var i = 0
var k = lo
# copy proper element back:
while k < j and j <= hi {
if cmp(b[i], a[j]) * order <= 0 {
a[k] <- b[i]
inc(i)
} else {
a[k] <- a[j]
inc(j)
}
inc(k)
}
# copy rest of b:
when onlySafeCode {
while k < j {
a[k] <- b[i]
inc(k)
inc(i)
}
} else {
if k < j { copyMem(addr(a[k]), addr(b[i]), sizeof(T)*(j-k)) }
}
}
proc sort*[T](a: var openArray[T],
cmp: proc (x, y: T): int @closure,
order = SortOrder.Ascending) {
## Default Nim sort (an implementation of merge sort). The sorting
## is guaranteed to be stable and the worst case is guaranteed to
## be O(n log n).
## The current implementation uses an iterative
## mergesort to achieve this. It uses a temporary sequence of
## length ``a.len div 2``. Currently Nim does not support a
## sensible default argument for ``cmp``, so you have to provide one
## of your own. However, the ``system.cmp`` procs can be used:
##
## .. code-block:: nim
##
## sort(myIntArray, system.cmp[int])
##
## # do not use cmp[string] here as we want to use the specialized
## # overload:
## sort(myStrArray, system.cmp)
##
## You can inline adhoc comparison procs with the `do notation
## <manual.html#procedures-do-notation>`_. Example:
##
## .. code-block:: nim
##
## people.sort do (x, y: Person) -> int:
## result = cmp(x.surname, y.surname)
## if result == 0:
## result = cmp(x.name, y.name)
var n = a.len
var b: seq[T]
newSeq(b, n div 2)
var s = 1
while s < n {
var m = n-1-s
while m >= 0 {
merge(a, b, max(m-s+1, 0), m, m+s, cmp, order)
dec(m, s*2)
}
s = s*2
}
}
proc sorted*[T](a: openArray[T], cmp: proc(x, y: T): int {.closure.},
order = SortOrder.Ascending): seq[T] {
## returns `a` sorted by `cmp` in the specified `order`.
result = newSeq[T](a.len)
for i in 0 .. a.high { result[i] = a[i] }
sort(result, cmp, order)
}
template sortedByIt*(seq1, op: untyped): untyped {
## Convenience template around the ``sorted`` proc to reduce typing.
##
## The template injects the ``it`` variable which you can use directly in an
## expression. Example:
##
## .. code-block:: nim
##
## type Person = tuple[name: string, age: int]
## var
## p1: Person = (name: "p1", age: 60)
## p2: Person = (name: "p2", age: 20)
## p3: Person = (name: "p3", age: 30)
## p4: Person = (name: "p4", age: 30)
## people = @[p1,p2,p4,p3]
##
## echo people.sortedByIt(it.name)
##
## Because the underlying ``cmp()`` is defined for tuples you can do
## a nested sort like in the following example:
##
## .. code-block:: nim
##
## echo people.sortedByIt((it.age, it.name))
##
var result = sorted(seq1, proc(x, y: type[seq1[0]]): int {
var it {.inject.} = x
let a = op
it = y
let b = op
result = cmp(a, b)
})
result
}
proc isSorted*[T](a: openarray[T],
cmp: proc(x, y: T): int {.closure.},
order = SortOrder.Ascending): bool {
## Checks to see whether `a` is already sorted in `order`
## using `cmp` for the comparison. Parameters identical
## to `sort`
result = true
for i in 0..<len(a)-1 {
case cmp(a[i],a[i+1]) * order > 0 {
of true { return false }
of false {}
}
}
}
proc product*[T](x: openArray[seq[T]]): seq[seq[T]] {
## produces the Cartesian product of the array. Warning: complexity
## may explode.
result = newSeq[seq[T]]()
if x.len == 0 { return }
if x.len == 1 {
result = @x
return
}
var (
indexes = newSeq[int](x.len)
initial = newSeq[int](x.len)
index = 0
)
var next = newSeq[T]()
next.setLen(x.len)
for i in 0..(x.len-1) {
if len(x[i]) == 0 { return }
initial[i] = len(x[i])-1
}
indexes = initial
while true {
while indexes[index] == -1 {
indexes[index] = initial[index]
index += 1
if index == x.len { return }
indexes[index] -= 1
}
for ni, i in indexes {
next[ni] = x[ni][i]
}
var res: seq[T]
shallowCopy(res, next)
result.add(res)
index = 0
indexes[index] -= 1
}
}
proc nextPermutation*[T](x: var openarray[T]): bool {.discardable.} {
## Calculates the next lexicographic permutation, directly modifying ``x``.
## The result is whether a permutation happened, otherwise we have reached
## the last-ordered permutation.
##
## .. code-block:: nim
##
## var v = @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
## v.nextPermutation()
## echo v # @[0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
if x.len < 2 {
return false }
var i = x.high
while i > 0 and x[i-1] >= x[i] { dec i }
if i == 0 { return false }
var j = x.high
while j >= i and x[j] <= x[i-1] { dec j }
swap x[j], x[i-1]
x.reverse(i, x.high)
result = true
}
proc prevPermutation*[T](x: var openarray[T]): bool @discardable {
## Calculates the previous lexicographic permutation, directly modifying
## ``x``. The result is whether a permutation happened, otherwise we have
## reached the first-ordered permutation.
##
## .. code-block:: nim
##
## var v = @[0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
## v.prevPermutation()
## echo v # @[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
if x.len < 2 { return false }
var i = x.high
while i > 0 and x[i-1] <= x[i] {
dec i
}
if i == 0 { return false }
x.reverse(i, x.high)
var j = x.high
while j >= i and x[j-1] < x[i-1] {
dec j
}
swap x[i-1], x[j]
result = true
}
when isMainModule {
# Tests for lowerBound
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]
try {
assert arr.lowerBound(4) == 1
assert arr.lowerBound(5) == 1
assert arr.lowerBound(6) == 2
} except ValueError {}
# 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 srt4: seq[int] = @[]
assert srt1.isSorted(cmp) == true
assert srt2.isSorted(cmp) == false
assert srt3.isSorted(cmp) == true
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]
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]
}
}