[TOC]

计算指标规则定义说明

计算指标的规则定义以json字符串的方式存储于指标定义表的regular字段，具体模型定义、计算流程、以及示例见下面说明。

1、模型定义

CONFIG说明

说明：原生指标计算时也会用到此CONFIG配置。

DEF参数定义

JS&COND内置对象说明

$R内置函数说明

$F内置函数说明

说明：函数详细用法说明见本文档附录2

2、计算流程

• 每个指标值产生后，根据源指标与计算指标配置关系，判断该指标是否为某个计算指标的源指标。
• 如果为真，则根据关系配置信息进行源指标值缓存，将指标值推入缓冲队列。
• 缓存操作完成后，执行COND。
• 如果为真，则执行JS，返回结果为该计算指标的值。
• 指标值计算完成后，根据SIZE值进行缓存清理。

3、配置示例

2061指标计算

{  
  "DEF": [
          { "M":"2047", "OBJ":"SINGLE", "PERIOD":"SINGLE"},
          { "M":"2049", "OBJ":"SINGLE", "PERIOD":"SINGLE"}
        ],
  "COND":"$F.exist(N2047) && $F.exist(N2049)",
  "JS":"var val = (N2047==0?0:(N2047-2049)*100/N2047);val.toFixed(1);"
}

2002指标计算

{  
  "DEF": [
                { "M":"2001","SIZE":11, "OBJ":"SINGLE", "PERIOD":"MULTI"}
          ],
  "COND":"$F.exist(N2001) && N2001.length>=12",
  "JS":"$F.boolRatio1(N2001, 1);"
}

2003指标计算

{  
  "DEF": [
                { "M":"2001","SIZE":0, "OBJ":"SINGLE", "PERIOD":"MULTI"}
          ],
  "COND":"$F.exist(N2001) && N2001.length>=12",
  "JS":"$F.boolRatio1(N2001, 1);"      
}

1004指标计算

{  
  "DEF": [
                { "M":"3001", "OBJ":"MULTI", "PERIOD":"SINGLE"}
       ],
  "COND":"$F.exist(N3001) && N3001.length>=$R.OBJ_3001_NUM",
  "JS":"$F.sum(N3001);"     
}

4、计算指标计算流程

附录1、各种维度组合支持情况

附录2、计算指标内置函数

exist

function exist(v) {
    return typeof(v) != 'undefined' && v != null && (Array.isArray(v) ? v.length > 0 : true);
}

boolRatio1

布尔量数组求真占比。源指标汇集数据集为一维数组，其值为整型，且只有0，1两种取值，例如：[1,0,0,1,1]，该规则value=(count(1)/size).toFixed(fixed)。fixed为保留小数位数，四舍五入。

/**
 * 布尔量数组求真占比
 * @param arr
 * @precision, 保留几位小数
 * @returns {number}
 */
function boolRatio1(arr, precision) {
    var sum = 0;
    for (var i in arr) {
        if (arr[i] >= 1) {
            sum++;
        }
    }
    var val = sum * 100 / arr.length;
    return precision==undefined?val:val.toFixed(precision);
}

boolRatio0

布尔量数组求假占比。源指标汇集数据集为一维数组，其值为整型，且只有0，1两种取值，例如：[1,0,0,1,1]，该规则value=(count(0)/size).toFixed(fixed)。fixed为保留小数位数，四舍五入。

/**
 * 布尔量数组求假占比
 * @param arr
 * @precision, 保留几位小数
 * @returns {number}
 */
function boolRatio0(arr,precision) {
    var sum = 0;
    for (var i in arr) {
        if (arr[i] < 1) {
            sum++;
        }
    }
    var val = sum * 100 / arr.length;
    return precision==undefined?val:val.toFixed(precision);
}

sumproduct

加权求和。对一维数据进行加权求和。形如：sumproduct(array, [coef])。array为一维或二维数组。coef为权值，如果没有给coef值，则默认为1，等效于sum函数；如果coef为单值则所有元素权值相同；如果coef为一维数组，则与arr的某个维度等长。如果coef为二维数组，则系数全匹配。

