Update start and end based on clarified definitions

Author: cmoesel

examples/browser/cql4browsers.js

@@ -514,24 +514,36 @@ export class Interval {
 
   start() {
     if (this.low == null) {
-      if (this.lowClosed) {
-        return minValueForInstance(this.high);
+      const quantityInstance =
+        this.high && this.pointType == ELM_QUANTITY_TYPE ? this.high : undefined;
+      const minValue = minValueForType(this.pointType, quantityInstance);
+      if (this.lowClosed || minValue == null) {
+        return minValue;
       } else {
-        return this.low;
+        const end = ((end: any) => (end.isUncertainty ? end.high : end))(
+          this.high == null ? maxValueForType(this.pointType) : this.end()
+        );
+        return new Uncertainty(minValue, end);
       }
     }
-    return this.toClosed().low;
+    return this.lowClosed ? this.low : successor(this.low, this.pointType);
   }
 
   end() {
     if (this.high == null) {
-      if (this.highClosed) {
-        return maxValueForInstance(this.low);
+      const quantityInstance =
+        this.low && this.pointType == ELM_QUANTITY_TYPE ? this.low : undefined;
+      const maxValue = maxValueForType(this.pointType, quantityInstance);
+      if (this.highClosed || maxValue == null) {
+        return maxValue;
       } else {
-        return this.high;
+        const start = ((start: any) => (start.isUncertainty ? start.low : start))(
+          this.low == null ? minValueForType(this.pointType) : this.start()
+        );
+        return new Uncertainty(start, maxValue);
       }
     }
-    return this.toClosed().high;
+    return this.highClosed ? this.high : predecessor(this.high, this.pointType);
   }
 
   starts(other: any, precision?: any) {

src/datatypes/interval.ts

@@ -1,5 +1,11 @@
 import { ELM_DECIMAL_TYPE } from '../util/elmTypes';
-import { decimalAdjust, isValidDecimal, overflowsOrUnderflows } from '../util/math';
+import {
+  decimalAdjust,
+  isValidDecimal,
+  MIN_FLOAT_VALUE,
+  MAX_FLOAT_VALUE,
+  overflowsOrUnderflows
+} from '../util/math';
 import {
   checkUnit,
   convertUnit,
@@ -157,6 +163,11 @@ export class Quantity {
   }
 }
 
+// Require MIN/MAX here because math.js requires this file, and when we make this file require
+// math.js before it exports DateTime and Date, it errors due to the circular dependency...
+export const MIN_QUANTITY_VALUE = new Quantity(MIN_FLOAT_VALUE, '1');
+export const MAX_QUANTITY_VALUE = new Quantity(MAX_FLOAT_VALUE, '1');
+
 export function parseQuantity(str: string) {
   const components = /([+|-]?\d+\.?\d*)\s*('(.+)')?/.exec(str);
   if (components != null && components[1] != null) {

src/datatypes/quantity.ts

@@ -1,4 +1,4 @@
-import { Uncertainty } from '../datatypes/datatypes';
+import { Uncertainty } from '../datatypes/uncertainty';
 
 function areNumbers(a: any, b: any) {
   return typeof a === 'number' && typeof b === 'number';

src/util/comparison.ts

@@ -1,5 +1,5 @@
 import { Exception } from '../datatypes/exception';
-import { Quantity } from '../datatypes/quantity';
+import { Quantity, MIN_QUANTITY_VALUE, MAX_QUANTITY_VALUE } from '../datatypes/quantity';
 import {
   MIN_DATETIME_VALUE as dtMinDateTimeValue,
   MAX_DATETIME_VALUE as dtMaxDateTimeValue,
@@ -279,9 +279,14 @@ export function maxValueForInstance(val: any) {
   } else if (val && val.isDate) {
     return MAX_DATE_VALUE?.copy();
   } else if (val && val.isQuantity) {
-    const val2 = val.clone();
-    val2.value = maxValueForInstance(val2.value);
-    return val2;
+    // Although the spec says max Quantity has unit '1', it doesn't make sense to change the unit,
+    // especially if this is being used in the context of an interval or uncertainty since the
+    // left and right sides need to be comparable in those cases.
+    const maxQuantity = MAX_QUANTITY_VALUE.clone();
+    if (val.unit) {
+      maxQuantity.unit = val.unit;
+    }
+    return maxQuantity;
   } else {
     return null;
   }
@@ -302,13 +307,17 @@ export function maxValueForType(type: string, quantityInstance?: Quantity) {
     case ELM_TIME_TYPE:
       return MAX_TIME_VALUE?.copy();
     case ELM_QUANTITY_TYPE: {
+      // Although the spec says max Quantity has unit '1', it doesn't make sense to change the unit,
+      // especially if this is being used in the context of an interval or uncertainty since the
+      // left and right sides need to be comparable in those cases.
+      const maxQuantity = MAX_QUANTITY_VALUE.clone();
       if (quantityInstance == null) {
-        // can't infer a quantity unit type from nothing]
-        return null;
+        return maxQuantity;
+      }
+      if (quantityInstance.unit) {
+        maxQuantity.unit = quantityInstance.unit;
       }
-      const maxQty = quantityInstance.clone();
-      maxQty.value = MAX_FLOAT_VALUE;
-      return maxQty;
+      return maxQuantity;
     }
   }
   return null;
@@ -330,9 +339,14 @@ export function minValueForInstance(val: any) {
   } else if (val && val.isDate) {
     return MIN_DATE_VALUE?.copy();
   } else if (val && val.isQuantity) {
-    const val2 = val.clone();
-    val2.value = minValueForInstance(val2.value);
-    return val2;
+    // Although the spec says max Quantity has unit '1', it doesn't make sense to change the unit,
+    // especially if this is being used in the context of an interval or uncertainty since the
+    // left and right sides need to be comparable in those cases.
+    const minQuantity = MIN_QUANTITY_VALUE.clone();
+    if (val.unit) {
+      minQuantity.unit = val.unit;
+    }
+    return minQuantity;
   } else {
     return null;
   }
@@ -353,13 +367,17 @@ export function minValueForType(type: string, quantityInstance?: Quantity) {
     case ELM_TIME_TYPE:
       return MIN_TIME_VALUE?.copy();
     case ELM_QUANTITY_TYPE: {
+      // Although the spec says max Quantity has unit '1', it doesn't make sense to change the unit,
+      // especially if this is being used in the context of an interval or uncertainty since the
+      // left and right sides need to be comparable in those cases.
+      const minQuantity = MIN_QUANTITY_VALUE.clone();
       if (quantityInstance == null) {
-        // can't infer a quantity unit type from nothing]
-        return null;
+        return minQuantity;
+      }
+      if (quantityInstance.unit) {
+        minQuantity.unit = quantityInstance.unit;
       }
-      const minQty = quantityInstance.clone();
-      minQty.value = MIN_FLOAT_VALUE;
-      return minQty;
+      return minQuantity;
     }
   }
   return null;

src/util/math.ts

@@ -1,5 +1,6 @@
 import { Interval } from '../../src/datatypes/interval';
-import { DateTime } from '../../src/datatypes/datetime';
+import { DateTime, Date } from '../../src/datatypes/datetime';
+import { Quantity } from '../../src/datatypes/quantity';
 
 class TestDateTime {
   static parse(string: string) {
@@ -43,23 +44,33 @@ class TestInterval {
   toMinute: Interval;
   toSecond: Interval;
   toMillisecond: Interval;
+  withNullStart: TestInterval;
+  withNullEnd: TestInterval;
 
-  constructor(low: any, high: any) {
-    const [thLow, thHigh] = Array.from([
-      TestDateTime.fromDateTime(low),
-      TestDateTime.fromDateTime(high)
-    ]);
+  constructor(low: any, high: any, createNullVariants = true) {
     this.closed = new Interval(low, high, true, true);
     this.open = new Interval(low, high, false, false);
     this.closedOpen = new Interval(low, high, true, false);
     this.openClosed = new Interval(low, high, false, true);
-    this.toYear = new Interval(thLow.toYear, thHigh.toYear);
-    this.toMonth = new Interval(thLow.toMonth, thHigh.toMonth);
-    this.toDay = new Interval(thLow.toDay, thHigh.toDay);
-    this.toHour = new Interval(thLow.toHour, thHigh.toHour);
-    this.toMinute = new Interval(thLow.toMinute, thHigh.toMinute);
-    this.toSecond = new Interval(thLow.toSecond, thHigh.toSecond);
-    this.toMillisecond = new Interval(thLow.toMillisecond, thHigh.toMillisecond);
+
+    if (low != null && high != null) {
+      const [thLow, thHigh] = Array.from([
+        TestDateTime.fromDateTime(low),
+        TestDateTime.fromDateTime(high)
+      ]);
+      this.toYear = new Interval(thLow.toYear, thHigh.toYear);
+      this.toMonth = new Interval(thLow.toMonth, thHigh.toMonth);
+      this.toDay = new Interval(thLow.toDay, thHigh.toDay);
+      this.toHour = new Interval(thLow.toHour, thHigh.toHour);
+      this.toMinute = new Interval(thLow.toMinute, thHigh.toMinute);
+      this.toSecond = new Interval(thLow.toSecond, thHigh.toSecond);
+      this.toMillisecond = new Interval(thLow.toMillisecond, thHigh.toMillisecond);
+    }
+
+    if (createNullVariants) {
+      this.withNullStart = new TestInterval(null, high, false);
+      this.withNullEnd = new TestInterval(low, null, false);
+    }
   }
 }
 
@@ -94,6 +105,11 @@ export default () => {
   data['mid2012'] = TestDateTime.parse('2012-06-01T00:00:00.0');
   data['end2012'] = TestDateTime.parse('2012-12-31T23:59:59.999');
   data['aft2012'] = TestDateTime.parse('2013-06-01T00:00:00.0');
+  data['all2012date'] = new TestInterval(Date.parse('2012-01-01'), Date.parse('2012-12-31'));
+  data['alldaytime'] = new TestInterval(
+    DateTime.parse('0001-01-01T00:00:00.0').getTime(),
+    DateTime.parse('0001-01-01T23:59:59.999').getTime()
+  );
   data['dIvl'] = {
     sameAs: {
       //    |----------X----------|
@@ -276,5 +292,7 @@ export default () => {
       y: new TestInterval(0n, 100n)
     }
   };
+  data['zeroPointFiveToNinePointFive'] = new TestInterval(0.5, 9.5);
+  data['zeroToHundredMg'] = new TestInterval(new Quantity(0, 'mg'), new Quantity(100, 'mg'));
   return data;
 };