Merge pull request #106 from vfrank66:issue-105/add-ucum-conversion-support

PiperOrigin-RevId: 765392994

Author: copybara-github

README.md

@@ -57,7 +57,6 @@ Language:
 - No support for related context retrieves
 - No support for uncertainties
 - No support for importing or exporting ELM
-- No support for Quantity unit conversion
 
 ## Getting Started
 

interpreter/operator_arithmetic.go

@@ -24,6 +24,7 @@ import (
 	"github.com/google/cql/model"
 	"github.com/google/cql/result"
 	"github.com/google/cql/types"
+	"github.com/google/cql/ucum"
 )
 
 // ARITHMETIC OPERATORS - https://cql.hl7.org/09-b-cqlreference.html#arithmetic-operators-4
@@ -461,31 +462,61 @@ func bigIntPow(l, r int64) any {
 	return bigResult.Int64()
 }
 
-// TODO(b/319156186): Add support for converting quantities between different units.
-// TODO(b/319333058): Add support for Date + Quantity arithmetic.
-// TODO(b/319525986): Add support for additional arithmetic for Quantities.
+// Arithmetic operations for Quantity values.
+// Has support for conversion between units.
 func arithmeticQuantity(m model.IBinaryExpression, l, r result.Quantity) (result.Value, error) {
-	if l.Unit != r.Unit {
-		return result.Value{}, fmt.Errorf("internal error - quantity unit conversion unsupported, got units: %s and %s", l.Unit, r.Unit)
-	}
 	switch m.(type) {
-	case *model.Add:
-		return result.New(result.Quantity{Value: l.Value + r.Value, Unit: l.Unit})
-	case *model.Subtract:
+	case *model.Add, *model.Subtract:
+		// For addition and subtraction, convert the right operand to the left's unit if needed.
+		if l.Unit != r.Unit {
+			convertedVal, err := ucum.ConvertUnit(r.Value, string(r.Unit), string(l.Unit))
+			if err != nil {
+				return result.Value{}, fmt.Errorf("cannot convert between units: %s and %s: %v", r.Unit, l.Unit, err)
+			}
+			r.Value = convertedVal
+			r.Unit = l.Unit
+		}
+
+		// Now perform the operation with matching units
+		if m.GetName() == "Add" {
+			return result.New(result.Quantity{Value: l.Value + r.Value, Unit: l.Unit})
+		}
 		return result.New(result.Quantity{Value: l.Value - r.Value, Unit: l.Unit})
 	case *model.Multiply:
-		return result.Value{}, fmt.Errorf("internal error - quantity multiplication unsupported, got: %v and %v", l, r)
+		resultUnit := ucum.GetProductOfUnits(string(l.Unit), string(r.Unit))
+		return result.New(result.Quantity{Value: l.Value * r.Value, Unit: model.Unit(resultUnit)})
 	case *model.TruncatedDivide:
-		return result.New(result.Quantity{Value: float64(int64(l.Value / r.Value)), Unit: model.ONEUNIT})
+		if r.Value == 0 {
+			return result.New(nil)
+		}
+		// Otherwise, the result unit is the quotient of the units
+		resultUnit := ucum.GetQuotientOfUnits(string(l.Unit), string(r.Unit))
+		return result.New(result.Quantity{Value: float64(int64(l.Value / r.Value)), Unit: model.Unit(resultUnit)})
+
 	case *model.Divide:
-		return result.New(result.Quantity{Value: l.Value / r.Value, Unit: model.ONEUNIT})
-	case *model.Modulo:
-		if l.Unit != r.Unit {
-			return result.Value{}, fmt.Errorf("internal error - quantity modulo with different units unsupported, got units: %s and %s", l.Unit, r.Unit)
+		if r.Value == 0 {
+			return result.New(nil)
 		}
+		// For division, the result unit is dimensionless "1" if units are the same.
+		if l.Unit == r.Unit {
+			return result.New(result.Quantity{Value: l.Value / r.Value, Unit: model.ONEUNIT})
+		}
+		// Otherwise, the result unit is the quotient of the units
+		resultUnit := ucum.GetQuotientOfUnits(string(l.Unit), string(r.Unit))
+		return result.New(result.Quantity{Value: l.Value / r.Value, Unit: model.Unit(resultUnit)})
+	case *model.Modulo:
 		if r.Value == 0 {
 			return result.New(nil)
 		}
+		// For modulo, units must match or be convertible
+		if l.Unit != r.Unit {
+			// Try to convert r to l's unit
+			convertedVal, err := ucum.ConvertUnit(r.Value, string(r.Unit), string(l.Unit))
+			if err != nil {
+				return result.New(nil)
+			}
+			r.Value = convertedVal
+		}
 		return result.New(result.Quantity{Value: math.Mod(l.Value, r.Value), Unit: l.Unit})
 	}
 	return result.Value{}, fmt.Errorf("internal error - unsupported Binary Arithmetic Expression %v", m)

interpreter/operator_comparison.go

@@ -18,13 +18,16 @@ import (
 	"cmp"
 	"errors"
 	"fmt"
+	"math"
+	"strconv"
 	"strings"
 	"unicode"
 
 	"github.com/google/cql/internal/convert"
 	"github.com/google/cql/model"
 	"github.com/google/cql/result"
 	"github.com/google/cql/types"
+	"github.com/google/cql/ucum"
 )
 
 // COMPARISON OPERATORS - https://cql.hl7.org/09-b-cqlreference.html#comparison-operators-4
@@ -36,9 +39,51 @@ func (i *interpreter) evalEqual(_ model.IBinaryExpression, lObj, rObj result.Val
 	if result.IsNull(lObj) || result.IsNull(rObj) {
 		return result.New(nil)
 	}
+
+	// Special handling for Quantity types with different units
+	_, lIsQuantity := lObj.GolangValue().(result.Quantity)
+	_, rIsQuantity := rObj.GolangValue().(result.Quantity)
+	if lIsQuantity && rIsQuantity {
+		return evalEqualQuantity(nil, lObj, rObj)
+	}
+
 	return result.New(lObj.Equal(rObj))
 }
 
+// =(left Quantity, right Quantity) Boolean
+// https://cql.hl7.org/09-b-cqlreference.html#equal
+// If either unit is invalid, returns null.
+func evalEqualQuantity(_ model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
+	if result.IsNull(lObj) || result.IsNull(rObj) {
+		return result.New(nil)
+	}
+	l, r, err := applyToValues(lObj, rObj, result.ToQuantity)
+	if err != nil {
+		return result.Value{}, err
+	}
+	// If units are the same, compare values directly
+	if l.Unit == r.Unit {
+		return result.New(l.Value == r.Value)
+	}
+
+	// If units are different, try to convert
+	fromVal := l.Value
+	fromUnit := string(l.Unit)
+	toUnit := string(r.Unit)
+
+	// Try to convert left value to right unit for comparison.
+	// It's not clear if this should return null for all failures here, for incompatible DateTime
+	// unites this is true, but for other units it may not be.
+	convertedVal, err := ucum.ConvertUnit(fromVal, fromUnit, toUnit)
+	if err != nil {
+		return result.New(nil)
+	}
+
+	// Compare with converted value using epsilon comparison for floating point values.
+	const epsilon = 1e-10
+	return result.New(math.Abs(convertedVal-r.Value) < epsilon)
+}
+
 // =(left DateTime, right DateTime) Boolean
 // =(left Date, right Date) Boolean
 // https://cql.hl7.org/09-b-cqlreference.html#equal
@@ -183,6 +228,33 @@ func (i *interpreter) evalEquivalentList(_ model.IBinaryExpression, lObj, rObj r
 	return result.New(true)
 }
 
+// getDecimalPrecision returns the number of significant digits after the decimal point.
+// It trims trailing zeros according to the CQL specification.
+func getDecimalPrecision(value float64) int {
+	// Convert to string to determine precision.
+	str := strconv.FormatFloat(value, 'f', -1, 64)
+
+	// Find the decimal point.
+	decimalPos := strings.IndexRune(str, '.')
+	if decimalPos == -1 {
+		return 0
+	}
+
+	// Extract the decimal part and trim trailing zeros.
+	decimalPart := strings.TrimRight(str[decimalPos+1:], "0")
+	return len(decimalPart)
+}
+
+// roundToDecimalPlaces rounds a float64 to the specified number of decimal places.
+func roundToDecimalPlaces(num float64, places int) float64 {
+	if places <= 0 {
+		return math.Round(num)
+	}
+
+	factor := math.Pow(10, float64(places))
+	return math.Round(num*factor) / factor
+}
+
 // ~(left String, right String) Boolean
 // https://cql.hl7.org/09-b-cqlreference.html#equivalent
 func evalEquivalentString(_ model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
@@ -213,6 +285,41 @@ func equivalentString(input string) string {
 	return out.String()
 }
 
+// ~(left Quantity, right Quantity) Boolean
+// https://cql.hl7.org/09-b-cqlreference.html#equivalent
+func evalEquivalentQuantity(_ model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
+	if result.IsNull(lObj) && result.IsNull(rObj) {
+		return result.New(true)
+	}
+	if result.IsNull(lObj) != result.IsNull(rObj) {
+		return result.New(false)
+	}
+
+	l, r, err := applyToValues(lObj, rObj, result.ToQuantity)
+	if err != nil {
+		return result.Value{}, err
+	}
+
+	// If units are the same, compare values directly.
+	if l.Unit == r.Unit {
+		return result.New(l.Value == r.Value)
+	}
+
+	// Try to convert l to r's unit for comparison.
+	fromVal := l.Value
+	fromUnit := string(l.Unit)
+	toUnit := string(r.Unit)
+
+	// Convert left value to right unit.
+	convertedVal, err := ucum.ConvertUnit(fromVal, fromUnit, toUnit)
+	if err != nil {
+		return result.New(nil)
+	}
+	// Compare with converted value using epsilon comparison.
+	const epsilon = 1e-10
+	return result.New(math.Abs(convertedVal-r.Value) < epsilon)
+}
+
 // ~(left Interval<T>, right Interval<T>) Boolean
 // https://cql.hl7.org/09-b-cqlreference.html#equivalent-1
 func (i *interpreter) evalEquivalentInterval(_ model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
@@ -457,3 +564,37 @@ func compare[n cmp.Ordered](m model.IBinaryExpression, l, r n) (result.Value, er
 	}
 	return result.Value{}, fmt.Errorf("internal error - unsupported Binary Comparison Expression %v", m)
 }
+
+// op(left Quantity, right Quantity) Boolean
+// https://cql.hl7.org/09-b-cqlreference.html#less
+// https://cql.hl7.org/09-b-cqlreference.html#less-or-equal
+// https://cql.hl7.org/09-b-cqlreference.html#greater
+// https://cql.hl7.org/09-b-cqlreference.html#greater-or-equal
+func evalCompareQuantity(m model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
+	if result.IsNull(lObj) || result.IsNull(rObj) {
+		return result.New(nil)
+	}
+
+	l, r, err := applyToValues(lObj, rObj, result.ToQuantity)
+	if err != nil {
+		return result.Value{}, err
+	}
+
+	// If units are the same, compare values directly.
+	// In the future we should calculate the smaller unit instead.
+	if l.Unit == r.Unit {
+		return compare(m, l.Value, r.Value)
+	}
+
+	// If units are different, try to convert.
+	fromVal := l.Value
+	fromUnit := string(l.Unit)
+	toUnit := string(r.Unit)
+
+	// Try to convert left value to right unit for comparison.
+	convertedVal, err := ucum.ConvertUnit(fromVal, fromUnit, toUnit)
+	if err != nil {
+		return result.New(nil)
+	}
+	return compare(m, convertedVal, r.Value)
+}

interpreter/operator_datetime.go

@@ -23,6 +23,7 @@ import (
 	"github.com/google/cql/model"
 	"github.com/google/cql/result"
 	"github.com/google/cql/types"
+	"github.com/google/cql/ucum"
 )
 
 // DATETIME OPERATORS - https://cql.hl7.org/09-b-cqlreference.html#datetime-operators-2
@@ -282,13 +283,22 @@ func beforeOrEqualDateTimeWithPrecision(l, r result.DateTime, p model.DateTimePr
 // CanConvertQuantity(left Quantity, right String) Boolean
 // https://cql.hl7.org/09-b-cqlreference.html#canconvertquantity
 // Returns whether or not a Quantity can be converted into the given unit string.
-// This is not a required function to implement, and for the time being we are
-// choosing to not implement unit conversion so this function always returns false.
 func evalCanConvertQuantity(b model.IBinaryExpression, lObj, rObj result.Value) (result.Value, error) {
 	if result.IsNull(lObj) || result.IsNull(rObj) {
 		return result.New(nil)
 	}
-	return result.New(false)
+	l, err := result.ToQuantity(lObj)
+	if err != nil {
+		return result.Value{}, err
+	}
+	r, err := result.ToString(rObj)
+	if err != nil {
+		return result.Value{}, err
+	}
+	if _, err := ucum.ConvertUnit(l.Value, string(l.Unit), r); err != nil {
+		return result.New(false)
+	}
+	return result.New(true)
 }
 
 // difference in _precision_ between(left Date, right Date) Integer

interpreter/operator_dispatcher.go

@@ -919,6 +919,14 @@ func (i *interpreter) binaryOverloads(m model.IBinaryExpression) ([]convert.Over
 				Operands: []types.IType{types.Long, types.Long},
 				Result:   evalEquivalentSimpleType,
 			},
+			{
+				Operands: []types.IType{types.Decimal, types.Decimal},
+				Result:   evalEquivalentSimpleType,
+			},
+			{
+				Operands: []types.IType{types.Quantity, types.Quantity},
+				Result:   evalEquivalentQuantity,
+			},
 			{
 				Operands: []types.IType{types.String, types.String},
 				Result:   evalEquivalentString,
@@ -976,6 +984,10 @@ func (i *interpreter) binaryOverloads(m model.IBinaryExpression) ([]convert.Over
 				Operands: []types.IType{types.DateTime, types.DateTime},
 				Result:   evalCompareDateTime,
 			},
+			{
+				Operands: []types.IType{types.Quantity, types.Quantity},
+				Result:   evalCompareQuantity,
+			},
 		}, nil
 	case *model.After, *model.Before, *model.SameOrAfter, *model.SameOrBefore:
 		return []convert.Overload[evalBinarySignature]{
@@ -1022,6 +1034,13 @@ func (i *interpreter) binaryOverloads(m model.IBinaryExpression) ([]convert.Over
 				Result:   evalCanConvertQuantity,
 			},
 		}, nil
+	case *model.ConvertQuantity:
+		return []convert.Overload[evalBinarySignature]{
+			{
+				Operands: []types.IType{types.Quantity, types.String},
+				Result:   evalConvertQuantity,
+			},
+		}, nil
 	case *model.DifferenceBetween:
 		return []convert.Overload[evalBinarySignature]{
 			{