feat: add ln and log (#12)

* add Ln and Log

Author: seborama

README.md

@@ -102,7 +102,8 @@ n := args[0].(gal.Numberer).Number()
 or, for additional type safety:
 
 ```go
-if value, ok := args[0].(gal.Numberer); !ok {
+value, ok := args[0].(gal.Numberer)
+if !ok {
     return gal.NewUndefinedWithReasonf("NaN '%s'", args[0])
 }
 n := value.Number()
@@ -125,7 +126,7 @@ Escapes are supported:
 
 ## Bools
 
-In additional to boolean expressions, sepcial contants `True` and `False` may be used.
+In addition to boolean expressions, sepcial contants `True` and `False` may be used.
 
 Do not double-quote them, or they will become plain strings!
 
@@ -143,7 +144,7 @@ Do not double-quote them, or they will become plain strings!
         * Go classifies bit shift operators with the higher `*`.
         * `&&` is synonymous of `And`.
         * `||` is synonymous of `Or`.
-* Types: String, Number, Bool
+* Types: String, Number, Bool, MultiValue
 * Associativity with parentheses: `(` and `)`
 * Functions:
     * Built-in: pi, cos, floor, sin, sqrt, trunc, and more (see `function.go`: `Eval()`)
@@ -156,7 +157,7 @@ A function is defined as a Go type: `type FunctionalValue func(...Value) Value`
 
 Function names are case-insensitive.
 
-A function can optionally accept one or more **space-separated** arguments, but it must return a single `Value`.
+A **function** can optionally accept one or more **space-separated arguments**, but it must return a single `Value`.
 
 It should be noted that a `MultiValue` type is available that can hold multiple `Value` elements. A function can use `MultiValue` as its return type to effectively return multiple `Value`'s. Of course, as `MultiValue` is a `Value` type, functions can also accept it as part of their argument(s). Refer to the test `TestMultiValueFunctions`, for an example.
 

function.go

@@ -62,6 +62,8 @@ var builtInFunctions = map[string]FunctionalValue{
 	"sqrt":      Sqrt,
 	"floor":     Floor,
 	"trunc":     Trunc,
+	"ln":        Ln,
+	"log":       Log,
 }
 
 // BuiltInFunction returns a built-in function body if known.
@@ -162,6 +164,36 @@ func Tan(args ...Value) Value {
 	return NewUndefinedWithReasonf("tan(): invalid argument type '%s'", args[0].String())
 }
 
+// Ln returns the natural logarithm of d.
+func Ln(args ...Value) Value {
+	if len(args) != 2 {
+		return NewUndefinedWithReasonf("ln() requires 2 arguments, got %d", len(args))
+	}
+
+	if v, ok := args[0].(Numberer); ok {
+		if p, ok := args[1].(Numberer); ok {
+			return v.Number().Ln(int32(p.Number().value.IntPart()))
+		}
+	}
+
+	return NewUndefinedWithReasonf("ln(): invalid argument type '%s'", args[0].String())
+}
+
+// Log returns the logarithm base 10 of d.
+func Log(args ...Value) Value {
+	if len(args) != 2 {
+		return NewUndefinedWithReasonf("log() requires 2 arguments, got %d", len(args))
+	}
+
+	if v, ok := args[0].(Numberer); ok {
+		if p, ok := args[1].(Numberer); ok {
+			return v.Number().Log(int32(p.Number().value.IntPart()))
+		}
+	}
+
+	return NewUndefinedWithReasonf("log(): invalid argument type '%s'", args[0].String())
+}
+
 // Sqrt returns the square root.
 func Sqrt(args ...Value) Value {
 	if len(args) != 1 {

function_test.go

@@ -28,6 +28,9 @@ func TestFactorial(t *testing.T) {
 
 	val = gal.Factorial(gal.NewNumber(10))
 	assert.Equal(t, gal.NewNumber(3_628_800).String(), val.String())
+
+	val = gal.Factorial(gal.NewNumber(-10))
+	assert.Equal(t, "undefined: Factorial: requires a positive integer, cannot accept -10", val.String())
 }
 
 func TestCos(t *testing.T) {
@@ -54,3 +57,19 @@ func TestFloor(t *testing.T) {
 	val := gal.Floor(gal.NewNumberFromFloat(0.0))
 	assert.Equal(t, int64(0), gal.ToNumber(val).Int64())
 }
+
+func TestLn(t *testing.T) {
+	val := gal.Ln(gal.NewNumber(123456), gal.NewNumber(5))
+	assert.Equal(t, "11.72364", val.String())
+
+	val = gal.Ln(gal.NewNumber(-123456), gal.NewNumber(5))
+	assert.Equal(t, "undefined: Ln:cannot calculate natural logarithm for negative decimals", val.String())
+}
+
+func TestLog(t *testing.T) {
+	val := gal.Log(gal.NewNumber(123456), gal.NewNumber(5))
+	assert.Equal(t, "5.09152", val.String())
+
+	val = gal.Log(gal.NewNumber(-123456), gal.NewNumber(5))
+	assert.Equal(t, "undefined: Log:cannot calculate natural logarithm for negative decimals", val.String())
+}

value.go

@@ -158,7 +158,6 @@ func (s String) Add(other Value) Value {
 
 func (s String) Multiply(other Value) Value {
 	if v, ok := other.(Numberer); ok {
-		// TODO: additionally, we could try and create a number from String / Bool to increase flexibility
 		return String{
 			value: strings.Repeat(s.value, int(v.Number().value.IntPart())),
 		}
@@ -343,12 +342,12 @@ func (n Number) Cos() Number {
 	}
 }
 
-func (n Number) Sqrt() Number {
+func (n Number) Sqrt() Value {
 	n, err := NewNumberFromString(
 		new(big.Float).Sqrt(n.value.BigFloat()).String(),
 	)
 	if err != nil {
-		panic(err) // TODO: :-/ - Maybe `Sqrt() Value` and here return Undefined{} instead??
+		return NewUndefinedWithReasonf("Sqrt:" + err.Error())
 	}
 
 	return n
@@ -360,6 +359,33 @@ func (n Number) Tan() Number {
 	}
 }
 
+func (n Number) Ln(precision int32) Value {
+	res, err := n.value.Ln(precision)
+	if err != nil {
+		return NewUndefinedWithReasonf("Ln:" + err.Error())
+	}
+
+	return Number{
+		value: res,
+	}
+}
+
+func (n Number) Log(precision int32) Value {
+	res1, err := n.value.Ln(precision)
+	if err != nil {
+		return NewUndefinedWithReasonf("Log:" + err.Error())
+	}
+
+	res10, err := decimal.New(10, 0).Ln(precision)
+	if err != nil {
+		return NewUndefinedWithReasonf("Log:" + err.Error())
+	}
+
+	return Number{
+		value: res1.Div(res10).Truncate(precision),
+	}
+}
+
 func (n Number) Floor() Number {
 	return Number{
 		value: n.value.Floor(),
@@ -372,9 +398,9 @@ func (n Number) Trunc(precision int32) Number {
 	}
 }
 
-func (n Number) Factorial() Number {
+func (n Number) Factorial() Value {
 	if !n.value.IsInteger() || n.value.IsNegative() {
-		panic(fmt.Sprintf("invalid calculation: Factorial requires a positive integer, cannot accept %s", n.String())) // TODO :-/
+		return NewUndefinedWithReasonf(fmt.Sprintf("Factorial: requires a positive integer, cannot accept %s", n.String()))
 	}
 
 	res := decimal.NewFromInt(1)