@phema/cql-execution/lib/elm/aggregate.js

An execution framework for the Clinical Quality Language (CQL)

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

var _require = require('./expression'),
    Expression = _require.Expression;

var _require2 = require('../util/util'),
    typeIsArray = _require2.typeIsArray,
    allTrue = _require2.allTrue,
    anyTrue = _require2.anyTrue,
    removeNulls = _require2.removeNulls,
    numerical_sort = _require2.numerical_sort;

var _require3 = require('./builder'),
    build = _require3.build;

var _require4 = require('../datatypes/exception'),
    Exception = _require4.Exception;

var _require5 = require('../util/comparison'),
    greaterThan = _require5.greaterThan,
    lessThan = _require5.lessThan;

var _require6 = require('../datatypes/quantity'),
    Quantity = _require6.Quantity;

var AggregateExpression = /*#__PURE__*/function (_Expression) {
  _inherits(AggregateExpression, _Expression);

  var _super = _createSuper(AggregateExpression);

  function AggregateExpression(json) {
    var _this;

    _classCallCheck(this, AggregateExpression);

    _this = _super.call(this, json);
    _this.source = build(json.source);
    return _this;
  }

  return AggregateExpression;
}(Expression);

var Count = /*#__PURE__*/function (_AggregateExpression) {
  _inherits(Count, _AggregateExpression);

  var _super2 = _createSuper(Count);

  function Count(json) {
    _classCallCheck(this, Count);

    return _super2.call(this, json);
  }

  _createClass(Count, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (typeIsArray(items)) {
        return removeNulls(items).length;
      }

      return 0;
    }
  }]);

  return Count;
}(AggregateExpression);

var Sum = /*#__PURE__*/function (_AggregateExpression2) {
  _inherits(Sum, _AggregateExpression2);

  var _super3 = _createSuper(Sum);

  function Sum(json) {
    _classCallCheck(this, Sum);

    return _super3.call(this, json);
  }

  _createClass(Sum, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      try {
        items = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      if (hasOnlyQuantities(items)) {
        var values = getValuesFromQuantities(items);
        var sum = values.reduce(function (x, y) {
          return x + y;
        });
        return new Quantity(sum, items[0].unit);
      } else {
        return items.reduce(function (x, y) {
          return x + y;
        });
      }
    }
  }]);

  return Sum;
}(AggregateExpression);

var Min = /*#__PURE__*/function (_AggregateExpression3) {
  _inherits(Min, _AggregateExpression3);

  var _super4 = _createSuper(Min);

  function Min(json) {
    _classCallCheck(this, Min);

    return _super4.call(this, json);
  }

  _createClass(Min, [{
    key: "exec",
    value: function exec(ctx) {
      var list = this.source.execute(ctx);

      if (list == null) {
        return null;
      }

      var listWithoutNulls = removeNulls(list); // Check for incompatible units and return null. We don't want to convert
      // the units for Min/Max, so we throw away the converted array if it succeeds

      try {
        processQuantities(list);
      } catch (e) {
        return null;
      }

      if (listWithoutNulls.length === 0) {
        return null;
      } // We assume the list is an array of all the same type.


      var minimum = listWithoutNulls[0];

      var _iterator = _createForOfIteratorHelper(listWithoutNulls),
          _step;

      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var element = _step.value;

          if (lessThan(element, minimum)) {
            minimum = element;
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }

      return minimum;
    }
  }]);

  return Min;
}(AggregateExpression);

var Max = /*#__PURE__*/function (_AggregateExpression4) {
  _inherits(Max, _AggregateExpression4);

  var _super5 = _createSuper(Max);

  function Max(json) {
    _classCallCheck(this, Max);

    return _super5.call(this, json);
  }

  _createClass(Max, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (items == null) {
        return null;
      }

      var listWithoutNulls = removeNulls(items); // Check for incompatible units and return null. We don't want to convert
      // the units for Min/Max, so we throw away the converted array if it succeeds

      try {
        processQuantities(items);
      } catch (e) {
        return null;
      }

      if (listWithoutNulls.length === 0) {
        return null;
      } // We assume the list is an array of all the same type.


      var maximum = listWithoutNulls[0];

      var _iterator2 = _createForOfIteratorHelper(listWithoutNulls),
          _step2;

      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var element = _step2.value;

          if (greaterThan(element, maximum)) {
            maximum = element;
          }
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }

      return maximum;
    }
  }]);

  return Max;
}(AggregateExpression);

var Avg = /*#__PURE__*/function (_AggregateExpression5) {
  _inherits(Avg, _AggregateExpression5);

  var _super6 = _createSuper(Avg);

  function Avg(json) {
    _classCallCheck(this, Avg);

    return _super6.call(this, json);
  }

  _createClass(Avg, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      try {
        items = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      if (hasOnlyQuantities(items)) {
        var values = getValuesFromQuantities(items);
        var sum = values.reduce(function (x, y) {
          return x + y;
        });
        return new Quantity(sum / values.length, items[0].unit);
      } else {
        var _sum = items.reduce(function (x, y) {
          return x + y;
        });

        return _sum / items.length;
      }
    }
  }]);

  return Avg;
}(AggregateExpression);

