435c0d9fc8
This PR switches the Nomad repository from using govendor to Go modules for managing dependencies. Aspects of the Nomad workflow remain pretty much the same. The usual Makefile targets should continue to work as they always did. The API submodule simply defers to the parent Nomad version on the repository, keeping the semantics of API versioning that currently exists.
124 lines
2.8 KiB
Go
124 lines
2.8 KiB
Go
package humanize
|
|
|
|
import (
|
|
"errors"
|
|
"math"
|
|
"regexp"
|
|
"strconv"
|
|
)
|
|
|
|
var siPrefixTable = map[float64]string{
|
|
-24: "y", // yocto
|
|
-21: "z", // zepto
|
|
-18: "a", // atto
|
|
-15: "f", // femto
|
|
-12: "p", // pico
|
|
-9: "n", // nano
|
|
-6: "µ", // micro
|
|
-3: "m", // milli
|
|
0: "",
|
|
3: "k", // kilo
|
|
6: "M", // mega
|
|
9: "G", // giga
|
|
12: "T", // tera
|
|
15: "P", // peta
|
|
18: "E", // exa
|
|
21: "Z", // zetta
|
|
24: "Y", // yotta
|
|
}
|
|
|
|
var revSIPrefixTable = revfmap(siPrefixTable)
|
|
|
|
// revfmap reverses the map and precomputes the power multiplier
|
|
func revfmap(in map[float64]string) map[string]float64 {
|
|
rv := map[string]float64{}
|
|
for k, v := range in {
|
|
rv[v] = math.Pow(10, k)
|
|
}
|
|
return rv
|
|
}
|
|
|
|
var riParseRegex *regexp.Regexp
|
|
|
|
func init() {
|
|
ri := `^([\-0-9.]+)\s?([`
|
|
for _, v := range siPrefixTable {
|
|
ri += v
|
|
}
|
|
ri += `]?)(.*)`
|
|
|
|
riParseRegex = regexp.MustCompile(ri)
|
|
}
|
|
|
|
// ComputeSI finds the most appropriate SI prefix for the given number
|
|
// and returns the prefix along with the value adjusted to be within
|
|
// that prefix.
|
|
//
|
|
// See also: SI, ParseSI.
|
|
//
|
|
// e.g. ComputeSI(2.2345e-12) -> (2.2345, "p")
|
|
func ComputeSI(input float64) (float64, string) {
|
|
if input == 0 {
|
|
return 0, ""
|
|
}
|
|
mag := math.Abs(input)
|
|
exponent := math.Floor(logn(mag, 10))
|
|
exponent = math.Floor(exponent/3) * 3
|
|
|
|
value := mag / math.Pow(10, exponent)
|
|
|
|
// Handle special case where value is exactly 1000.0
|
|
// Should return 1 M instead of 1000 k
|
|
if value == 1000.0 {
|
|
exponent += 3
|
|
value = mag / math.Pow(10, exponent)
|
|
}
|
|
|
|
value = math.Copysign(value, input)
|
|
|
|
prefix := siPrefixTable[exponent]
|
|
return value, prefix
|
|
}
|
|
|
|
// SI returns a string with default formatting.
|
|
//
|
|
// SI uses Ftoa to format float value, removing trailing zeros.
|
|
//
|
|
// See also: ComputeSI, ParseSI.
|
|
//
|
|
// e.g. SI(1000000, "B") -> 1 MB
|
|
// e.g. SI(2.2345e-12, "F") -> 2.2345 pF
|
|
func SI(input float64, unit string) string {
|
|
value, prefix := ComputeSI(input)
|
|
return Ftoa(value) + " " + prefix + unit
|
|
}
|
|
|
|
// SIWithDigits works like SI but limits the resulting string to the
|
|
// given number of decimal places.
|
|
//
|
|
// e.g. SIWithDigits(1000000, 0, "B") -> 1 MB
|
|
// e.g. SIWithDigits(2.2345e-12, 2, "F") -> 2.23 pF
|
|
func SIWithDigits(input float64, decimals int, unit string) string {
|
|
value, prefix := ComputeSI(input)
|
|
return FtoaWithDigits(value, decimals) + " " + prefix + unit
|
|
}
|
|
|
|
var errInvalid = errors.New("invalid input")
|
|
|
|
// ParseSI parses an SI string back into the number and unit.
|
|
//
|
|
// See also: SI, ComputeSI.
|
|
//
|
|
// e.g. ParseSI("2.2345 pF") -> (2.2345e-12, "F", nil)
|
|
func ParseSI(input string) (float64, string, error) {
|
|
found := riParseRegex.FindStringSubmatch(input)
|
|
if len(found) != 4 {
|
|
return 0, "", errInvalid
|
|
}
|
|
mag := revSIPrefixTable[found[2]]
|
|
unit := found[3]
|
|
|
|
base, err := strconv.ParseFloat(found[1], 64)
|
|
return base * mag, unit, err
|
|
}
|