-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
4 changed files
with
265 additions
and
6 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,196 @@ | ||
| /* | ||
| Author: https://github.com/gorhill | ||
| Source: https://gist.github.com/gorhill/5285193 | ||
| A Go function to render a number to a string based on | ||
| the following user-specified criteria: | ||
| * thousands separator | ||
| * decimal separator | ||
| * decimal precision | ||
| Usage: s := RenderFloat(format, n) | ||
| The format parameter tells how to render the number n. | ||
| http://play.golang.org/p/LXc1Ddm1lJ | ||
| Examples of format strings, given n = 12345.6789: | ||
| "#,###.##" => "12,345.67" | ||
| "#,###." => "12,345" | ||
| "#,###" => "12345,678" | ||
| "#\u202F###,##" => "12 345,67" | ||
| "#.###,###### => 12.345,678900 | ||
| "" (aka default format) => 12,345.67 | ||
| The highest precision allowed is 9 digits after the decimal symbol. | ||
| There is also a version for integer number, RenderInteger(), | ||
| which is convenient for calls within template. | ||
| I didn't feel it was worth to publish a library just for this piece | ||
| of code, hence the snippet. Feel free to reuse as you wish. | ||
| */ | ||
|
|
||
| package chars | ||
|
|
||
| import ( | ||
| "math" | ||
| "strconv" | ||
| ) | ||
|
|
||
| var renderFloatPrecisionMultipliers = [10]float64{ | ||
| 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, | ||
| } | ||
|
|
||
| // RenderFloat - add thousands separator | ||
| 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.FormatInt(int64(intf), 10) | ||
|
|
||
| // 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 | ||
| } | ||
|
|
||
| // RenderInteger - add thousands separator | ||
| func RenderInteger(format string, n int64) string { | ||
| return RenderFloat(format, float64(n)) | ||
| } |