diff --git a/go.mod b/go.mod
index 50cf929..01f9c91 100644
--- a/go.mod
+++ b/go.mod
@@ -1,4 +1,4 @@
-module git.tilde.institute/kneezle/myCovidCLI
+module git.tilde.institute/kneezle/mycovidcli
go 1.13
diff --git a/myCovidCLI.go b/myCovidCLI.go
index 2594512..bf6dbaf 100644
--- a/myCovidCLI.go
+++ b/myCovidCLI.go
@@ -12,7 +12,7 @@ import (
"strings"
"time"
- "git.tilde.institute/kneezle/myCOVIDcli/renderfloat"
+ "git.tilde.institute/kneezle/mycovidcli/renderfloat"
"github.com/olekukonko/tablewriter"
)
diff --git a/renderfloat/renderfloat.go b/renderfloat/renderfloat.go
index 042a36d..e66209b 100644
--- a/renderfloat/renderfloat.go
+++ b/renderfloat/renderfloat.go
@@ -37,158 +37,158 @@ of code, hence the snippet. Feel free to reuse as you wish.
package renderfloat
import (
-"math"
-"strconv"
+ "math"
+ "strconv"
)
var renderFloatPrecisionMultipliers = [10]float64{
-1,
-10,
-100,
-1000,
-10000,
-100000,
-1000000,
-10000000,
-100000000,
-1000000000,
+ 1,
+ 10,
+ 100,
+ 1000,
+ 10000,
+ 100000,
+ 1000000,
+ 10000000,
+ 100000000,
+ 1000000000,
}
var renderFloatPrecisionRounders = [10]float64{
-0.5,
-0.05,
-0.005,
-0.0005,
-0.00005,
-0.000005,
-0.0000005,
-0.00000005,
-0.000000005,
-0.0000000005,
+ 0.5,
+ 0.05,
+ 0.005,
+ 0.0005,
+ 0.00005,
+ 0.000005,
+ 0.0000005,
+ 0.00000005,
+ 0.000000005,
+ 0.0000000005,
}
func RenderFloat(format string, n float64) string {
-// Special cases:
-// NaN = "NaN"
-// +Inf = "+Infinity"
-// -Inf = "-Infinity"
-if math.IsNaN(n) {
-return "NaN"
-}
-if n > math.MaxFloat64 {
-return "Infinity"
-}
-if n < -math.MaxFloat64 {
-return "-Infinity"
-}
-
-// default format
-precision := 2
-decimalStr := "."
-thousandStr := ","
-positiveStr := ""
-negativeStr := "-"
-
-if len(format) > 0 {
-// If there is an explicit format directive,
-// then default values are these:
-precision = 9
-thousandStr = ""
-
-// collect indices of meaningful formatting directives
-formatDirectiveChars := []rune(format)
-formatDirectiveIndices := make([]int, 0)
-for i, char := range formatDirectiveChars {
-if char != '#' && char != '0' {
-formatDirectiveIndices = append(formatDirectiveIndices, i)
-}
-}
-
-if len(formatDirectiveIndices) > 0 {
-// Directive at index 0:
-// Must be a '+'
-// Raise an error if not the case
-// index: 0123456789
-// +0.000,000
-// +000,000.0
-// +0000.00
-// +0000
-if formatDirectiveIndices[0] == 0 {
-if formatDirectiveChars[formatDirectiveIndices[0]] != '+' {
-panic("RenderFloat(): invalid positive sign directive")
-}
-positiveStr = "+"
-formatDirectiveIndices = formatDirectiveIndices[1:]
-}
-
-// Two directives:
-// First is thousands separator
-// Raise an error if not followed by 3-digit
-// 0123456789
-// 0.000,000
-// 000,000.00
-if len(formatDirectiveIndices) == 2 {
-if (formatDirectiveIndices[1] - formatDirectiveIndices[0]) != 4 {
-panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers")
-}
-thousandStr = string(formatDirectiveChars[formatDirectiveIndices[0]])
-formatDirectiveIndices = formatDirectiveIndices[1:]
-}
-
-// One directive:
-// Directive is decimal separator
-// The number of digit-specifier following the separator indicates wanted precision
-// 0123456789
-// 0.00
-// 000,0000
-if len(formatDirectiveIndices) == 1 {
-decimalStr = string(formatDirectiveChars[formatDirectiveIndices[0]])
-precision = len(formatDirectiveChars) - formatDirectiveIndices[0] - 1
-}
-}
-}
-
-// generate sign part
-var signStr string
-if n >= 0.000000001 {
-signStr = positiveStr
-} else if n <= -0.000000001 {
-signStr = negativeStr
-n = -n
-} else {
-signStr = ""
-n = 0.0
-}
-
-// split number into integer and fractional parts
-intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])
-
-// generate integer part string
-intStr := strconv.Itoa(int(intf))
-
-// add thousand separator if required
-if len(thousandStr) > 0 {
-for i := len(intStr); i > 3; {
-i -= 3
-intStr = intStr[:i] + thousandStr + intStr[i:]
-}
-}
-
-// no fractional part, we can leave now
-if precision == 0 {
-return signStr + intStr
-}
-
-// generate fractional part
-fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))
-// may need padding
-if len(fracStr) < precision {
-fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr
-}
-
-return signStr + intStr + decimalStr + fracStr
+ // Special cases:
+ // NaN = "NaN"
+ // +Inf = "+Infinity"
+ // -Inf = "-Infinity"
+ if math.IsNaN(n) {
+ return "NaN"
+ }
+ if n > math.MaxFloat64 {
+ return "Infinity"
+ }
+ if n < -math.MaxFloat64 {
+ return "-Infinity"
+ }
+
+ // default format
+ precision := 2
+ decimalStr := "."
+ thousandStr := ","
+ positiveStr := ""
+ negativeStr := "-"
+
+ if len(format) > 0 {
+ // If there is an explicit format directive,
+ // then default values are these:
+ precision = 9
+ thousandStr = ""
+
+ // collect indices of meaningful formatting directives
+ formatDirectiveChars := []rune(format)
+ formatDirectiveIndices := make([]int, 0)
+ for i, char := range formatDirectiveChars {
+ if char != '#' && char != '0' {
+ formatDirectiveIndices = append(formatDirectiveIndices, i)
+ }
+ }
+
+ if len(formatDirectiveIndices) > 0 {
+ // Directive at index 0:
+ // Must be a '+'
+ // Raise an error if not the case
+ // index: 0123456789
+ // +0.000,000
+ // +000,000.0
+ // +0000.00
+ // +0000
+ if formatDirectiveIndices[0] == 0 {
+ if formatDirectiveChars[formatDirectiveIndices[0]] != '+' {
+ panic("RenderFloat(): invalid positive sign directive")
+ }
+ positiveStr = "+"
+ formatDirectiveIndices = formatDirectiveIndices[1:]
+ }
+
+ // Two directives:
+ // First is thousands separator
+ // Raise an error if not followed by 3-digit
+ // 0123456789
+ // 0.000,000
+ // 000,000.00
+ if len(formatDirectiveIndices) == 2 {
+ if (formatDirectiveIndices[1] - formatDirectiveIndices[0]) != 4 {
+ panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers")
+ }
+ thousandStr = string(formatDirectiveChars[formatDirectiveIndices[0]])
+ formatDirectiveIndices = formatDirectiveIndices[1:]
+ }
+
+ // One directive:
+ // Directive is decimal separator
+ // The number of digit-specifier following the separator indicates wanted precision
+ // 0123456789
+ // 0.00
+ // 000,0000
+ if len(formatDirectiveIndices) == 1 {
+ decimalStr = string(formatDirectiveChars[formatDirectiveIndices[0]])
+ precision = len(formatDirectiveChars) - formatDirectiveIndices[0] - 1
+ }
+ }
+ }
+
+ // generate sign part
+ var signStr string
+ if n >= 0.000000001 {
+ signStr = positiveStr
+ } else if n <= -0.000000001 {
+ signStr = negativeStr
+ n = -n
+ } else {
+ signStr = ""
+ n = 0.0
+ }
+
+ // split number into integer and fractional parts
+ intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])
+
+ // generate integer part string
+ intStr := strconv.Itoa(int(intf))
+
+ // add thousand separator if required
+ if len(thousandStr) > 0 {
+ for i := len(intStr); i > 3; {
+ i -= 3
+ intStr = intStr[:i] + thousandStr + intStr[i:]
+ }
+ }
+
+ // no fractional part, we can leave now
+ if precision == 0 {
+ return signStr + intStr
+ }
+
+ // generate fractional part
+ fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))
+ // may need padding
+ if len(fracStr) < precision {
+ fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr
+ }
+
+ return signStr + intStr + decimalStr + fracStr
}
func RenderInteger(format string, n int) string {
-return RenderFloat(format, float64(n))
+ return RenderFloat(format, float64(n))
}
|