modify

Author: penguinn

pmath/round.go

@@ -0,0 +1,18 @@
+package pmath
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+)
+
+func Round(f float64, n int) float64 {
+	n10 := math.Pow10(n)
+	return math.Trunc((f+0.5/n10)*n10) / n10
+}
+
+func Round2(f float64, n int) float64 {
+	floatStr := fmt.Sprintf("%."+strconv.Itoa(n)+"f", f)
+	inst, _ := strconv.ParseFloat(floatStr, 64)
+	return inst
+}

pmath/round_test.go

@@ -0,0 +1,88 @@
+package pmath_test
+
+import (
+	"github.com/penguinn/utils/pmath"
+	"testing"
+)
+
+func TestRound(t *testing.T) {
+	type args struct {
+		f float64
+		n int
+	}
+	tests := []struct {
+		name string
+		args args
+		want float64
+	}{
+		{name: "测试1",
+			args: args{
+				f: 54.48341896,
+				n: 2,
+			},
+			want: 54.48,
+		},
+		{name: "测试2",
+			args: args{
+				f: 54.48841896,
+				n: 2,
+			},
+			want: 54.49,
+		},
+		{name: "测试3",
+			args: args{
+				f: 54.47841896,
+				n: 2,
+			},
+			want: 54.48,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := pmath.Round(tt.args.f, tt.args.n); got != tt.want {
+				t.Errorf("Round() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestRound2(t *testing.T) {
+	type args struct {
+		f float64
+		n int
+	}
+	tests := []struct {
+		name string
+		args args
+		want float64
+	}{
+		{name: "测试1",
+			args: args{
+				f: 54.48341896,
+				n: 2,
+			},
+			want: 54.48,
+		},
+		{name: "测试2",
+			args: args{
+				f: 54.48841896,
+				n: 2,
+			},
+			want: 54.49,
+		},
+		{name: "测试3",
+			args: args{
+				f: 54.47841896,
+				n: 2,
+			},
+			want: 54.48,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := pmath.Round2(tt.args.f, tt.args.n); got != tt.want {
+				t.Errorf("Round2() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

set_util.go

@@ -1,79 +1,79 @@
-package utils
-
-import (
-	"sync"
-)
-
-type Set struct {
-	mapInst map[interface{}]bool
-	sync.RWMutex
-}
-
-func New() *Set {
-	return &Set{
-		mapInst: map[interface{}]bool{},
-	}
-}
-
-func (p *Set) Add(item interface{}) {
-	p.Lock()
-	defer p.Unlock()
-	p.mapInst[item] = true
-}
-
-func (p *Set) Remove(item interface{}) {
-	p.Lock()
-	defer p.Unlock()
-	delete(p.mapInst, item)
-}
-
-func (p *Set) PopOne() (item interface{}, ok bool) {
-	p.Lock()
-	defer p.Unlock()
-	if len(p.mapInst) > 0 {
-		for k := range p.mapInst {
-			item = k
-			delete(p.mapInst, k)
-			break
-		}
-		ok = true
-	} else {
-		ok = false
-	}
-	return
-}
-
-func (p *Set) Has(item interface{}) bool {
-	p.RLock()
-	defer p.RUnlock()
-	_, ok := p.mapInst[item]
-	return ok
-}
-
-func (p *Set) Len() int {
-	return int(len(p.mapInst))
-}
-
-func (p *Set) Clear() {
-	p.Lock()
-	defer p.Unlock()
-	p.mapInst = map[interface{}]bool{}
-}
-
-func (p *Set) IsEmpty() bool {
-	if p.Len() == 0 {
-		return true
-	}
-	return false
-}
-
-func (p *Set) List() []interface{} {
-	p.RLock()
-	defer p.RUnlock()
-	list := []interface{}{}
-
-	for item := range p.mapInst {
-		list = append(list, item)
-	}
-	return list
-}
+package utils
+
+import (
+	"sync"
+)
+
+type Set struct {
+	mapInst map[interface{}]bool
+	sync.RWMutex
+}
+
+func New() *Set {
+	return &Set{
+		mapInst: map[interface{}]bool{},
+	}
+}
+
+func (p *Set) Add(item interface{}) {
+	p.Lock()
+	defer p.Unlock()
+	p.mapInst[item] = true
+}
+
+func (p *Set) Remove(item interface{}) {
+	p.Lock()
+	defer p.Unlock()
+	delete(p.mapInst, item)
+}
+
+func (p *Set) PopOne() (item interface{}, ok bool) {
+	p.Lock()
+	defer p.Unlock()
+	if len(p.mapInst) > 0 {
+		for k := range p.mapInst {
+			item = k
+			delete(p.mapInst, k)
+			break
+		}
+		ok = true
+	} else {
+		ok = false
+	}
+	return
+}
+
+func (p *Set) Has(item interface{}) bool {
+	p.RLock()
+	defer p.RUnlock()
+	_, ok := p.mapInst[item]
+	return ok
+}
+
+func (p *Set) Len() int {
+	return int(len(p.mapInst))
+}
+
+func (p *Set) Clear() {
+	p.Lock()
+	defer p.Unlock()
+	p.mapInst = map[interface{}]bool{}
+}
+
+func (p *Set) IsEmpty() bool {
+	if p.Len() == 0 {
+		return true
+	}
+	return false
+}
+
+func (p *Set) List() []interface{} {
+	p.RLock()
+	defer p.RUnlock()
+	list := []interface{}{}
+
+	for item := range p.mapInst {
+		list = append(list, item)
+	}
+	return list
+}