cubefs

1
package humanize
2

3
/*
4
Slightly adapted from the source to fit go-humanize.
5

6
Author: https://github.com/gorhill
7
Source: https://gist.github.com/gorhill/5285193
8

9
*/
10

11
import (
12
	"math"
13
	"strconv"
14
)
15

16
var (
17
	renderFloatPrecisionMultipliers = [...]float64{
18
		1,
19
		10,
20
		100,
21
		1000,
22
		10000,
23
		100000,
24
		1000000,
25
		10000000,
26
		100000000,
27
		1000000000,
28
	}
29

30
	renderFloatPrecisionRounders = [...]float64{
31
		0.5,
32
		0.05,
33
		0.005,
34
		0.0005,
35
		0.00005,
36
		0.000005,
37
		0.0000005,
38
		0.00000005,
39
		0.000000005,
40
		0.0000000005,
41
	}
42
)
43

44
// FormatFloat produces a formatted number as string based on the following user-specified criteria:
45
// * thousands separator
46
// * decimal separator
47
// * decimal precision
48
//
49
// Usage: s := RenderFloat(format, n)
50
// The format parameter tells how to render the number n.
51
//
52
// See examples: http://play.golang.org/p/LXc1Ddm1lJ
53
//
54
// Examples of format strings, given n = 12345.6789:
55
// "#,###.##" => "12,345.67"
56
// "#,###." => "12,345"
57
// "#,###" => "12345,678"
58
// "#\u202F###,##" => "12 345,68"
59
// "#.###,###### => 12.345,678900
60
// "" (aka default format) => 12,345.67
61
//
62
// The highest precision allowed is 9 digits after the decimal symbol.
63
// There is also a version for integer number, FormatInteger(),
64
// which is convenient for calls within template.
65
func FormatFloat(format string, n float64) string {
66
	// Special cases:
67
	//   NaN = "NaN"
68
	//   +Inf = "+Infinity"
69
	//   -Inf = "-Infinity"
70
	if math.IsNaN(n) {
71
		return "NaN"
72
	}
73
	if n > math.MaxFloat64 {
74
		return "Infinity"
75
	}
76
	if n < (0.0 - math.MaxFloat64) {
77
		return "-Infinity"
78
	}
79

80
	// default format
81
	precision := 2
82
	decimalStr := "."
83
	thousandStr := ","
84
	positiveStr := ""
85
	negativeStr := "-"
86

87
	if len(format) > 0 {
88
		format := []rune(format)
89

90
		// If there is an explicit format directive,
91
		// then default values are these:
92
		precision = 9
93
		thousandStr = ""
94

95
		// collect indices of meaningful formatting directives
96
		formatIndx := []int{}
97
		for i, char := range format {
98
			if char != '#' && char != '0' {
99
				formatIndx = append(formatIndx, i)
100
			}
101
		}
102

103
		if len(formatIndx) > 0 {
104
			// Directive at index 0:
105
			//   Must be a '+'
106
			//   Raise an error if not the case
107
			// index: 0123456789
108
			//        +0.000,000
109
			//        +000,000.0
110
			//        +0000.00
111
			//        +0000
112
			if formatIndx[0] == 0 {
113
				if format[formatIndx[0]] != '+' {
114
					panic("RenderFloat(): invalid positive sign directive")
115
				}
116
				positiveStr = "+"
117
				formatIndx = formatIndx[1:]
118
			}
119

120
			// Two directives:
121
			//   First is thousands separator
122
			//   Raise an error if not followed by 3-digit
123
			// 0123456789
124
			// 0.000,000
125
			// 000,000.00
126
			if len(formatIndx) == 2 {
127
				if (formatIndx[1] - formatIndx[0]) != 4 {
128
					panic("RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers")
129
				}
130
				thousandStr = string(format[formatIndx[0]])
131
				formatIndx = formatIndx[1:]
132
			}
133

134
			// One directive:
135
			//   Directive is decimal separator
136
			//   The number of digit-specifier following the separator indicates wanted precision
137
			// 0123456789
138
			// 0.00
139
			// 000,0000
140
			if len(formatIndx) == 1 {
141
				decimalStr = string(format[formatIndx[0]])
142
				precision = len(format) - formatIndx[0] - 1
143
			}
144
		}
145
	}
146

147
	// generate sign part
148
	var signStr string
149
	if n >= 0.000000001 {
150
		signStr = positiveStr
151
	} else if n <= -0.000000001 {
152
		signStr = negativeStr
153
		n = -n
154
	} else {
155
		signStr = ""
156
		n = 0.0
157
	}
158

159
	// split number into integer and fractional parts
160
	intf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])
161

162
	// generate integer part string
163
	intStr := strconv.FormatInt(int64(intf), 10)
164

165
	// add thousand separator if required
166
	if len(thousandStr) > 0 {
167
		for i := len(intStr); i > 3; {
168
			i -= 3
169
			intStr = intStr[:i] + thousandStr + intStr[i:]
170
		}
171
	}
172

173
	// no fractional part, we can leave now
174
	if precision == 0 {
175
		return signStr + intStr
176
	}
177

178
	// generate fractional part
179
	fracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))
180
	// may need padding
181
	if len(fracStr) < precision {
182
		fracStr = "000000000000000"[:precision-len(fracStr)] + fracStr
183
	}
184

185
	return signStr + intStr + decimalStr + fracStr
186
}
187

188
// FormatInteger produces a formatted number as string.
189
// See FormatFloat.
190
func FormatInteger(format string, n int) string {
191
	return FormatFloat(format, float64(n))
192
}
193