Add dectest suite and regex parser

decimal64.go

@@ -134,6 +134,7 @@ func matchScales(exp1 int, significand1 uint64, exp2 int, significand2 uint64) (
 
 func newFromParts(sign int, exp int, significand uint64) Decimal64 {
 	s := uint64(sign) << 63
+
 	if significand < 0x8<<50 {
 		// s EEeeeeeeee   (0)ttt tttttttttt tttttttttt tttttttttt tttttttttt tttttttttt
 		//   EE ∈ {00, 01, 10}

decimal64_test.go

@@ -1,10 +1,9 @@
 package decimal
 
 import (
+	"github.com/stretchr/testify/require"
 	"math"
 	"testing"
-
-	"github.com/stretchr/testify/require"
 )
 
 func TestNew64FromInt64(t *testing.T) {

decimal64const.go

@@ -36,8 +36,17 @@ var inf64 uint64 = 0x78 << 56
 // 1E15
 const decimal64Base = 1000 * 1000 * 1000 * 1000 * 1000
 
+// Max significand possible (16 decimal places)
+const maxSig = decimal64Base*10 - 1
+
 const expOffset = 398
 const expMax = 369
 
+// Max64  is max number possible with Decimal64
+var Max64 = newFromParts(0, expMax, maxSig)
+
+// Min64 is minimum number that is subnormal possible with Decimal64
+var Min64 = newFromParts(0, -398, 1)
+
 var zeroes = []Decimal64{Zero64, NegZero64}
 var infinities = []Decimal64{Infinity64, NegInfinity64}

decimal64math.go

@@ -24,12 +24,17 @@ func (d Decimal64) Add(e Decimal64) Decimal64 {
 		}
 		return QNaN64
 	}
+	if significand1 == 0 && significand2 == 0 {
+		return Zero64
+	}
+
 	exp1, significand1, exp2, significand2 = matchScales(exp1, significand1, exp2, significand2)
+
 	if sign1 == sign2 {
 		significand := significand1 + significand2
-		if significand >= decimal64Base {
-			exp1++
-			significand /= 10
+		exp1, significand = renormalize(exp1, significand)
+		if significand > maxSig || exp1 > expMax {
+			return infinities[sign1]
 		}
 		return newFromParts(sign1, exp1, significand)
 	}
@@ -91,11 +96,10 @@ func (d Decimal64) Mul(e Decimal64) Decimal64 {
 
 	exp := exp1 + exp2 + 15
 	significand := umul64(significand1, significand2).div64(decimal64Base)
-	for significand.lo >= 10*decimal64Base {
-		exp++
-		significand.lo /= 10
+	exp, significand.lo = renormalize(exp, significand.lo)
+	if significand.lo > maxSig || exp > expMax {
+		return infinities[sign]
 	}
-
 	return newFromParts(sign, exp, significand.lo)
 }
 
@@ -133,12 +137,17 @@ func (d Decimal64) Quo(e Decimal64) Decimal64 {
 		return zeroes[sign]
 	}
 
+	if e == Zero64 || e == NegZero64 {
+		return infinities[sign1]
+	}
+
 	exp := exp1 - exp2 - 16
 	significand := umul64(10*decimal64Base, significand1).div64(significand2)
-	for significand.hi > 0 || significand.lo >= 10*decimal64Base {
-		exp++
-		significand = significand.divBy10()
+	exp, significand.lo = renormalize(exp, significand.lo)
+	if significand.lo > maxSig || exp > expMax {
+		return infinities[sign]
 	}
+
 	return newFromParts(sign, exp, significand.lo)
 }
 

decimal64math_test.go

@@ -379,3 +379,44 @@ func BenchmarkDecimal64Sub(b *testing.B) {
 		_ = x[i%len(x)].Sub(y[i%len(y)])
 	}
 }
+
+func TestAddOverflow(t *testing.T) {
+	require := require.New(t)
+
+	a := MustParseDecimal64("-9.999999999999999e384")
+	require.Equal(NegInfinity64, a.Sub(MustParseDecimal64("0.00000000000001e384")))
+	a = Max64
+	require.Equal(Infinity64, a.Add(MustParseDecimal64("0.000000000000001e384")))
+	require.Equal(a, a.Add(MustParseDecimal64("1")))
+	require.Equal(a, Zero64.Add(a))
+}
+
+func TestQuoOverflow(t *testing.T) {
+	require := require.New(t)
+
+	a := MustParseDecimal64("1e384")
+	require.Equal(Infinity64, a.Quo(MustParseDecimal64(".01")))
+	a = MustParseDecimal64("1e384")
+	require.Equal(NegInfinity64, a.Quo(MustParseDecimal64("-.01")))
+	a = MustParseDecimal64("-1e384")
+	require.Equal(NegInfinity64, a.Quo(MustParseDecimal64(".01")))
+	a = MustParseDecimal64("-1e384")
+	require.Equal(NegInfinity64, a.Quo(MustParseDecimal64("0")))
+	require.Equal(QNaN64, Zero64.Quo(Zero64))
+	require.Equal(Zero64, Zero64.Quo(MustParseDecimal64("100")))
+}
+
+func TestMul(t *testing.T) {
+	require := require.New(t)
+
+	a := MustParseDecimal64("1e384")
+	require.Equal(Infinity64, a.Mul(MustParseDecimal64("10")))
+	a = MustParseDecimal64("1e384")
+	require.Equal(NegInfinity64, a.Mul(MustParseDecimal64("-10")))
+	a = MustParseDecimal64("-1e384")
+	require.Equal(NegInfinity64, a.Mul(MustParseDecimal64("10")))
+	a = MustParseDecimal64("-1e384")
+	require.Equal(NegZero64, a.Mul(Zero64))
+	require.Equal(Zero64, Zero64.Mul(Zero64))
+	require.Equal(Zero64, Zero64.Mul(MustParseDecimal64("100")))
+}

decimalSuite_test.go

@@ -0,0 +1,138 @@
+package decimal
+
+import (
+	"fmt"
+	"io/ioutil"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// master tester for the suite
+func TestFromSuite(t *testing.T) {
+	// require := require.New(t)
+	testVals, testNames := getInput("dectest/ddAdd.decTest")
+
+	var testName string
+	var TestResult string
+	var TestPass bool
+	var testVal1, testVal2, testAns Decimal64
+	var parseResult string
+
+	for i := range testNames {
+		testName = testNames[i]
+		testVal1, testVal2, testAns, parseResult = convertToDec64(testVals[testName], testName)
+		TestPass, TestResult = doTests(testVal1, testVal2, testAns, testVals[testName]["TestFunc"])
+		if TestPass == false {
+			fmt.Printf("%s: \n %s\n %s\n", testName, TestResult, parseResult)
+		}
+	}
+
+}
+
+// func TestNew(t *testing.T) {
+// 	// require := require.New(t)
+// 	// // propper rounding
+// 	// require.Equal(MustParseDecimal64("4444444444444445"), MustParseDecimal64("4444444444444444").Add(MustParseDecimal64("0.5001")))
+// 	// require.Equal(MustParseDecimal64("0.23"), MustParseDecimal64("1.3").Add(MustParseDecimal64("-1.07")))
+// 	// fmt.Println("sjoidgf", MustParseDecimal64("4444444444444444").Add(MustParseDecimal64("1.5001")))
+// 	// // require.Equal(MustParseDecimal64("12345678901234.29"), MustParseDecimal64("12345678901234").Add(MustParseDecimal64("0.2951")))
+//
+// }
+
+//getInput gets the test file and extracts test using regex, then returns a map object and a list of test names
+func getInput(file string) (map[string]map[string]string, []string) {
+	dat, _ := ioutil.ReadFile("dectest/ddAdd.decTest")
+	dataString := string(dat)
+	//  "(\n|\r)") // start with newline
+	//  "(?P<TestName>dd[\w]*)") // TestName must start with dd (double decimal)
+	//  "(?P<TestFunc>[\S]*)") // testfunc made of anything that isn't a whitespace
+	//  "(\s*\'?)") // after can be any number of spaces and quotations if they exist
+	// "(?P<TestVals_1>(\+|-)*[^\r\n\t\f\v\' ]*)") // first test val is anything that isnt a whitespace or a quoteation mark
+	//  "(?P<TestVals_1>(\+|-)*[^\r\n\t\f\v\' ]*)") // first test val is anything that isnt a whitespace or a quoteation mark
+	// ('?\s*'?) match any quotation marks and any spaces
+	// (?P<TestVals_2>(\+|-[^->])?[^\r\n\t\f\v\' ]*) testvals2 same as 1 but no '->'
+	// ('?\s*->\s*'?) matches the indicator to answer
+	// (?P<answer>(\+|-)*[^\r\n\t\f\v\' ]*) matches the answer that's anything that is plus minus but not quotations
+
+	// split into groups: testName, TestFunct, TestVals (x2) and TestAns
+	regex := `(\n|\r)(?P<TestName>dd[\w]*)(\s*)(?P<TestFunc>[\S]*)(\s*\'?)(?P<TestVals_1>(\+|-)*[^\r\n\t\f\v\' ]*)('?\s*'?)(?P<TestVals_2>(\+|-[^->])?[^\r\n\t\f\v\' ]*)('?\s*->\s*'?)(?P<answer>(\+|-)*[^\r\n\t\f\v\' ]*)`
+	r := regexp.MustCompile(regex)
+	ans := r.FindAllStringSubmatch(dataString, -1)
+	testList := []string{}
+	var data = map[string]map[string]string{}
+
+	for i := 0; i < len(ans); i++ {
+		data[ans[i][2]] = make(map[string]string)
+		data[ans[i][2]]["TestFunc"] = ans[i][4]
+		data[ans[i][2]]["TestVal1"] = ans[i][6]
+		data[ans[i][2]]["TestVal2"] = ans[i][9]
+		data[ans[i][2]]["TestAns"] = ans[i][12]
+		testList = append(testList, ans[i][2])
+
+	}
+	return data, testList
+
+}
+
+//convertToDec64 converts the map object strings to decimal64s
+func convertToDec64(testVals map[string]string, testName string) (testVal1, testVal2, testAns Decimal64, parseErr string) {
+	var err1, err2, err3 error
+	// var TestResult []string
+
+	testVal1, err1 = ParseDecimal64(testVals["TestVal1"])
+	testAns, err3 = ParseDecimal64(testVals["TestAns"])
+
+	testVal2, err2 = ParseDecimal64(testVals["TestVal2"])
+	parseErr = checkErrors(err1, err2, err3, testVals)
+
+	return
+}
+
+//checkErrors checks to see if there are any string parsing errors
+func checkErrors(err1, err2, err3 error, testVals map[string]string) (errReturn string) {
+	var errReturnSlice []string
+	if err2 != nil {
+		errReturnSlice = append(errReturnSlice, fmt.Sprintf("error parsing input of value: %s \n", testVals["TestVal2"]))
+	}
+	if err1 != nil {
+		errReturnSlice = append(errReturnSlice, fmt.Sprintf("error parsing input of value: %s \n", testVals["TestVal1"]))
+	}
+
+	if err3 != nil {
+		errReturnSlice = append(errReturnSlice, fmt.Sprintf("error parsing input of value: %s \n", testVals["TestAns"]))
+	}
+	return strings.Join(errReturnSlice, "")
+}
+
+//doTests completes the tests and returns a boolean and string on if the test passes
+func doTests(testVal1, testVal2, testAns Decimal64, testfunc string) (testStatus bool, testString string) {
+
+	fmt.Println()
+	switch testfunc {
+	case "add":
+		testString = fmt.Sprintf("%v + %v != %v \n(expected %v)", testVal1, testVal2, testVal1.Add(testVal2), testAns)
+		testStatus = testAns == testVal1.Add(testVal2)
+		return
+	case "abs":
+
+		testStatus = testAns == testVal1.Abs()
+		return
+	case "divide":
+
+		testStatus = testAns == testVal1.Quo(testVal2)
+		return
+	case "minus":
+
+		testStatus = testAns == testVal1.Sub(testVal2)
+		return
+	case "multiply":
+		testString = fmt.Sprintf("%v * %v != %v (expected %v)", testVal1, testVal2, testVal1.Mul(testVal2), testAns)
+		testStatus = testAns == testVal1.Mul(testVal2)
+		return
+	default:
+		testStatus = false
+		return
+	}
+
+}