@adaptabletools/adaptable 12.1.5 → 12.1.8-canary.0

package/src/Utilities/ExpressionFunctions/aggregatedScalarExpressionFunctions.js

@@ -1,15 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.aggregatedScalarExpressionFunctions = void 0;
+exports.aggregatedScalarExpressionFunctions = exports.aggregatedExpressionFunctions = exports.cumulativeAggregatedExpressionFunctions = void 0;
 const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
 const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
+exports.cumulativeAggregatedExpressionFunctions = [
+    'CUMUL',
+    'OVER',
+    'SUM',
+    'PERCENTAGE',
+    'MIN',
+    'MAX',
+    'AVG',
+    'WEIGHT',
+    'COL',
+    'GROUP_BY',
+];
+exports.aggregatedExpressionFunctions = [
+    'SUM',
+    'PERCENTAGE',
+    'MIN',
+    'MAX',
+    'QUANT',
+    'AVG',
+    'WEIGHT',
+    'COL',
+    'GROUP_BY',
+];
 exports.aggregatedScalarExpressionFunctions = {
+    CUMUL: {
+        handler(args, context) {
+            const aggregationParameter = expressionFunctionUtils_1.extractParameter('CUMUL', 'aggregationScalar', ['SUM', 'MIN', 'MAX', 'PERCENTAGE', 'AVG', 'PERCENTAGE'], args);
+            const overColumnParameter = expressionFunctionUtils_1.extractParameter('CUMUL', 'operand', ['OVER'], args);
+            const cumulationExpressionEvaluation = mapAggregationToCumulation(aggregationParameter, overColumnParameter, context);
+            const result = {
+                name: 'CUMUL',
+                type: 'aggregationScalar',
+                value: cumulationExpressionEvaluation,
+            };
+            return result;
+        },
+        description: 'Performs a cumulative aggregation (running total) with the given aggregation operation over a provided column',
+        signatures: ['CUMUL( aggregationOp: SUM|MIN|MAX, OVER( [colNameB] ))'],
+        examples: [
+            'CUMUL( SUM([colNameA]), OVER( [colNameB] ))',
+            'CUMUL( MIN([colNameA]), OVER( [colNameB] ))',
+            'CUMUL( MAX([colNameA]), OVER( [colNameB] ))',
+        ],
+    },
     SUM: {
         handler(args, context) {
             const sumColumnParameter = expressionFunctionUtils_1.extractColumnParameter('SUM', args);
             const sumColumnName = sumColumnParameter.value;
             expressionFunctionUtils_1.validateColumnType(sumColumnName, ['Number'], 'SUM', context.adaptableApi);
-            const groupByParameter = expressionFunctionUtils_1.extractParameter('SUM', 'operand', ['GROUP_BY'], args, true);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('SUM', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
             const aggregationExpressionEvaluation = {
                 aggregationParams: {
                     reducers: {
@@ -18,20 +63,21 @@ exports.aggregatedScalarExpressionFunctions = {
                             field: sumColumnName,
                             initialValue: 0,
                             reducer: (totalSum, rowValue) => {
-                                if (!rowValue) {
+                                if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
-                                return totalSum + rowValue;
+                                return totalSum + expressionFunctionUtils_1.getNumericValue(rowValue);
                             },
                         },
                     },
                 },
+                rowFilterFn: context.filterFn,
                 columnDependencies: [sumColumnName],
             };
-            addGroupByParams(groupByParameter, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'SUM',
-                type: 'aggregation',
+                type: 'aggregationScalar',
                 value: aggregationExpressionEvaluation,
             };
             return result;
@@ -51,17 +97,21 @@ exports.aggregatedScalarExpressionFunctions = {
             const percentageColumnParameter = expressionFunctionUtils_1.extractColumnParameter('PERCENTAGE', args);
             const percentageColumnName = percentageColumnParameter.value;
             expressionFunctionUtils_1.validateColumnType(percentageColumnName, ['Number'], 'PERCENTAGE', context.adaptableApi);
-            const sumOperand = expressionFunctionUtils_1.extractParameter('PERCENTAGE', 'aggregation', ['SUM'], args, true);
-            const groupByOperand = expressionFunctionUtils_1.extractParameter('PERCENTAGE', 'operand', ['GROUP_BY'], args, true);
+            const sumOperand = expressionFunctionUtils_1.extractParameter('PERCENTAGE', 'aggregationScalar', ['SUM'], args, {
+                isOptional: true,
+            });
+            const groupByOperand = expressionFunctionUtils_1.extractParameter('PERCENTAGE', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
             if (sumOperand && groupByOperand) {
                 throw new ExpressionEvaluationError_1.ExpressionEvaluationError('PERCENTAGE', `expects either a SUM or a GROUP_BY argument`);
             }
             const sumAggregationColumnName = sumOperand
                 ? sumOperand.value.aggregationParams.reducers['SUM'].field
                 : percentageColumnName;
-            const groupByColumnName = groupByOperand
-                ? groupByOperand.value
-                : (_a = sumOperand === null || sumOperand === void 0 ? void 0 : sumOperand.value.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a[0].field;
+            const groupByColumnNames = groupByOperand
+                ? groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value
+                : (_a = sumOperand === null || sumOperand === void 0 ? void 0 : sumOperand.value.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.map((param) => param.field);
             const aggregationExpressionEvaluation = {
                 aggregationParams: {
                     reducers: {
@@ -70,32 +120,26 @@ exports.aggregatedScalarExpressionFunctions = {
                             field: sumAggregationColumnName,
                             initialValue: 0,
                             reducer: (totalSum, rowValue) => {
-                                if (!rowValue) {
+                                if (isUndefinedValue(rowValue)) {
                                     return totalSum;
                                 }
-                                return totalSum + rowValue;
+                                return totalSum + expressionFunctionUtils_1.getNumericValue(rowValue);
                             },
                         },
                     },
                 },
                 rowValueGetter: (rowNode, aggregationValue) => {
-                    return ((context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, percentageColumnName) /
+                    return ((expressionFunctionUtils_1.getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, percentageColumnName)) /
                         aggregationValue) *
                         100);
                 },
+                rowFilterFn: context.filterFn,
                 columnDependencies: [...new Set([percentageColumnName, sumAggregationColumnName])],
             };
-            if (groupByColumnName) {
-                aggregationExpressionEvaluation.aggregationParams.groupBy = [
-                    {
-                        field: groupByColumnName,
-                    },
-                ];
-                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
-            }
+            addGroupByParams(groupByColumnNames, aggregationExpressionEvaluation);
             const result = {
                 name: 'PERCENTAGE',
-                type: 'aggregation',
+                type: 'aggregationScalar',
                 value: aggregationExpressionEvaluation,
             };
             return result;
@@ -114,171 +158,67 @@ exports.aggregatedScalarExpressionFunctions = {
             'PERCENTAGE( [colNameA], SUM ( [colNameB], GROUP_BY( [colNameC] )))',
         ],
     },
-    QUANT: {
-        handler(args, context) {
-            var _a, _b, _c;
-            const quantileColumnParameter = expressionFunctionUtils_1.extractColumnParameter('QUANT', args);
-            const quantileColumnName = quantileColumnParameter.value;
-            expressionFunctionUtils_1.validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
-            const qNumber = args.find((arg) => typeof arg === 'number');
-            if (qNumber == null || qNumber <= 0) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUANT', 'expects a positive number as argument');
-            }
-            const groupByOperand = expressionFunctionUtils_1.extractParameter('QUANT', 'operand', ['GROUP_BY'], args, true);
-            const groupByColumnName = groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value;
-            let quantReducer;
-            if (groupByColumnName) {
-                // do the heavy-lifting in done()
-                quantReducer = {
-                    initialValue: new WeakMap(),
-                    reducer: (nodeValueMap, rowValue, rowNode, rowIndex) => {
-                        if (!rowValue) {
-                            return nodeValueMap;
-                        }
-                        nodeValueMap.set(rowNode, rowValue);
-                        return nodeValueMap;
-                    },
-                    done: (nodeValueMap, groupItems) => {
-                        var _a, _b;
-                        const populationSize = (_b = (_a = groupItems === null || groupItems === void 0 ? void 0 : groupItems.filter((rowNode) => {
-                            const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
-                            return rowValue != undefined;
-                        })) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-                        const bucketsMap = new Map();
-                        for (let step = 1; step <= qNumber; step++) {
-                            bucketsMap.set(step, populationSize * (step / qNumber));
-                        }
-                        const indexBucketMap = new Map();
-                        for (let populationIndex = 0; populationIndex < populationSize; populationIndex++) {
-                            for (let quantIndex = 1; quantIndex <= qNumber; quantIndex++) {
-                                if (bucketsMap.get(quantIndex) < populationIndex + 1) {
-                                    continue;
-                                }
-                                else {
-                                    indexBucketMap.set(populationIndex, quantIndex);
-                                    break;
-                                }
-                            }
-                        }
-                        const groupedRowBucketMap = new Map();
-                        groupItems.forEach((subgroupRowNode, subgroupRowIndex) => {
-                            const subgroupRowValue = nodeValueMap.get(subgroupRowNode);
-                            if (subgroupRowValue) {
-                                groupedRowBucketMap.set(subgroupRowValue, indexBucketMap.get(subgroupRowIndex));
-                            }
-                        });
-                        return groupedRowBucketMap;
-                    },
-                };
-            }
-            else {
-                // in case of non-grouped quantiles, we are able to calculate the buckets beforehand (which is the most efficient)
-                const populationSize = (_c = (_b = (_a = context.adaptableApi.gridApi.getAllRowNodes()) === null || _a === void 0 ? void 0 : _a.filter((rowNode) => {
-                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
-                    return rowValue != undefined;
-                })) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
-                const bucketsMap = new Map();
-                for (let step = 1; step <= qNumber; step++) {
-                    bucketsMap.set(step, populationSize * (step / qNumber));
-                }
-                const indexBucketMap = new Map();
-                for (let populationIndex = 0; populationIndex < populationSize; populationIndex++) {
-                    for (let quantIndex = 1; quantIndex <= qNumber; quantIndex++) {
-                        if (bucketsMap.get(quantIndex) < populationIndex + 1) {
-                            continue;
-                        }
-                        else {
-                            indexBucketMap.set(populationIndex, quantIndex);
-                            break;
-                        }
-                    }
-                }
-                quantReducer = {
-                    initialValue: new Map(),
-                    reducer: (rowBucketMap, rowValue, rowNode, rowIndex) => {
-                        if (!rowValue) {
-                            return rowBucketMap;
-                        }
-                        rowBucketMap.set(rowValue, indexBucketMap.get(rowIndex));
-                        return rowBucketMap;
-                    },
-                };
-            }
-            const aggregationExpressionEvaluation = {
-                sortByColumn: quantileColumnName,
-                filterUndefinedValues: true,
-                aggregationParams: {
-                    reducers: {
-                        QUANT: Object.assign({ name: 'QUANT', field: quantileColumnName }, quantReducer),
-                    },
-                },
-                rowValueGetter: (rowNode, rowBucketMap) => {
-                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
-                    if (rowValue == null) {
-                        return;
-                    }
-                    return rowBucketMap.get(rowValue);
-                },
-                columnDependencies: [quantileColumnName],
-            };
-            if (groupByColumnName) {
-                aggregationExpressionEvaluation.aggregationParams.groupBy = [
-                    {
-                        field: groupByColumnName,
-                    },
-                ];
-                aggregationExpressionEvaluation.columnDependencies.push(groupByColumnName);
-            }
-            const result = {
-                name: 'QUANT',
-                type: 'aggregation',
-                value: aggregationExpressionEvaluation,
-            };
-            return result;
-        },
-        description: 'Calculates the q-Quantiles of the given group and displays which q-quantile the given value is in\nCommon quantiles are 4-quantile or Quartile, 5-quantile or Quintile, 10-quantile or Decile and 100-quantile or Percentile',
-        signatures: [
-            'QUANT( [colName], q: number)',
-            'QUANT( COL(name: string), q: number)',
-            'QUANT( [colName1], q: number, GROUP_BY([colName2]) )',
-        ],
-        examples: [
-            'QUANT( [col1], 5)',
-            `QUANT( COL('col1'), 100))`,
-            'QUANT( [col1], 4, GROUP_BY([col2]) )',
-        ],
-    },
     AVG: {
         handler(args, context) {
             const avgColumnParameter = expressionFunctionUtils_1.extractColumnParameter('AVG', args);
             const avgColumnName = avgColumnParameter.value;
             expressionFunctionUtils_1.validateColumnType(avgColumnName, ['Number'], 'AVG', context.adaptableApi);
-            const groupByParameter = expressionFunctionUtils_1.extractParameter('AVG', 'operand', ['GROUP_BY'], args, true);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('AVG', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const weightParameter = expressionFunctionUtils_1.extractParameter('AVG', 'operand', ['WEIGHT'], args, {
+                isOptional: true,
+            });
             const aggregationExpressionEvaluation = {
                 aggregationParams: {
                     reducers: {
-                        SUM: {
+                        AVG: {
                             name: 'AVG',
                             field: avgColumnName,
-                            initialValue: 0,
-                            reducer: (totalSum, rowValue) => {
-                                if (!rowValue) {
-                                    return totalSum;
+                            initialValue: {
+                                sumOfValues: 0,
+                                numberOfValues: 0,
+                            },
+                            reducer: (aggregatedValue, rowValue, rowNode) => {
+                                var _a;
+                                if (isUndefinedValue(rowValue)) {
+                                    return aggregatedValue;
+                                }
+                                const numericRowValue = expressionFunctionUtils_1.getNumericValue(rowValue);
+                                if (weightParameter) {
+                                    // weighted average
+                                    const weightValue = (_a = expressionFunctionUtils_1.getNumericValue(context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, weightParameter.value))) !== null && _a !== void 0 ? _a : 0;
+                                    aggregatedValue.sumOfValues =
+                                        aggregatedValue.sumOfValues + numericRowValue * weightValue;
+                                    aggregatedValue.numberOfValues = aggregatedValue.numberOfValues + weightValue;
                                 }
-                                return totalSum + rowValue;
+                                else {
+                                    aggregatedValue.sumOfValues = aggregatedValue.sumOfValues + numericRowValue;
+                                    aggregatedValue.numberOfValues = aggregatedValue.numberOfValues + 1;
+                                }
+                                return aggregatedValue;
                             },
-                            done: (value, dataArray) => {
-                                return dataArray.length ? value / dataArray.length : 0;
+                            done: (aggregatedValue) => {
+                                if (aggregatedValue.numberOfValues === 0) {
+                                    return 0;
+                                }
+                                return aggregatedValue.sumOfValues / aggregatedValue.numberOfValues;
                             },
                         },
                     },
                 },
+                rowFilterFn: context.filterFn,
                 columnDependencies: [avgColumnName],
             };
-            addGroupByParams(groupByParameter, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
+            if (weightParameter) {
+                aggregationExpressionEvaluation.context = {
+                    weightParam: weightParameter,
+                };
+            }
             const result = {
                 name: 'AVG',
-                type: 'aggregation',
+                type: 'aggregationScalar',
                 value: aggregationExpressionEvaluation,
             };
             return result;
@@ -297,19 +237,22 @@ exports.aggregatedScalarExpressionFunctions = {
             const minColumnParameter = expressionFunctionUtils_1.extractColumnParameter('MIN', args);
             const minColumnName = minColumnParameter.value;
             expressionFunctionUtils_1.validateColumnType(minColumnName, ['Number'], 'MIN', context.adaptableApi);
-            const groupByParameter = expressionFunctionUtils_1.extractParameter('MIN', 'operand', ['GROUP_BY'], args, true);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('MIN', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
             const aggregationExpressionEvaluation = {
                 aggregationParams: {
                     reducers: {
-                        SUM: {
+                        MIN: {
                             name: 'MIN',
                             field: minColumnName,
                             initialValue: Number.MAX_VALUE,
                             reducer: (minValue, rowValue) => {
-                                if (!rowValue) {
+                                if (isUndefinedValue(rowValue)) {
                                     return minValue;
                                 }
-                                return rowValue < minValue ? rowValue : minValue;
+                                const numericRowValue = expressionFunctionUtils_1.getNumericValue(rowValue);
+                                return numericRowValue < minValue ? numericRowValue : minValue;
                             },
                             done: (minValue) => {
                                 if (minValue !== Number.MAX_VALUE) {
@@ -319,12 +262,13 @@ exports.aggregatedScalarExpressionFunctions = {
                         },
                     },
                 },
+                rowFilterFn: context.filterFn,
                 columnDependencies: [minColumnName],
             };
-            addGroupByParams(groupByParameter, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'MIN',
-                type: 'aggregation',
+                type: 'aggregationScalar',
                 value: aggregationExpressionEvaluation,
             };
             return result;
@@ -343,19 +287,22 @@ exports.aggregatedScalarExpressionFunctions = {
             const maxColumnParameter = expressionFunctionUtils_1.extractColumnParameter('MAX', args);
             const maxColumnName = maxColumnParameter.value;
             expressionFunctionUtils_1.validateColumnType(maxColumnName, ['Number'], 'MAX', context.adaptableApi);
-            const groupByParameter = expressionFunctionUtils_1.extractParameter('MAX', 'operand', ['GROUP_BY'], args, true);
+            const groupByParameter = expressionFunctionUtils_1.extractParameter('MAX', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
             const aggregationExpressionEvaluation = {
                 aggregationParams: {
                     reducers: {
-                        SUM: {
+                        MAX: {
                             name: 'MAX',
                             field: maxColumnName,
                             initialValue: Number.MIN_VALUE,
                             reducer: (maxValue, rowValue) => {
-                                if (!rowValue) {
+                                if (isUndefinedValue(rowValue)) {
                                     return maxValue;
                                 }
-                                return rowValue > maxValue ? rowValue : maxValue;
+                                const numericRowValue = expressionFunctionUtils_1.getNumericValue(rowValue);
+                                return numericRowValue > maxValue ? numericRowValue : maxValue;
                             },
                             done: (maxValue) => {
                                 if (maxValue !== Number.MIN_VALUE) {
@@ -365,12 +312,13 @@ exports.aggregatedScalarExpressionFunctions = {
                         },
                     },
                 },
+                rowFilterFn: context.filterFn,
                 columnDependencies: [maxColumnName],
             };
-            addGroupByParams(groupByParameter, aggregationExpressionEvaluation);
+            addGroupByParams(groupByParameter === null || groupByParameter === void 0 ? void 0 : groupByParameter.value, aggregationExpressionEvaluation);
             const result = {
                 name: 'MAX',
-                type: 'aggregation',
+                type: 'aggregationScalar',
                 value: aggregationExpressionEvaluation,
             };
             return result;
@@ -384,45 +332,136 @@ exports.aggregatedScalarExpressionFunctions = {
         ],
         examples: ['MIN([colA])', 'MIN([colA], GROUP_BY([colB]))'],
     },
-    GROUP_BY: {
-        handler(args, context) {
-            const columnParameter = expressionFunctionUtils_1.extractColumnParameter('GROUP_BY', args);
-            const result = {
-                type: 'operand',
-                name: 'GROUP_BY',
-                value: columnParameter.value,
-            };
-            return result;
-        },
-        description: 'Groups an aggregation operation within the rows that have the same value in the specified column',
-        signatures: ['GROUP_BY( [colName] )', 'GROUP_BY( COL(name: string))'],
-        examples: ['GROUP_BY( [colName] )', `GROUP_BY( COL('colName'))`],
-    },
-    CUMUL: {
+    QUANT: {
         handler(args, context) {
-            var _a;
-            const aggregationParameter = expressionFunctionUtils_1.extractParameter('CUMUL', 'aggregation', ['SUM', 'MIN', 'MAX', 'PERCENTAGE', 'AVG'], args);
-            if (aggregationParameter.name === 'AVG' || aggregationParameter.name === 'PERCENTAGE') {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('CUMUL', `supports only following aggregations: SUM, MIN, MAX`);
+            var _a, _b, _c;
+            const quantileColumnParameter = expressionFunctionUtils_1.extractColumnParameter('QUANT', args);
+            const quantileColumnName = quantileColumnParameter.value;
+            expressionFunctionUtils_1.validateColumnType(quantileColumnName, ['Number'], 'QUANT', context.adaptableApi);
+            const qNumber = args.find((arg) => typeof arg === 'number');
+            if (qNumber == null || qNumber <= 0) {
+                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUANT', 'expects a positive number as argument');
+            }
+            const groupByOperand = expressionFunctionUtils_1.extractParameter('QUANT', 'operand', ['GROUP_BY'], args, {
+                isOptional: true,
+            });
+            const groupByColumnNames = groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value;
+            let quantReducer;
+            if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {
+                // do the heavy-lifting in done()
+                quantReducer = {
+                    initialValue: {},
+                    reducer: (nodeValueMap, rowValue, rowNode, rowIndex) => {
+                        if (isUndefinedValue(rowValue)) {
+                            return nodeValueMap;
+                        }
+                        nodeValueMap[rowNode.id] = rowValue;
+                        return nodeValueMap;
+                    },
+                    done: (nodeValueMap, groupItems) => {
+                        var _a, _b;
+                        const populationSize = (_b = (_a = groupItems === null || groupItems === void 0 ? void 0 : groupItems.filter((rowNode) => {
+                            const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                            return isDefinedValue(rowValue);
+                        })) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+                        const bucketsMap = new Map();
+                        for (let step = 1; step <= qNumber; step++) {
+                            bucketsMap.set(step, populationSize * (step / qNumber));
+                        }
+                        const indexBucketMap = new Map();
+                        for (let populationIndex = 0; populationIndex < populationSize; populationIndex++) {
+                            for (let quantIndex = 1; quantIndex <= qNumber; quantIndex++) {
+                                if (bucketsMap.get(quantIndex) < populationIndex + 1) {
+                                    continue;
+                                }
+                                else {
+                                    indexBucketMap.set(populationIndex, quantIndex);
+                                    break;
+                                }
+                            }
+                        }
+                        const groupedRowBucketMap = {};
+                        groupItems.forEach((subgroupRowNode, subgroupRowIndex) => {
+                            const subgroupRowValue = nodeValueMap[subgroupRowNode.id];
+                            if (subgroupRowValue) {
+                                groupedRowBucketMap[subgroupRowValue] = indexBucketMap.get(subgroupRowIndex);
+                            }
+                        });
+                        return groupedRowBucketMap;
+                    },
+                };
             }
-            if ((_a = aggregationParameter.value.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('CUMUL', `supports only aggregations without any grouping (GROUP_BY clauses)`);
+            else {
+                // in case of non-grouped quantiles, we are able to calculate the buckets beforehand (which is the most efficient)
+                const populationSize = (_c = (_b = (_a = context.adaptableApi.gridApi.getAllRowNodes()) === null || _a === void 0 ? void 0 : _a.filter((rowNode) => {
+                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                    return isDefinedValue(rowValue);
+                })) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+                const bucketsMap = new Map();
+                for (let step = 1; step <= qNumber; step++) {
+                    bucketsMap.set(step, populationSize * (step / qNumber));
+                }
+                const indexBucketMap = new Map();
+                for (let populationIndex = 0; populationIndex < populationSize; populationIndex++) {
+                    for (let quantIndex = 1; quantIndex <= qNumber; quantIndex++) {
+                        if (bucketsMap.get(quantIndex) < populationIndex + 1) {
+                            continue;
+                        }
+                        else {
+                            indexBucketMap.set(populationIndex, quantIndex);
+                            break;
+                        }
+                    }
+                }
+                quantReducer = {
+                    initialValue: {},
+                    reducer: (rowBucketMap, rowValue, rowNode, rowIndex) => {
+                        if (isUndefinedValue(rowValue)) {
+                            return rowBucketMap;
+                        }
+                        rowBucketMap[rowValue] = indexBucketMap.get(rowIndex);
+                        return rowBucketMap;
+                    },
+                };
             }
-            const overColumnParameter = expressionFunctionUtils_1.extractParameter('CUMUL', 'operand', ['OVER'], args);
-            aggregationParameter.value.cumulateOver = overColumnParameter.value;
+            const aggregationExpressionEvaluation = {
+                sortByColumn: quantileColumnName,
+                rowFilterFn: (rowNode) => {
+                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                    return isDefinedValue(rowValue);
+                },
+                aggregationParams: {
+                    reducers: {
+                        QUANT: Object.assign({ name: 'QUANT', field: quantileColumnName }, quantReducer),
+                    },
+                },
+                rowValueGetter: (rowNode, rowBucketMap) => {
+                    const rowValue = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, quantileColumnName);
+                    if (rowValue == null) {
+                        return;
+                    }
+                    return rowBucketMap[rowValue];
+                },
+                columnDependencies: [quantileColumnName],
+            };
+            addGroupByParams(groupByOperand === null || groupByOperand === void 0 ? void 0 : groupByOperand.value, aggregationExpressionEvaluation);
             const result = {
-                name: 'CUMUL',
-                type: 'aggregation',
-                value: aggregationParameter.value,
+                name: 'QUANT',
+                type: 'aggregationScalar',
+                value: aggregationExpressionEvaluation,
             };
             return result;
         },
-        description: 'Performs a cumulative aggregation (running total) with the given aggregation operation over a provided column',
-        signatures: ['CUMUL( aggregationOp: SUM|MIN|MAX, OVER( [colNameB] ))'],
+        description: 'Calculates the q-Quantiles of the given group and displays which q-quantile the given value is in\nCommon quantiles are 4-quantile or Quartile, 5-quantile or Quintile, 10-quantile or Decile and 100-quantile or Percentile',
+        signatures: [
+            'QUANT( [colName], q: number)',
+            'QUANT( COL(name: string), q: number)',
+            'QUANT( [colName1], q: number, GROUP_BY([colName2]) )',
+        ],
         examples: [
-            'CUMUL( SUM([colNameA]), OVER( [colNameB] ))',
-            'CUMUL( MIN([colNameA]), OVER( [colNameB] ))',
-            'CUMUL( MAX([colNameA]), OVER( [colNameB] ))',
+            'QUANT( [col1], 5)',
+            `QUANT( COL('col1'), 100))`,
+            'QUANT( [col1], 4, GROUP_BY([col2]) )',
         ],
     },
     OVER: {
@@ -440,6 +479,35 @@ exports.aggregatedScalarExpressionFunctions = {
         signatures: ['OVER( [colName] )', 'OVER( COL(name: string))'],
         examples: ['OVER( [colName] )', `OVER( COL('colName'))`],
     },
+    WEIGHT: {
+        handler(args, context) {
+            const columnParameter = expressionFunctionUtils_1.extractColumnParameter('WEIGHT', args);
+            expressionFunctionUtils_1.validateColumnType(columnParameter.value, ['Number'], 'WEIGHT', context.adaptableApi);
+            const result = {
+                type: 'operand',
+                name: 'WEIGHT',
+                value: columnParameter.value,
+            };
+            return result;
+        },
+        description: 'Defines a weight for the enclosing AVG(Average) aggregation',
+        signatures: ['WEIGHT( [colName] )', 'WEIGHT( COL(name: string))'],
+        examples: ['WEIGHT( [colName] )', `WEIGHT( COL('colName'))`],
+    },
+    GROUP_BY: {
+        handler(args, context) {
+            const columnParameters = expressionFunctionUtils_1.extractColumnParameters('GROUP_BY', args);
+            const result = {
+                type: 'operand',
+                name: 'GROUP_BY',
+                value: columnParameters.map((columnParam) => columnParam.value),
+            };
+            return result;
+        },
+        description: 'Groups an aggregation operation within the rows that have the same value in the specified column',
+        signatures: ['GROUP_BY( [colName] )', 'GROUP_BY( COL(name: string))'],
+        examples: ['GROUP_BY( [colName] )', `GROUP_BY( COL('colName'))`],
+    },
     COL: {
         handler(args, context) {
             return expressionFunctionUtils_1.handleColumnFunction(args, context);
@@ -449,15 +517,150 @@ exports.aggregatedScalarExpressionFunctions = {
         examples: ['[col1]', 'COL("col1")'],
     },
 };
-// !! mutates expressionEvaluation
-const addGroupByParams = (groupByParameter, expressionEvaluation) => {
-    if (groupByParameter) {
-        const groupByColumnName = groupByParameter.value;
-        expressionEvaluation.aggregationParams.groupBy = [
-            {
-                field: groupByColumnName,
+const mapAggregationToCumulation = (aggregationParameter, overColumnParameter, context) => {
+    const aggregationEvaluation = aggregationParameter.value;
+    const aggregationReducer = aggregationEvaluation.aggregationParams.reducers[aggregationParameter.name];
+    const cumulationAggregationReducer = aggregationParameter.name === 'SUM'
+        ? {
+            name: 'CUMUL_SUM',
+            field: aggregationReducer.field,
+            initialValue: {
+                currentValue: aggregationReducer.initialValue,
+                cumulatedValues: {},
             },
-        ];
-        expressionEvaluation.columnDependencies.push(groupByColumnName);
+            reducer: (cumulationBag, rowValue, rowNode) => {
+                if (isDefinedValue(rowValue)) {
+                    cumulationBag.currentValue = cumulationBag.currentValue + rowValue;
+                }
+                cumulationBag.cumulatedValues[rowNode.id] = cumulationBag.currentValue;
+                return cumulationBag;
+            },
+        }
+        : aggregationParameter.name === 'MIN'
+            ? {
+                name: 'CUMUL_MIN',
+                field: aggregationReducer.field,
+                initialValue: {
+                    currentValue: aggregationReducer.initialValue,
+                    cumulatedValues: {},
+                },
+                reducer: (cumulationBag, rowValue, rowNode) => {
+                    if (isDefinedValue(rowValue) && rowValue < cumulationBag.currentValue) {
+                        cumulationBag.currentValue = rowValue;
+                    }
+                    if (cumulationBag.currentValue !== aggregationReducer.initialValue) {
+                        cumulationBag.cumulatedValues[rowNode.id] = cumulationBag.currentValue;
+                    }
+                    return cumulationBag;
+                },
+            }
+            : aggregationParameter.name === 'MAX'
+                ? {
+                    name: 'CUMUL_MAX',
+                    field: aggregationReducer.field,
+                    initialValue: {
+                        currentValue: aggregationReducer.initialValue,
+                        cumulatedValues: {},
+                    },
+                    reducer: (cumulationBag, rowValue, rowNode) => {
+                        if (isDefinedValue(rowValue) && rowValue > cumulationBag.currentValue) {
+                            cumulationBag.currentValue = rowValue;
+                        }
+                        if (cumulationBag.currentValue !== aggregationReducer.initialValue) {
+                            cumulationBag.cumulatedValues[rowNode.id] = cumulationBag.currentValue;
+                        }
+                        return cumulationBag;
+                    },
+                }
+                : aggregationParameter.name === 'AVG'
+                    ? {
+                        name: 'CUMUL_AVG',
+                        field: aggregationReducer.field,
+                        initialValue: {
+                            currentValue: 0,
+                            cumulatedValues: {},
+                            numberOfCumulatedValues: 0,
+                        },
+                        reducer: (cumulationBag, rowValue, rowNode) => {
+                            var _a, _b;
+                            if (isDefinedValue(rowValue)) {
+                                if ((_a = aggregationEvaluation.context) === null || _a === void 0 ? void 0 : _a.weightParam) {
+                                    // weighted average
+                                    const weightValue = (_b = context.adaptableApi.gridApi.getRawValueFromRowNode(rowNode, aggregationEvaluation.context.weightParam.value)) !== null && _b !== void 0 ? _b : 0;
+                                    cumulationBag.currentValue = cumulationBag.currentValue + rowValue * weightValue;
+                                    cumulationBag.numberOfCumulatedValues =
+                                        cumulationBag.numberOfCumulatedValues + weightValue;
+                                }
+                                else {
+                                    cumulationBag.currentValue = cumulationBag.currentValue + rowValue;
+                                    cumulationBag.numberOfCumulatedValues = cumulationBag.numberOfCumulatedValues + 1;
+                                }
+                            }
+                            if (cumulationBag.numberOfCumulatedValues !== 0) {
+                                cumulationBag.cumulatedValues[rowNode.id] =
+                                    cumulationBag.currentValue / cumulationBag.numberOfCumulatedValues;
+                            }
+                            return cumulationBag;
+                        },
+                    }
+                    : aggregationParameter.name === 'PERCENTAGE'
+                        ? {
+                            name: 'CUMUL_PERCENTAGE',
+                            field: aggregationReducer.field,
+                            initialValue: {
+                                currentValue: aggregationReducer.initialValue,
+                                cumulatedValues: {},
+                            },
+                            reducer: (cumulationBag, rowValue, rowNode) => {
+                                if (isDefinedValue(rowValue)) {
+                                    cumulationBag.currentValue = cumulationBag.currentValue + rowValue;
+                                }
+                                cumulationBag.cumulatedValues[rowNode.id] = cumulationBag.currentValue;
+                                return cumulationBag;
+                            },
+                            done: (cumulationBag) => {
+                                cumulationBag.totalAggregationValue = cumulationBag.currentValue;
+                                return cumulationBag;
+                            },
+                        }
+                        : null;
+    const rowValueGetter = aggregationParameter.name === 'PERCENTAGE'
+        ? (rowNode, cumulationBag) => {
+            const cumulatedSum = cumulationBag.cumulatedValues[rowNode.id];
+            const totalValue = cumulationBag.totalAggregationValue;
+            return (cumulatedSum / totalValue) * 100;
+        }
+        : (rowNode, aggregatedValue) => {
+            return aggregatedValue.cumulatedValues[rowNode.id];
+        };
+    const cumulationExpressionEvaluation = {
+        sortByColumn: overColumnParameter.value,
+        aggregationParams: {
+            reducers: {
+                CUMUL: cumulationAggregationReducer,
+            },
+            groupBy: aggregationEvaluation.aggregationParams.groupBy,
+        },
+        rowValueGetter,
+        columnDependencies: [
+            ...new Set([...aggregationEvaluation.columnDependencies, overColumnParameter.value]),
+        ],
+        rowFilterFn: aggregationEvaluation.rowFilterFn,
+    };
+    return cumulationExpressionEvaluation;
+};
+// !! mutates expressionEvaluation
+const addGroupByParams = (groupByColumnNames, expressionEvaluation) => {
+    if (groupByColumnNames === null || groupByColumnNames === void 0 ? void 0 : groupByColumnNames.length) {
+        expressionEvaluation.aggregationParams.groupBy = groupByColumnNames.map((columnName) => ({
+            field: columnName,
+        }));
+        expressionEvaluation.columnDependencies.push(...groupByColumnNames);
     }
 };
+const isUndefinedValue = (input) => {
+    return input == undefined || input === '';
+};
+const isDefinedValue = (input) => {
+    return !isUndefinedValue(input);
+};