| package humanize |
| |
| /* |
| Slightly adapted from the source to fit go-humanize. |
| |
| Author: https://github.com/gorhill |
| Source: https://gist.github.com/gorhill/5285193 |
| |
| */ |
| |
| import ( |
| "math" |
| "strconv" |
| ) |
| |
| var ( |
| renderFloatPrecisionMultipliers = [...]float64{ |
| 1, |
| 10, |
| 100, |
| 1000, |
| 10000, |
| 100000, |
| 1000000, |
| 10000000, |
| 100000000, |
| 1000000000, |
| } |
| |
| renderFloatPrecisionRounders = [...]float64{ |
| 0.5, |
| 0.05, |
| 0.005, |
| 0.0005, |
| 0.00005, |
| 0.000005, |
| 0.0000005, |
| 0.00000005, |
| 0.000000005, |
| 0.0000000005, |
| } |
| ) |
| |
| // FormatFloat produces a formatted number as 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. |
| // |
| // See examples: http://play.golang.org/p/LXc1Ddm1lJ |
| // |
| // Examples of format strings, given n = 12345.6789: |
| // "#,###.##" => "12,345.67" |
| // "#,###." => "12,345" |
| // "#,###" => "12345,678" |
| // "#\u202F###,##" => "12 345,68" |
| // "#.###,###### => 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, FormatInteger(), |
| // which is convenient for calls within template. |
| func FormatFloat(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 < (0.0 - math.MaxFloat64) { |
| return "-Infinity" |
| } |
| |
| // default format |
| precision := 2 |
| decimalStr := "." |
| thousandStr := "," |
| positiveStr := "" |
| negativeStr := "-" |
| |
| if len(format) > 0 { |
| format := []rune(format) |
| |
| // If there is an explicit format directive, |
| // then default values are these: |
| precision = 9 |
| thousandStr = "" |
| |
| // collect indices of meaningful formatting directives |
| formatIndx := []int{} |
| for i, char := range format { |
| if char != '#' && char != '0' { |
| formatIndx = append(formatIndx, i) |
| } |
| } |
| |
| if len(formatIndx) > 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 formatIndx[0] == 0 { |
| if format[formatIndx[0]] != '+' { |
| panic("RenderFloat(): invalid positive sign directive") |
| } |
| positiveStr = "+" |
| formatIndx = formatIndx[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(formatIndx) == 2 { |
| if (formatIndx[1] - formatIndx[0]) != 4 { |
| panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers") |
| } |
| thousandStr = string(format[formatIndx[0]]) |
| formatIndx = formatIndx[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(formatIndx) == 1 { |
| decimalStr = string(format[formatIndx[0]]) |
| precision = len(format) - formatIndx[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 |
| } |
| |
| // FormatInteger produces a formatted number as string. |
| // See FormatFloat. |
| func FormatInteger(format string, n int) string { |
| return FormatFloat(format, float64(n)) |
| } |