var Median = /*#__PURE__*/function (_AggregateExpression6) {
  _inherits(Median, _AggregateExpression6);

  var _super7 = _createSuper(Median);

  function Median(json) {
    _classCallCheck(this, Median);

    return _super7.call(this, json);
  }

  _createClass(Median, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      try {
        items = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (!hasOnlyQuantities(items)) {
        return medianOfNumbers(items);
      }

      var values = getValuesFromQuantities(items);
      var median = medianOfNumbers(values);
      return new Quantity(median, items[0].unit);
    }
  }]);

  return Median;
}(AggregateExpression);

var Mode = /*#__PURE__*/function (_AggregateExpression7) {
  _inherits(Mode, _AggregateExpression7);

  var _super8 = _createSuper(Mode);

  function Mode(json) {
    _classCallCheck(this, Mode);

    return _super8.call(this, json);
  }

  _createClass(Mode, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      var filtered;

      try {
        filtered = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (hasOnlyQuantities(filtered)) {
        var values = getValuesFromQuantities(filtered);
        var mode = this.mode(values);

        if (mode.length === 1) {
          mode = mode[0];
        }

        return new Quantity(mode, items[0].unit);
      } else {
        var _mode = this.mode(filtered);

        if (_mode.length === 1) {
          return _mode[0];
        } else {
          return _mode;
        }
      }
    }
  }, {
    key: "mode",
    value: function mode(arr) {
      var max = 0;
      var counts = {};
      var results = [];

      var _iterator3 = _createForOfIteratorHelper(arr),
          _step3;

      try {
        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
          var elem = _step3.value;
          var cnt = counts[elem] = (counts[elem] != null ? counts[elem] : 0) + 1;

          if (cnt === max && !results.includes(elem)) {
            results.push(elem);
          } else if (cnt > max) {
            results = [elem];
            max = cnt;
          }
        }
      } catch (err) {
        _iterator3.e(err);
      } finally {
        _iterator3.f();
      }

      return results;
    }
  }]);

  return Mode;
}(AggregateExpression);

var StdDev = /*#__PURE__*/function (_AggregateExpression8) {
  _inherits(StdDev, _AggregateExpression8);

  var _super9 = _createSuper(StdDev);

  // TODO: This should be a derived class of an abstract base class 'Statistic'
  // rather than the base class
  function StdDev(json) {
    var _this2;

    _classCallCheck(this, StdDev);

    _this2 = _super9.call(this, json);
    _this2.type = 'standard_deviation';
    return _this2;
  }

  _createClass(StdDev, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      try {
        items = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      if (hasOnlyQuantities(items)) {
        var values = getValuesFromQuantities(items);
        var stdDev = this.standardDeviation(values);
        return new Quantity(stdDev, items[0].unit);
      } else {
        return this.standardDeviation(items);
      }
    }
  }, {
    key: "standardDeviation",
    value: function standardDeviation(list) {
      var val = this.stats(list);

      if (val) {
        return val[this.type];
      }
    }
  }, {
    key: "stats",
    value: function stats(list) {
      var sum = list.reduce(function (x, y) {
        return x + y;
      });
      var mean = sum / list.length;
      var sumOfSquares = 0;

      var _iterator4 = _createForOfIteratorHelper(list),
          _step4;

      try {
        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
          var sq = _step4.value;
          sumOfSquares += Math.pow(sq - mean, 2);
        }
      } catch (err) {
        _iterator4.e(err);
      } finally {
        _iterator4.f();
      }

      var std_var = 1 / (list.length - 1) * sumOfSquares;
      var pop_var = 1 / list.length * sumOfSquares;
      var std_dev = Math.sqrt(std_var);
      var pop_dev = Math.sqrt(pop_var);
      return {
        standard_variance: std_var,
        population_variance: pop_var,
        standard_deviation: std_dev,
        population_deviation: pop_dev
      };
    }
  }]);

  return StdDev;
}(AggregateExpression);

var Product = /*#__PURE__*/function (_AggregateExpression9) {
  _inherits(Product, _AggregateExpression9);

  var _super10 = _createSuper(Product);

  function Product(json) {
    _classCallCheck(this, Product);

    return _super10.call(this, json);
  }

  _createClass(Product, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      try {
        items = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      if (hasOnlyQuantities(items)) {
        var values = getValuesFromQuantities(items);
        var product = values.reduce(function (x, y) {
          return x * y;
        }); // Units are not multiplied for the geometric product

        return new Quantity(product, items[0].unit);
      } else {
        return items.reduce(function (x, y) {
          return x * y;
        });
      }
    }
  }]);

  return Product;
}(AggregateExpression);

