How to use the mathjs.sum function in mathjs

//  console.log('low:\t', low);
                
              if(percentvar > low){
                  var lowper = low - percentvar;
                  Lowdiff.push(lowper);
              }  
              if(percentvar < top){
                var topper = top - percentvar;
                Topdiff.push(topper);
            }           
                
                  if(Lowdiff.length > 20){Lowdiff.shift()}
                  if(Topdiff.length > 20){Topdiff.shift()}
                
                  lowup = math.sum(Lowdiff) / Lowdiff.length;
                  topup = math.sum(Topdiff) / Topdiff.length;


              //  console.log('topup', topup);
              //  console.log('differnce:', lowper);
              //  console.log('lowup', lowup);
               // console.log(' ');

                global.sig0 = global.meanp < global.mean && meanp != 0

                if (global.sig0 === false  && percentvar > low){
                  ManageSize();
                }
                
                if (global.sig0 === false  && percentvar > (low - lowup) && hasbought === false && candle.close > previousprice)
                   {

sum: function(v) {
        return m.sum(v);
    },
    // sum the rows in matrix a, return column

        function f(x) { return m.sum(x); }
        return _.map(a, f);

} else {
                result.errors[error] = count;
            }
        });
    });

    result.latency.median = math.median(requestMedians);
    result.latency.min = math.min(requestMins);
    result.latency.max = math.max(requestMaxs);
    result.latency.p95 = math.sum(request95) / result.requestsCompleted;
    result.latency.p99 = math.sum(request99) / result.requestsCompleted;

    result.scenarioDuration.median = math.median(scenarioMedians);
    result.scenarioDuration.min = math.min(scenarioMins);
    result.scenarioDuration.max = math.max(scenarioMaxs);
    result.scenarioDuration.p95 = math.sum(scenario95) / result.scenariosCompleted;
    result.scenarioDuration.p99 = math.sum(scenario99) / result.scenariosCompleted;

    return result;
}

const halfwidth = weights.map((weight, idx) => {
        const V1 = math.sum(weight)
        const V2 = math.multiply(weight, weight)
        const intervalEstimate = Math.sqrt(math.multiply(math.square(residuals[idx]), weight) / (V1 - V2 / V1))
        return intervalEstimate * z
      })
      Object.assign(output, {halfwidth})

} else {
                result.errors[error] = count;
            }
        });

        result.rps.count += stats.rps.count;
        result.requestsCompleted += stats.requestsCompleted;

        result.pendingRequests += stats.pendingRequests;
    });

    result.rps.mean = result.rps.count / STATS_INTERVAL;
    result.latency.median = math.median(medians);
    result.latency.min = math.min(mins);
    result.latency.max = math.max(maxs);
    result.latency.p95 = math.sum(request95) / result.requestsCompleted;
    result.latency.p99 = math.sum(request99) / result.requestsCompleted;

    result.scenarioDuration.p95 = math.sum(scenario95) / result.scenariosCompleted;
    result.scenarioDuration.p99 = math.sum(scenario99) / result.scenariosCompleted;

    return result;
}

result.codes[code.toString()] = count;
            }
        });
        _.each(stats.errors, function (count, error) {
            if (result.errors[error]) {
                result.errors[error] += count;
            } else {
                result.errors[error] = count;
            }
        });
    });

    result.latency.median = math.median(requestMedians);
    result.latency.min = math.min(requestMins);
    result.latency.max = math.max(requestMaxs);
    result.latency.p95 = math.sum(request95) / result.requestsCompleted;
    result.latency.p99 = math.sum(request99) / result.requestsCompleted;

    result.scenarioDuration.median = math.median(scenarioMedians);
    result.scenarioDuration.min = math.min(scenarioMins);
    result.scenarioDuration.max = math.max(scenarioMaxs);
    result.scenarioDuration.p95 = math.sum(scenario95) / result.scenariosCompleted;
    result.scenarioDuration.p99 = math.sum(scenario99) / result.scenariosCompleted;

    return result;
}

});

        result.rps.count += stats.rps.count;
        result.requestsCompleted += stats.requestsCompleted;

        result.pendingRequests += stats.pendingRequests;
    });

    result.rps.mean = result.rps.count / STATS_INTERVAL;
    result.latency.median = math.median(medians);
    result.latency.min = math.min(mins);
    result.latency.max = math.max(maxs);
    result.latency.p95 = math.sum(request95) / result.requestsCompleted;
    result.latency.p99 = math.sum(request99) / result.requestsCompleted;

    result.scenarioDuration.p95 = math.sum(scenario95) / result.scenariosCompleted;
    result.scenarioDuration.p99 = math.sum(scenario99) / result.scenariosCompleted;

    return result;
}

loadSpots(spots, tissueMask) {
        const ds = _.filter(_.map(spots, _.last), x => x > 0);
        this.avgDiameter = math.sum(ds) / ds.length;
        this.spots = _.map(spots, props => this.createSpot(...props));
        if (tissueMask) {
            this.loadMask(tissueMask);
        }
    }

export function isInside(point, corners) {
  const { topLeft, topRight, bottomLeft, bottomRight } = corners;
  const triangles = [
    findTriangleArea(topLeft, point, bottomRight),
    findTriangleArea(bottomRight, point, bottomLeft),
    findTriangleArea(bottomLeft, point, topRight),
    findTriangleArea(point, topRight, topLeft)
  ];
  return sum(...triangles) <= findRectangleArea(corners);
}