Add space between the numbers and units.
Closes #21
diff --git a/bigbytes.go b/bigbytes.go
index e4a814a..67ea5c8 100644
--- a/bigbytes.go
+++ b/bigbytes.go
@@ -95,14 +95,14 @@
func humanateBigBytes(s, base *big.Int, sizes []string) string {
if s.Cmp(ten) < 0 {
- return fmt.Sprintf("%dB", s)
+ return fmt.Sprintf("%d B", s)
}
c := (&big.Int{}).Set(s)
val, mag := oomm(c, base, len(sizes)-1)
suffix := sizes[mag]
- f := "%.0f%s"
+ f := "%.0f %s"
if val < 10 {
- f = "%.1f%s"
+ f = "%.1f %s"
}
return fmt.Sprintf(f, val, suffix)
diff --git a/bigbytes_test.go b/bigbytes_test.go
index da367d4..88eed45 100644
--- a/bigbytes_test.go
+++ b/bigbytes_test.go
@@ -81,91 +81,91 @@
func TestBigBytes(t *testing.T) {
testList{
- {"bytes(0)", bbyte(0), "0B"},
- {"bytes(1)", bbyte(1), "1B"},
- {"bytes(803)", bbyte(803), "803B"},
- {"bytes(999)", bbyte(999), "999B"},
+ {"bytes(0)", bbyte(0), "0 B"},
+ {"bytes(1)", bbyte(1), "1 B"},
+ {"bytes(803)", bbyte(803), "803 B"},
+ {"bytes(999)", bbyte(999), "999 B"},
- {"bytes(1024)", bbyte(1024), "1.0kB"},
- {"bytes(1MB - 1)", bbyte(MByte - Byte), "1000kB"},
+ {"bytes(1024)", bbyte(1024), "1.0 kB"},
+ {"bytes(1MB - 1)", bbyte(MByte - Byte), "1000 kB"},
- {"bytes(1MB)", bbyte(1024 * 1024), "1.0MB"},
- {"bytes(1GB - 1K)", bbyte(GByte - KByte), "1000MB"},
+ {"bytes(1MB)", bbyte(1024 * 1024), "1.0 MB"},
+ {"bytes(1GB - 1K)", bbyte(GByte - KByte), "1000 MB"},
- {"bytes(1GB)", bbyte(GByte), "1.0GB"},
- {"bytes(1TB - 1M)", bbyte(TByte - MByte), "1000GB"},
+ {"bytes(1GB)", bbyte(GByte), "1.0 GB"},
+ {"bytes(1TB - 1M)", bbyte(TByte - MByte), "1000 GB"},
- {"bytes(1TB)", bbyte(TByte), "1.0TB"},
- {"bytes(1PB - 1T)", bbyte(PByte - TByte), "999TB"},
+ {"bytes(1TB)", bbyte(TByte), "1.0 TB"},
+ {"bytes(1PB - 1T)", bbyte(PByte - TByte), "999 TB"},
- {"bytes(1PB)", bbyte(PByte), "1.0PB"},
- {"bytes(1PB - 1T)", bbyte(EByte - PByte), "999PB"},
+ {"bytes(1PB)", bbyte(PByte), "1.0 PB"},
+ {"bytes(1PB - 1T)", bbyte(EByte - PByte), "999 PB"},
- {"bytes(1EB)", bbyte(EByte), "1.0EB"},
+ {"bytes(1EB)", bbyte(EByte), "1.0 EB"},
// Overflows.
// {"bytes(1EB - 1P)", Bytes((KByte*EByte)-PByte), "1023EB"},
- {"bytes(0)", bibyte(0), "0B"},
- {"bytes(1)", bibyte(1), "1B"},
- {"bytes(803)", bibyte(803), "803B"},
- {"bytes(1023)", bibyte(1023), "1023B"},
+ {"bytes(0)", bibyte(0), "0 B"},
+ {"bytes(1)", bibyte(1), "1 B"},
+ {"bytes(803)", bibyte(803), "803 B"},
+ {"bytes(1023)", bibyte(1023), "1023 B"},
- {"bytes(1024)", bibyte(1024), "1.0KiB"},
- {"bytes(1MB - 1)", bibyte(MiByte - IByte), "1024KiB"},
+ {"bytes(1024)", bibyte(1024), "1.0 KiB"},
+ {"bytes(1MB - 1)", bibyte(MiByte - IByte), "1024 KiB"},
- {"bytes(1MB)", bibyte(1024 * 1024), "1.0MiB"},
- {"bytes(1GB - 1K)", bibyte(GiByte - KiByte), "1024MiB"},
+ {"bytes(1MB)", bibyte(1024 * 1024), "1.0 MiB"},
+ {"bytes(1GB - 1K)", bibyte(GiByte - KiByte), "1024 MiB"},
- {"bytes(1GB)", bibyte(GiByte), "1.0GiB"},
- {"bytes(1TB - 1M)", bibyte(TiByte - MiByte), "1024GiB"},
+ {"bytes(1GB)", bibyte(GiByte), "1.0 GiB"},
+ {"bytes(1TB - 1M)", bibyte(TiByte - MiByte), "1024 GiB"},
- {"bytes(1TB)", bibyte(TiByte), "1.0TiB"},
- {"bytes(1PB - 1T)", bibyte(PiByte - TiByte), "1023TiB"},
+ {"bytes(1TB)", bibyte(TiByte), "1.0 TiB"},
+ {"bytes(1PB - 1T)", bibyte(PiByte - TiByte), "1023 TiB"},
- {"bytes(1PB)", bibyte(PiByte), "1.0PiB"},
- {"bytes(1PB - 1T)", bibyte(EiByte - PiByte), "1023PiB"},
+ {"bytes(1PB)", bibyte(PiByte), "1.0 PiB"},
+ {"bytes(1PB - 1T)", bibyte(EiByte - PiByte), "1023 PiB"},
- {"bytes(1EiB)", bibyte(EiByte), "1.0EiB"},
+ {"bytes(1EiB)", bibyte(EiByte), "1.0 EiB"},
// Overflows.
// {"bytes(1EB - 1P)", bibyte((KIByte*EIByte)-PiByte), "1023EB"},
- {"bytes(5.5GiB)", bibyte(5.5 * GiByte), "5.5GiB"},
+ {"bytes(5.5GiB)", bibyte(5.5 * GiByte), "5.5 GiB"},
- {"bytes(5.5GB)", bbyte(5.5 * GByte), "5.5GB"},
+ {"bytes(5.5GB)", bbyte(5.5 * GByte), "5.5 GB"},
}.validate(t)
}
func TestVeryBigBytes(t *testing.T) {
b, _ := (&big.Int{}).SetString("15347691069326346944512", 10)
s := BigBytes(b)
- if s != "15ZB" {
- t.Errorf("Expected 15ZB, got %v", s)
+ if s != "15 ZB" {
+ t.Errorf("Expected 15 ZB, got %v", s)
}
s = BigIBytes(b)
- if s != "13ZiB" {
- t.Errorf("Expected 13ZiB, got %v", s)
+ if s != "13 ZiB" {
+ t.Errorf("Expected 13 ZiB, got %v", s)
}
b, _ = (&big.Int{}).SetString("15716035654990179271180288", 10)
s = BigBytes(b)
- if s != "16YB" {
- t.Errorf("Expected 16YB, got %v", s)
+ if s != "16 YB" {
+ t.Errorf("Expected 16 YB, got %v", s)
}
s = BigIBytes(b)
- if s != "13YiB" {
- t.Errorf("Expected 13YiB, got %v", s)
+ if s != "13 YiB" {
+ t.Errorf("Expected 13 YiB, got %v", s)
}
}
func TestVeryVeryBigBytes(t *testing.T) {
b, _ := (&big.Int{}).SetString("16093220510709943573688614912", 10)
s := BigBytes(b)
- if s != "16093YB" {
- t.Errorf("Expected 16093YB, got %v", s)
+ if s != "16093 YB" {
+ t.Errorf("Expected 16093 YB, got %v", s)
}
s = BigIBytes(b)
- if s != "13312YiB" {
- t.Errorf("Expected 13312YiB, got %v", s)
+ if s != "13312 YiB" {
+ t.Errorf("Expected 13312 YiB, got %v", s)
}
}
@@ -174,23 +174,23 @@
in string
out string
}{
- {"16ZB", "16000000000000000000000"},
- {"16ZiB", "18889465931478580854784"},
- {"16.5ZB", "16500000000000000000000"},
- {"16.5ZiB", "19479761741837286506496"},
- {"16Z", "16000000000000000000000"},
- {"16Zi", "18889465931478580854784"},
- {"16.5Z", "16500000000000000000000"},
- {"16.5Zi", "19479761741837286506496"},
+ {"16 ZB", "16000000000000000000000"},
+ {"16 ZiB", "18889465931478580854784"},
+ {"16.5 ZB", "16500000000000000000000"},
+ {"16.5 ZiB", "19479761741837286506496"},
+ {"16 Z", "16000000000000000000000"},
+ {"16 Zi", "18889465931478580854784"},
+ {"16.5 Z", "16500000000000000000000"},
+ {"16.5 Zi", "19479761741837286506496"},
- {"16YB", "16000000000000000000000000"},
- {"16YiB", "19342813113834066795298816"},
- {"16.5YB", "16500000000000000000000000"},
- {"16.5YiB", "19947276023641381382651904"},
- {"16Y", "16000000000000000000000000"},
- {"16Yi", "19342813113834066795298816"},
- {"16.5Y", "16500000000000000000000000"},
- {"16.5Yi", "19947276023641381382651904"},
+ {"16 YB", "16000000000000000000000000"},
+ {"16 YiB", "19342813113834066795298816"},
+ {"16.5 YB", "16500000000000000000000000"},
+ {"16.5 YiB", "19947276023641381382651904"},
+ {"16 Y", "16000000000000000000000000"},
+ {"16 Yi", "19342813113834066795298816"},
+ {"16.5 Y", "16500000000000000000000000"},
+ {"16.5 Yi", "19947276023641381382651904"},
}
for _, test := range tests {
@@ -208,7 +208,7 @@
func BenchmarkParseBigBytes(b *testing.B) {
for i := 0; i < b.N; i++ {
- ParseBigBytes("16.5Z")
+ ParseBigBytes("16.5 Z")
}
}
diff --git a/bytes.go b/bytes.go
index b7a77b5..dacbb9c 100644
--- a/bytes.go
+++ b/bytes.go
@@ -67,14 +67,14 @@
func humanateBytes(s uint64, base float64, sizes []string) string {
if s < 10 {
- return fmt.Sprintf("%dB", s)
+ return fmt.Sprintf("%d B", s)
}
e := math.Floor(logn(float64(s), base))
suffix := sizes[int(e)]
val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
- f := "%.0f%s"
+ f := "%.0f %s"
if val < 10 {
- f = "%.1f%s"
+ f = "%.1f %s"
}
return fmt.Sprintf(f, val, suffix)
diff --git a/bytes_test.go b/bytes_test.go
index 7497fa0..99cad92 100644
--- a/bytes_test.go
+++ b/bytes_test.go
@@ -75,65 +75,65 @@
func TestBytes(t *testing.T) {
testList{
- {"bytes(0)", Bytes(0), "0B"},
- {"bytes(1)", Bytes(1), "1B"},
- {"bytes(803)", Bytes(803), "803B"},
- {"bytes(999)", Bytes(999), "999B"},
+ {"bytes(0)", Bytes(0), "0 B"},
+ {"bytes(1)", Bytes(1), "1 B"},
+ {"bytes(803)", Bytes(803), "803 B"},
+ {"bytes(999)", Bytes(999), "999 B"},
- {"bytes(1024)", Bytes(1024), "1.0kB"},
- {"bytes(9999)", Bytes(9999), "10kB"},
- {"bytes(1MB - 1)", Bytes(MByte - Byte), "1000kB"},
+ {"bytes(1024)", Bytes(1024), "1.0 kB"},
+ {"bytes(9999)", Bytes(9999), "10 kB"},
+ {"bytes(1MB - 1)", Bytes(MByte - Byte), "1000 kB"},
- {"bytes(1MB)", Bytes(1024 * 1024), "1.0MB"},
- {"bytes(1GB - 1K)", Bytes(GByte - KByte), "1000MB"},
+ {"bytes(1MB)", Bytes(1024 * 1024), "1.0 MB"},
+ {"bytes(1GB - 1K)", Bytes(GByte - KByte), "1000 MB"},
- {"bytes(1GB)", Bytes(GByte), "1.0GB"},
- {"bytes(1TB - 1M)", Bytes(TByte - MByte), "1000GB"},
- {"bytes(10MB)", Bytes(9999 * 1000), "10MB"},
+ {"bytes(1GB)", Bytes(GByte), "1.0 GB"},
+ {"bytes(1TB - 1M)", Bytes(TByte - MByte), "1000 GB"},
+ {"bytes(10MB)", Bytes(9999 * 1000), "10 MB"},
- {"bytes(1TB)", Bytes(TByte), "1.0TB"},
- {"bytes(1PB - 1T)", Bytes(PByte - TByte), "999TB"},
+ {"bytes(1TB)", Bytes(TByte), "1.0 TB"},
+ {"bytes(1PB - 1T)", Bytes(PByte - TByte), "999 TB"},
- {"bytes(1PB)", Bytes(PByte), "1.0PB"},
- {"bytes(1PB - 1T)", Bytes(EByte - PByte), "999PB"},
+ {"bytes(1PB)", Bytes(PByte), "1.0 PB"},
+ {"bytes(1PB - 1T)", Bytes(EByte - PByte), "999 PB"},
- {"bytes(1EB)", Bytes(EByte), "1.0EB"},
+ {"bytes(1EB)", Bytes(EByte), "1.0 EB"},
// Overflows.
// {"bytes(1EB - 1P)", Bytes((KByte*EByte)-PByte), "1023EB"},
- {"bytes(0)", IBytes(0), "0B"},
- {"bytes(1)", IBytes(1), "1B"},
- {"bytes(803)", IBytes(803), "803B"},
- {"bytes(1023)", IBytes(1023), "1023B"},
+ {"bytes(0)", IBytes(0), "0 B"},
+ {"bytes(1)", IBytes(1), "1 B"},
+ {"bytes(803)", IBytes(803), "803 B"},
+ {"bytes(1023)", IBytes(1023), "1023 B"},
- {"bytes(1024)", IBytes(1024), "1.0KiB"},
- {"bytes(1MB - 1)", IBytes(MiByte - IByte), "1024KiB"},
+ {"bytes(1024)", IBytes(1024), "1.0 KiB"},
+ {"bytes(1MB - 1)", IBytes(MiByte - IByte), "1024 KiB"},
- {"bytes(1MB)", IBytes(1024 * 1024), "1.0MiB"},
- {"bytes(1GB - 1K)", IBytes(GiByte - KiByte), "1024MiB"},
+ {"bytes(1MB)", IBytes(1024 * 1024), "1.0 MiB"},
+ {"bytes(1GB - 1K)", IBytes(GiByte - KiByte), "1024 MiB"},
- {"bytes(1GB)", IBytes(GiByte), "1.0GiB"},
- {"bytes(1TB - 1M)", IBytes(TiByte - MiByte), "1024GiB"},
+ {"bytes(1GB)", IBytes(GiByte), "1.0 GiB"},
+ {"bytes(1TB - 1M)", IBytes(TiByte - MiByte), "1024 GiB"},
- {"bytes(1TB)", IBytes(TiByte), "1.0TiB"},
- {"bytes(1PB - 1T)", IBytes(PiByte - TiByte), "1023TiB"},
+ {"bytes(1TB)", IBytes(TiByte), "1.0 TiB"},
+ {"bytes(1PB - 1T)", IBytes(PiByte - TiByte), "1023 TiB"},
- {"bytes(1PB)", IBytes(PiByte), "1.0PiB"},
- {"bytes(1PB - 1T)", IBytes(EiByte - PiByte), "1023PiB"},
+ {"bytes(1PB)", IBytes(PiByte), "1.0 PiB"},
+ {"bytes(1PB - 1T)", IBytes(EiByte - PiByte), "1023 PiB"},
- {"bytes(1EiB)", IBytes(EiByte), "1.0EiB"},
+ {"bytes(1EiB)", IBytes(EiByte), "1.0 EiB"},
// Overflows.
// {"bytes(1EB - 1P)", IBytes((KIByte*EIByte)-PiByte), "1023EB"},
- {"bytes(5.5GiB)", IBytes(5.5 * GiByte), "5.5GiB"},
+ {"bytes(5.5GiB)", IBytes(5.5 * GiByte), "5.5 GiB"},
- {"bytes(5.5GB)", Bytes(5.5 * GByte), "5.5GB"},
+ {"bytes(5.5GB)", Bytes(5.5 * GByte), "5.5 GB"},
}.validate(t)
}
func BenchmarkParseBytes(b *testing.B) {
for i := 0; i < b.N; i++ {
- ParseBytes("16.5GB")
+ ParseBytes("16.5 GB")
}
}
diff --git a/ftoa_test.go b/ftoa_test.go
index 40d13bd..276d411 100644
--- a/ftoa_test.go
+++ b/ftoa_test.go
@@ -44,7 +44,7 @@
func BenchmarkFmtF(b *testing.B) {
for i := 0; i < b.N; i++ {
- fmt.Sprintf("%f", 2.03584)
+ _ = fmt.Sprintf("%f", 2.03584)
}
}
diff --git a/si.go b/si.go
index dee8b76..fe86fe5 100644
--- a/si.go
+++ b/si.go
@@ -41,7 +41,7 @@
var riParseRegex *regexp.Regexp
func init() {
- ri := `^([0-9.]+)([`
+ ri := `^([0-9.]+)\s?([`
for _, v := range siPrefixTable {
ri += v
}
@@ -87,7 +87,7 @@
// e.g. SI(2.2345e-12, "F") -> 2.2345pF
func SI(input float64, unit string) string {
value, prefix := ComputeSI(input)
- return Ftoa(value) + prefix + unit
+ return Ftoa(value) + " " + prefix + unit
}
var errInvalid = errors.New("invalid input")
diff --git a/si_test.go b/si_test.go
index 32fb386..4940378 100644
--- a/si_test.go
+++ b/si_test.go
@@ -11,53 +11,53 @@
num float64
formatted string
}{
- {"e-24", 1e-24, "1yF"},
- {"e-21", 1e-21, "1zF"},
- {"e-18", 1e-18, "1aF"},
- {"e-15", 1e-15, "1fF"},
- {"e-12", 1e-12, "1pF"},
- {"e-12", 2.2345e-12, "2.2345pF"},
- {"e-12", 2.23e-12, "2.23pF"},
- {"e-11", 2.23e-11, "22.3pF"},
- {"e-10", 2.2e-10, "220pF"},
- {"e-9", 2.2e-9, "2.2nF"},
- {"e-8", 2.2e-8, "22nF"},
- {"e-7", 2.2e-7, "220nF"},
- {"e-6", 2.2e-6, "2.2µF"},
- {"e-6", 1e-6, "1µF"},
- {"e-5", 2.2e-5, "22µF"},
- {"e-4", 2.2e-4, "220µF"},
- {"e-3", 2.2e-3, "2.2mF"},
- {"e-2", 2.2e-2, "22mF"},
- {"e-1", 2.2e-1, "220mF"},
- {"e+0", 2.2e-0, "2.2F"},
- {"e+0", 2.2, "2.2F"},
- {"e+1", 2.2e+1, "22F"},
- {"0", 0, "0F"},
- {"e+1", 22, "22F"},
- {"e+2", 2.2e+2, "220F"},
- {"e+2", 220, "220F"},
- {"e+3", 2.2e+3, "2.2kF"},
- {"e+3", 2200, "2.2kF"},
- {"e+4", 2.2e+4, "22kF"},
- {"e+4", 22000, "22kF"},
- {"e+5", 2.2e+5, "220kF"},
- {"e+6", 2.2e+6, "2.2MF"},
- {"e+6", 1e+6, "1MF"},
- {"e+7", 2.2e+7, "22MF"},
- {"e+8", 2.2e+8, "220MF"},
- {"e+9", 2.2e+9, "2.2GF"},
- {"e+10", 2.2e+10, "22GF"},
- {"e+11", 2.2e+11, "220GF"},
- {"e+12", 2.2e+12, "2.2TF"},
- {"e+15", 2.2e+15, "2.2PF"},
- {"e+18", 2.2e+18, "2.2EF"},
- {"e+21", 2.2e+21, "2.2ZF"},
- {"e+24", 2.2e+24, "2.2YF"},
+ {"e-24", 1e-24, "1 yF"},
+ {"e-21", 1e-21, "1 zF"},
+ {"e-18", 1e-18, "1 aF"},
+ {"e-15", 1e-15, "1 fF"},
+ {"e-12", 1e-12, "1 pF"},
+ {"e-12", 2.2345e-12, "2.2345 pF"},
+ {"e-12", 2.23e-12, "2.23 pF"},
+ {"e-11", 2.23e-11, "22.3 pF"},
+ {"e-10", 2.2e-10, "220 pF"},
+ {"e-9", 2.2e-9, "2.2 nF"},
+ {"e-8", 2.2e-8, "22 nF"},
+ {"e-7", 2.2e-7, "220 nF"},
+ {"e-6", 2.2e-6, "2.2 µF"},
+ {"e-6", 1e-6, "1 µF"},
+ {"e-5", 2.2e-5, "22 µF"},
+ {"e-4", 2.2e-4, "220 µF"},
+ {"e-3", 2.2e-3, "2.2 mF"},
+ {"e-2", 2.2e-2, "22 mF"},
+ {"e-1", 2.2e-1, "220 mF"},
+ {"e+0", 2.2e-0, "2.2 F"},
+ {"e+0", 2.2, "2.2 F"},
+ {"e+1", 2.2e+1, "22 F"},
+ {"0", 0, "0 F"},
+ {"e+1", 22, "22 F"},
+ {"e+2", 2.2e+2, "220 F"},
+ {"e+2", 220, "220 F"},
+ {"e+3", 2.2e+3, "2.2 kF"},
+ {"e+3", 2200, "2.2 kF"},
+ {"e+4", 2.2e+4, "22 kF"},
+ {"e+4", 22000, "22 kF"},
+ {"e+5", 2.2e+5, "220 kF"},
+ {"e+6", 2.2e+6, "2.2 MF"},
+ {"e+6", 1e+6, "1 MF"},
+ {"e+7", 2.2e+7, "22 MF"},
+ {"e+8", 2.2e+8, "220 MF"},
+ {"e+9", 2.2e+9, "2.2 GF"},
+ {"e+10", 2.2e+10, "22 GF"},
+ {"e+11", 2.2e+11, "220 GF"},
+ {"e+12", 2.2e+12, "2.2 TF"},
+ {"e+15", 2.2e+15, "2.2 PF"},
+ {"e+18", 2.2e+18, "2.2 EF"},
+ {"e+21", 2.2e+21, "2.2 ZF"},
+ {"e+24", 2.2e+24, "2.2 YF"},
// special case
- {"1F", 1000 * 1000, "1MF"},
- {"1F", 1e6, "1MF"},
+ {"1F", 1000 * 1000, "1 MF"},
+ {"1F", 1e6, "1 MF"},
}
for _, test := range tests {
