Add parseFloatThousandSep

changelog.md

@@ -35,6 +35,9 @@
 
 - `doAssertRaises` now correctly handles foreign exceptions.
 
+- Add `strmisc.parseFloatThousandSep` designed to parse floats as found in the wild formatted for humans.
+
+
 ## Language changes
 
 - `nimscript` now handles `except Exception as e`

lib/pure/strmisc.nim

@@ -11,6 +11,7 @@
 ## used in comparison to `strutils <strutils.html>`_.
 
 import strutils
+import std/private/since
 
 proc expandTabs*(s: string, tabSize: int = 8): string {.noSideEffect.} =
   ## Expand tab characters in `s` replacing them by spaces.
@@ -85,6 +86,80 @@ proc rpartition*(s: string, sep: string): (string, string, string)
 
   return partition(s, sep, right = true)
 
+
+func parseFloatThousandSep*(str: openArray[char]; sep = ','; decimalDot = '.'): float {.since: (1, 5).} =
+  ## Convenience func for `parseFloat` which allows for thousand separators,
+  ## this is designed to parse floats as found in the wild formatted for humans.
+  ##
+  ## The following assumptions and requirements must be met:
+  ## - `str` must not be empty.
+  ## - `str` must be stripped of trailing and leading whitespaces.
+  ## - `sep` must not be `'-'`.
+  ## - `decimalDot` must not be `'-'` nor `' '`.
+  ## - `sep` and `decimalDot` must be different.
+  ## - No separator before a digit.
+  ## - There has to be 3 digits between successive separators.
+  ## - There has to be 3 digits between the last separator and the decimal dot.
+  ## - No separator after decimal dot.
+  ## - No duplicate separators.
+  ## - Floats without separator allowed.
+  ##
+  ## See also:
+  ## * `parseFloat <strutils.html#parseFloat,string>`_
+  runnableExamples:
+    doAssert parseFloatThousandSep("-1,000") == -1000.0
+    doAssert parseFloatThousandSep("10,000.000") == 10000.0
+    doAssert parseFloatThousandSep("1,000,000.000") == 1000000.0
+    doAssert parseFloatThousandSep("10,000,000.000") == 10000000.0
+    doAssert parseFloatThousandSep("10.000,0", '.', ',') == 10000.0
+    doAssert parseFloatThousandSep("1'000'000,000", '\'', ',') == 1000000.0
+    doAssert parseFloatThousandSep("1000000") == 1000000.0
+    ## You can omit `sep`, but then all subsequent `sep` to the left must also be omitted:
+    doAssert parseFloatThousandSep("1000,000") == 1000000.0
+
+  assert sep != '-' and decimalDot notin {'-', ' '} and sep != decimalDot
+
+  proc raiseError(i: int; c: char; s: openArray[char]) {.noinline, noreturn.} =
+    raise newException(ValueError,
+      "Invalid float containing thousand separators, invalid char $1 at index $2 for input $3" %
+      [c.repr, $i, s.repr])
+
+  var s = newStringOfCap(str.len)
+  var successive: int
+  var afterDot, lastWasDot, lastWasSep, hasAnySep, isNegative: bool
+  for idx, c in str:
+    if c in '0' .. '9':  # Digits
+      if hasAnySep and successive > 2:
+        raiseError(idx, c, str)
+      else:
+        s.add c
+        lastWasSep = false
+        lastWasDot = false
+        inc successive
+    if c == sep:  # Thousands separator, this is NOT the dot
+      if lastWasSep or afterDot or (isNegative and idx == 1 or idx == 0):
+        raiseError(idx, c, str)
+      else:
+        lastWasSep = true # Do NOT add the Thousands separator here.
+        hasAnySep = true
+        successive = 0
+    if c == decimalDot:  # This is the dot
+      if (isNegative and idx == 1 or idx == 0) or (hasAnySep and successive != 3):  # Disallow .1
+        raiseError(idx, c, str)
+      else:
+        s.add '.' # Replace decimalDot to '.' so parseFloat can take it.
+        successive = 0
+        lastWasDot = true
+        afterDot = true
+    if c == '-':  # Allow negative float
+      if isNegative or idx != 0:  # Disallow ---1.0
+        raiseError(idx, c, str)
+      else:
+        s.add '-'
+        isNegative = true
+  result = parseFloat(s)
+
+
 when isMainModule:
   doAssert expandTabs("\t", 4) == "    "
   doAssert expandTabs("\tfoo\t", 4) == "    foo "

lib/pure/strutils.nim

@@ -1150,6 +1150,9 @@ proc parseFloat*(s: string): float {.noSideEffect,
   ##
   ## If `s` is not a valid floating point number, `ValueError` is raised.
   ##``NAN``, ``INF``, ``-INF`` are also supported (case insensitive comparison).
+  ##
+  ## See also:
+  ## * `parseFloatThousandSep <strmisc.html#parseFloatThousandSep,openArray[char],char,char>`_
   runnableExamples:
     doAssert parseFloat("3.14") == 3.14
     doAssert parseFloat("inf") == 1.0/0

tests/stdlib/tstrmisc.nim

@@ -0,0 +1,22 @@
+import strmisc
+
+
+func main() =
+  doAssert parseFloatThousandSep("0") == 0.0
+  doAssert parseFloatThousandSep("-0") == -0.0
+  doAssert parseFloatThousandSep("0.0") == 0.0
+  doAssert parseFloatThousandSep("1.0") == 1.0
+  doAssert parseFloatThousandSep("-0.0") == -0.0
+  doAssert parseFloatThousandSep("-1.0") == -1.0
+  doAssert parseFloatThousandSep("1.000") == 1.0
+  doAssert parseFloatThousandSep("-1.000") == -1.0
+  doAssertRaises(ValueError): discard parseFloatThousandSep("1,0000.000")
+  doAssertRaises(ValueError): discard parseFloatThousandSep("--")
+  doAssertRaises(ValueError): discard parseFloatThousandSep("..")
+  doAssertRaises(ValueError): discard parseFloatThousandSep("1,,000")
+  doAssertRaises(ValueError): discard parseFloatThousandSep("1..000")
+  doAssertRaises(ValueError): discard parseFloatThousandSep("1,000000")
+
+
+main()
+static: main()