DS-704: Implement calculated streams support for Pow, Sqrt, Ln, Log, and Truncate. (#184)

Author: ro-tex

llo/stream_calculated.go

@@ -36,6 +36,10 @@ var (
 				"Add":                Add,
 				"Sum":                Add,
 				"Sub":                Sub,
+				"Pow":                Pow,
+				"Sqrt":               Sqrt,
+				"Ln":                 Ln,
+				"Log":                Log,
 				"IsZero":             IsZero,
 				"IsNegative":         IsNegative,
 				"IsPositive":         IsPositive,
@@ -67,6 +71,10 @@ var (
 		"Add":                true,
 		"Sum":                true,
 		"Sub":                true,
+		"Pow":                true,
+		"Sqrt":               true,
+		"Ln":                 true,
+		"Log":                true,
 		"IsZero":             true,
 		"IsNegative":         true,
 		"IsPositive":         true,
@@ -80,6 +88,15 @@ var (
 	}
 )
 
+const (
+	// precision defines the precision level for power calculations, representing the number of decimal places.
+	// See PowerWithPrecision at https://github.com/shopspring/decimal/blob/master/decimal.go#L798.
+	precision = 18
+	// doublePrecision is used when we intend to further modify the result and we don't want to suffer from rounding
+	// errors.
+	doublePrecision = 2 * precision
+)
+
 type environment map[string]any
 
 func (e environment) SetStreamValue(id llotypes.StreamID, value StreamValue) error {
@@ -328,6 +345,83 @@ func Sub(x, y any) (decimal.Decimal, error) {
 	return ad.Sub(bd), nil
 }
 
+// Pow returns x, raised to the power of y
+func Pow(x, y any) (decimal.Decimal, error) {
+	base, err := toDecimal(x)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	power, err := toDecimal(y)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	// We use double precision here in order to offset any float approximation errors.
+	res, err := base.PowWithPrecision(power, doublePrecision)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	return res.Round(precision), nil
+}
+
+// Sqrt returns the square root of x. Returns error for negative values.
+func Sqrt(x any) (decimal.Decimal, error) {
+	n, err := toDecimal(x)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	if n.IsNegative() {
+		return decimal.Decimal{}, fmt.Errorf("negative number")
+	}
+	sqrtPow, _ := toDecimal(0.5)
+	// We use double precision here in order to offset any float approximation errors.
+	res, err := n.PowWithPrecision(sqrtPow, doublePrecision)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	return res.Round(precision), nil
+}
+
+// Ln returns the natural logarithm of x.
+func Ln(x any) (decimal.Decimal, error) {
+	n, err := toDecimal(x)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	if n.IsZero() {
+		return decimal.Decimal{}, fmt.Errorf("cannot represent natural logarithm of 0")
+	}
+	return n.Ln(precision)
+}
+
+// Log returns the logarithms of y with base x. This is equivalent to log_x(y).
+//
+// We use this formula:
+//
+//	             ln(y)
+//	log_x(y)  =  ----
+//	             ln(x)
+func Log(x, y any) (decimal.Decimal, error) {
+	log, err := toDecimal(x)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	lnLog, err := log.Ln(doublePrecision) // double precision, since we're going to divide them
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+
+	base, err := toDecimal(y)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	lnBase, err := base.Ln(doublePrecision) // double precision, since we're going to divide them
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+
+	return lnBase.DivRound(lnLog, precision), nil
+}
+
 // IsZero returns true if x is zero
 func IsZero(x any) (bool, error) {
 	ad, err := toDecimal(x)
@@ -367,6 +461,15 @@ func Round(x any, precision int) (decimal.Decimal, error) {
 	return ad.Round(int32(precision)), nil
 }
 
+// Truncate truncates off digits from the number, without rounding.
+func Truncate(x any, precision int32) (decimal.Decimal, error) {
+	n, err := toDecimal(x)
+	if err != nil {
+		return decimal.Decimal{}, err
+	}
+	return n.Truncate(precision), nil
+}
+
 // Duration parses a duration string into a time.Duration
 func Duration(x string) (time.Duration, error) {
 	return time.ParseDuration(x)