/**
 * 加权求和
 * @param arr
 * @param coef 系数矩阵
 * @returns {number}
 */
function sumproduct(arr, coef) {
    var sum = 0;
    if (Array.isArray(arr) && !Array.isArray(arr[0])) {
        for (var i in arr) {
            if (coef == undefined || coef == null) {
                sum += arr[i];
            }
            else if (Array.isArray(coef)) {
                sum += arr[i] * coef[i];
            }
            else {
                sum += arr[i] * coef;
            }
        }
    }
    else if (Array.isArray(arr) && Array.isArray(arr[0])) {
        for (var i = 0; i < arr.length; i++) {
            for (var j = 0; j < arr[0].length; j++) {
                if (coef == undefined || coef == null) {
                    sum += arr[i][j];
                }
                else if (Array.isArray(coef) && !Array.isArray(coef[0])) {
                    if (coef.length == arr[0].length) {
                        sum += arr[i][j] * coef[j];
                    }
                    else if (coef.length == arr.length) {
                        sum += arr[i][j] * coef[i];
                    }
                    else {
                        sum += arr[i][j] * coef;
                    }
                } else if (Array.isArray(coef) && Array.isArray(coef[0])) {
                    sum += arr[i][j] * coef[i][j];
                } else {
                    sum += arr[i][j];
                }
            }
        }
    } else {
        sum = 0;
    }
    return sum;
}

sumaverage

加权平均。对一维数据进行加权平均。形如：sumaverage(array, [coef])。array为一维数组。coef为权值，如果没有给coef值，则默认为1，等效于average函数；如果coef为单值则所有元素权值相同；如果coef为数组，则长度必须与array等长。

/**
 * 加权平均
 * @param arr
 * @param coef
 * @param precision
 */
function sumaverage(arr, coef, precision) {
    var sum = sumproduct(arr, coef);
    var count;
    if (Array.isArray(arr) && !Array.isArray(arr[0])) {
        count = arr.length;
    } else if (Array.isArray(arr) && Array.isArray(arr[0])) {
        count = arr.length * arr[0].length;
    } else {
        count = 1;
    }

    var val = sum / count;
    return precision == undefined ? val : val.toFixed(precision);
}

sum

求和。对一维数据进行求和。

/**
 * 求和
 * @param arr
 */
function sum(arr) {
    return sumproduct(arr);
}

average

平均。对一维数据进行平均。

/**
 * 平均
 * @param arr
 * @param precision, 保留几位小数
 */
function average(arr, precision) {
    return sumaverage(arr, 1, exist(precision) ? precision : 1);
}

max

求数组的最大值。

/**
 * 求数组最大值
 * @param arr, 一维数组或二维数组
 * @returns {number}
 */
function max(arr) {
    var maxnum = -Infinity;
    if(!exist(arr)) return 0;
    if (Array.isArray(arr) && !Array.isArray(arr[0])) {
        maxnum = Math.max.apply(null, arr);
    }else if(Array.isArray(arr) && Array.isArray(arr[0])){
        for(var i=0;i<arr.length;i++){
            var tmp = Math.max.apply(null, arr[i]);
            if(tmp>maxnum){
                maxnum = tmp;
            }
        }
    }
    return maxnum;
}

min

求数组的最小值。

/**
 * 求数组最小值
 * @param arr
 * @returns {number}
 */
function min(arr) {
    var minnum = Infinity;
    if(!exist(arr)) return 0;
    if (Array.isArray(arr) && !Array.isArray(arr[0])) {
        minnum = Math.min.apply(null, arr);
    }else if(Array.isArray(arr) && Array.isArray(arr[0])){
        for(var i=0;i<arr.length;i++){
            var tmp = Math.min.apply(null, arr[i]);
            if(tmp<minnum){
                minnum = tmp;
            }
        }
    }
    return minnum;
}