var GeometricMean = /*#__PURE__*/function (_AggregateExpression10) {
  _inherits(GeometricMean, _AggregateExpression10);

  var _super11 = _createSuper(GeometricMean);

  function GeometricMean(json) {
    _classCallCheck(this, GeometricMean);

    return _super11.call(this, json);
  }

  _createClass(GeometricMean, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);

      if (!typeIsArray(items)) {
        return null;
      }

      try {
        items = processQuantities(items);
      } catch (e) {
        return null;
      }

      if (items.length === 0) {
        return null;
      }

      if (hasOnlyQuantities(items)) {
        var values = getValuesFromQuantities(items);
        var product = values.reduce(function (x, y) {
          return x * y;
        });
        var geoMean = Math.pow(product, 1.0 / items.length);
        return new Quantity(geoMean, items[0].unit);
      } else {
        var _product = items.reduce(function (x, y) {
          return x * y;
        });

        return Math.pow(_product, 1.0 / items.length);
      }
    }
  }]);

  return GeometricMean;
}(AggregateExpression);

var PopulationStdDev = /*#__PURE__*/function (_StdDev) {
  _inherits(PopulationStdDev, _StdDev);

  var _super12 = _createSuper(PopulationStdDev);

  function PopulationStdDev(json) {
    var _this3;

    _classCallCheck(this, PopulationStdDev);

    _this3 = _super12.call(this, json);
    _this3.type = 'population_deviation';
    return _this3;
  }

  return PopulationStdDev;
}(StdDev);

var Variance = /*#__PURE__*/function (_StdDev2) {
  _inherits(Variance, _StdDev2);

  var _super13 = _createSuper(Variance);

  function Variance(json) {
    var _this4;

    _classCallCheck(this, Variance);

    _this4 = _super13.call(this, json);
    _this4.type = 'standard_variance';
    return _this4;
  }

  return Variance;
}(StdDev);

var PopulationVariance = /*#__PURE__*/function (_StdDev3) {
  _inherits(PopulationVariance, _StdDev3);

  var _super14 = _createSuper(PopulationVariance);

  function PopulationVariance(json) {
    var _this5;

    _classCallCheck(this, PopulationVariance);

    _this5 = _super14.call(this, json);
    _this5.type = 'population_variance';
    return _this5;
  }

  return PopulationVariance;
}(StdDev);

var AllTrue = /*#__PURE__*/function (_AggregateExpression11) {
  _inherits(AllTrue, _AggregateExpression11);

  var _super15 = _createSuper(AllTrue);

  function AllTrue(json) {
    _classCallCheck(this, AllTrue);

    return _super15.call(this, json);
  }

  _createClass(AllTrue, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);
      return allTrue(removeNulls(items));
    }
  }]);

  return AllTrue;
}(AggregateExpression);

var AnyTrue = /*#__PURE__*/function (_AggregateExpression12) {
  _inherits(AnyTrue, _AggregateExpression12);

  var _super16 = _createSuper(AnyTrue);

  function AnyTrue(json) {
    _classCallCheck(this, AnyTrue);

    return _super16.call(this, json);
  }

  _createClass(AnyTrue, [{
    key: "exec",
    value: function exec(ctx) {
      var items = this.source.execute(ctx);
      return anyTrue(items);
    }
  }]);

  return AnyTrue;
}(AggregateExpression);

function processQuantities(values) {
  var items = removeNulls(values);

  if (hasOnlyQuantities(items)) {
    return convertAllUnits(items);
  } else if (hasSomeQuantities(items)) {
    throw new Exception('Cannot perform aggregate operations on mixed values of Quantities and non Quantities');
  } else {
    return items;
  }
}

function getValuesFromQuantities(quantities) {
  return quantities.map(function (quantity) {
    return quantity.value;
  });
}

function hasOnlyQuantities(arr) {
  return arr.every(function (x) {
    return x.isQuantity;
  });
}

function hasSomeQuantities(arr) {
  return arr.some(function (x) {
    return x.isQuantity;
  });
}

function convertAllUnits(arr) {
  // convert all quantities in array to match the unit of the first item
  return arr.map(function (q) {
    return q.convertUnit(arr[0].unit);
  });
}

function medianOfNumbers(numbers) {
  var items = numerical_sort(numbers, 'asc');

  if (items.length % 2 === 1) {
    // Odd number of items
    return items[(items.length - 1) / 2];
  } else {
    // Even number of items
    return (items[items.length / 2 - 1] + items[items.length / 2]) / 2;
  }
}

module.exports = {
  Count: Count,
  Sum: Sum,
  Min: Min,
  Max: Max,
  Avg: Avg,
  Median: Median,
  Mode: Mode,
  StdDev: StdDev,
  Product: Product,
  GeometricMean: GeometricMean,
  PopulationStdDev: PopulationStdDev,
  Variance: Variance,
  PopulationVariance: PopulationVariance,
  AllTrue: AllTrue,
  AnyTrue: AnyTrue
};