tpl: Add math.Ceil, Floor, and Round

Ceil and Floor are frontends for the stdlib math functions. The Round
implementation is essentially the same thing except that the Go stdlib
doesn't include a Round implementation in a stable release yet.  I've
included the Round function slated for Go 1.10.

Fixes #3883
This commit is contained in:
Cameron Moore 2017-09-23 20:07:55 -05:00 committed by Bjørn Erik Pedersen
parent 80c7ea60a0
commit 19c5910485
3 changed files with 190 additions and 0 deletions

View file

@ -34,11 +34,31 @@ func (ns *Namespace) Add(a, b interface{}) (interface{}, error) {
return DoArithmetic(a, b, '+')
}
// Ceil returns the least integer value greater than or equal to x.
func (ns *Namespace) Ceil(x interface{}) (float64, error) {
xf, err := cast.ToFloat64E(x)
if err != nil {
return 0, errors.New("Ceil operator can't be used with non-float value")
}
return math.Ceil(xf), nil
}
// Div divides two numbers.
func (ns *Namespace) Div(a, b interface{}) (interface{}, error) {
return DoArithmetic(a, b, '/')
}
// Floor returns the greatest integer value less than or equal to x.
func (ns *Namespace) Floor(x interface{}) (float64, error) {
xf, err := cast.ToFloat64E(x)
if err != nil {
return 0, errors.New("Floor operator can't be used with non-float value")
}
return math.Floor(xf), nil
}
// Log returns the natural logarithm of a number.
func (ns *Namespace) Log(a interface{}) (float64, error) {
af, err := cast.ToFloat64E(a)
@ -92,6 +112,16 @@ func (ns *Namespace) Mul(a, b interface{}) (interface{}, error) {
return DoArithmetic(a, b, '*')
}
// Round returns the nearest integer, rounding half away from zero.
func (ns *Namespace) Round(x interface{}) (float64, error) {
xf, err := cast.ToFloat64E(x)
if err != nil {
return 0, errors.New("Round operator can't be used with non-float value")
}
return _round(xf), nil
}
// Sub subtracts two numbers.
func (ns *Namespace) Sub(a, b interface{}) (interface{}, error) {
return DoArithmetic(a, b, '-')

View file

@ -143,6 +143,72 @@ func TestDoArithmetic(t *testing.T) {
}
}
func TestCeil(t *testing.T) {
t.Parallel()
ns := New()
for i, test := range []struct {
x interface{}
expect interface{}
}{
{0.1, 1.0},
{0.5, 1.0},
{1.1, 2.0},
{1.5, 2.0},
{-0.1, 0.0},
{-0.5, 0.0},
{-1.1, -1.0},
{-1.5, -1.0},
{"abc", false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
result, err := ns.Ceil(test.x)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
}
}
func TestFloor(t *testing.T) {
t.Parallel()
ns := New()
for i, test := range []struct {
x interface{}
expect interface{}
}{
{0.1, 0.0},
{0.5, 0.0},
{1.1, 1.0},
{1.5, 1.0},
{-0.1, -1.0},
{-0.5, -1.0},
{-1.1, -2.0},
{-1.5, -2.0},
{"abc", false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
result, err := ns.Floor(test.x)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
}
}
func TestLog(t *testing.T) {
t.Parallel()
@ -255,3 +321,36 @@ func TestModBool(t *testing.T) {
assert.Equal(t, test.expect, result, errMsg)
}
}
func TestRound(t *testing.T) {
t.Parallel()
ns := New()
for i, test := range []struct {
x interface{}
expect interface{}
}{
{0.1, 0.0},
{0.5, 1.0},
{1.1, 1.0},
{1.5, 2.0},
{-0.1, -0.0},
{-0.5, -1.0},
{-1.1, -1.0},
{-1.5, -2.0},
{"abc", false},
} {
errMsg := fmt.Sprintf("[%d] %v", i, test)
result, err := ns.Round(test.x)
if b, ok := test.expect.(bool); ok && !b {
require.Error(t, err, errMsg)
continue
}
require.NoError(t, err, errMsg)
assert.Equal(t, test.expect, result, errMsg)
}
}

61
tpl/math/round.go Normal file
View file

@ -0,0 +1,61 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// According to https://github.com/golang/go/issues/20100, the Go stdlib will
// include math.Round beginning with Go 1.10.
//
// The following implementation was taken from https://golang.org/cl/43652.
package math
import "math"
const (
mask = 0x7FF
shift = 64 - 11 - 1
bias = 1023
)
// 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
// }
const (
signMask = 1 << 63
fracMask = 1<<shift - 1
half = 1 << (shift - 1)
one = bias << shift
)
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 |= one // +-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.
e -= bias
bits += half >> e
bits &^= fracMask >> e
}
return math.Float64frombits(bits)
}