Do not use stdlib math.Round

Author: lafriks

modules/stats/lang.go

@@ -18,14 +18,14 @@ import (
 
 const fileSizeLimit int64 = 16 * 1024 * 1024
 
-// GetLanguageStats calculates language stats for git repository specified commit
-func GetLanguageStats(repoPath, commitSha string) (map[string]float32, error) {
+// GetLanguageStats calculates language stats for git repository at specified commit
+func GetLanguageStats(repoPath, commitID string) (map[string]float32, error) {
 	r, err := git.PlainOpen(repoPath)
 	if err != nil {
 		return nil, err
 	}
 
-	rev, err := r.ResolveRevision(plumbing.Revision(commitSha))
+	rev, err := r.ResolveRevision(plumbing.Revision(commitID))
 	if err != nil {
 		return nil, err
 	}
@@ -75,15 +75,15 @@ func GetLanguageStats(repoPath, commitSha string) (map[string]float32, error) {
 	stats := make(map[string]float32, 0)
 	var otherPerc float32 = 100
 	for language, size := range sizes {
-		perc := float32(math.Round(float64(size)/float64(total)*1000) / 10)
+		perc := float32(round(float64(size)/float64(total)*1000) / 10)
 		if perc <= 0.1 {
 			continue
 		}
 		otherPerc -= perc
 		stats[language] = perc
 	}
 	if otherPerc > 0 {
-		stats["other"] = float32(math.Round(float64(otherPerc)*10) / 10)
+		stats["other"] = float32(round(float64(otherPerc)*10) / 10)
 	}
 	return stats, nil
 }
@@ -108,3 +108,51 @@ func readFile(f *object.File, limit int64) ([]byte, error) {
 	_, err = io.Copy(buf, io.LimitReader(r, limit))
 	return buf.Bytes(), err
 }
+
+// TODO: Taken from std lib, remove when GoLang min version updated to 1.10
+
+const (
+	uvone    = 0x3FF0000000000000
+	mask     = 0x7FF
+	shift    = 64 - 11 - 1
+	bias     = 1023
+	signMask = 1 << 63
+	fracMask = 1<<shift - 1
+)
+
+// round returns the nearest integer, rounding half away from zero.
+//
+// Special cases are:
+//	round(±0) = ±0
+//	round(±Inf) = ±Inf
+//	round(NaN) = NaN
+func round(x float64) float64 {
+	// round is a faster implementation of:
+	//
+	// func round(x float64) float64 {
+	//   t := Trunc(x)
+	//   if Abs(x-t) >= 0.5 {
+	//     return t + Copysign(1, x)
+	//   }
+	//   return t
+	// }
+	bits := math.Float64bits(x)
+	e := uint(bits>>shift) & mask
+	if e < bias {
+		// Round abs(x) < 1 including denormals.
+		bits &= signMask // +-0
+		if e == bias-1 {
+			bits |= uvone // +-1
+		}
+	} else if e < bias+shift {
+		// Round any abs(x) >= 1 containing a fractional component [0,1).
+		//
+		// Numbers with larger exponents are returned unchanged since they
+		// must be either an integer, infinity, or NaN.
+		const half = 1 << (shift - 1)
+		e -= bias
+		bits += half >> e
+		bits &^= fracMask >> e
+	}
+	return math.Float64frombits(bits)
+}