make compute_error export a compute-error generating function,

- so that the opts object is destructure only once once per
  trace instead of on every data pt.

Author: etpinard

src/components/errorbars/calc.js

@@ -14,7 +14,7 @@ var isNumeric = require('fast-isnumeric');
 var Plots = require('../../plots/plots');
 var Axes = require('../../plots/cartesian/axes');
 
-var computeError = require('./compute_error');
+var makeComputeError = require('./compute_error');
 
 
 module.exports = function calc(gd) {
@@ -26,33 +26,36 @@ module.exports = function calc(gd) {
 
         if(!Plots.traceIs(trace, 'errorBarsOK')) continue;
 
-        var xObj = trace.error_x || {},
-            yObj = trace.error_y || {},
+        var xOpts = trace.error_x || {},
+            yOpts = trace.error_y || {},
             xa = Axes.getFromId(gd, trace.xaxis),
             ya = Axes.getFromId(gd, trace.yaxis),
-            xVis = (xObj.visible && ['linear', 'log'].indexOf(xa.type) !== -1),
-            yVis = (yObj.visible && ['linear', 'log'].indexOf(ya.type) !== -1);
+            xVis = (xOpts.visible && ['linear', 'log'].indexOf(xa.type) !== -1),
+            yVis = (yOpts.visible && ['linear', 'log'].indexOf(ya.type) !== -1);
 
         if(!xVis && !yVis) continue;
 
         var xVals = [],
             yVals = [];
 
+        var computeErrorY = makeComputeError(yOpts),
+            computeErrorX = makeComputeError(xOpts);
+
         for(var j = 0; j < calcTrace.length; j++) {
             var calcPt = calcTrace[j],
-                calcX = calcPt.x,
-                calcY = calcPt.y;
+                calcY = calcPt.y,
+                calcX = calcPt.x;
 
             if(!isNumeric(ya.c2l(calcY)) || !isNumeric(xa.c2l(calcX))) continue;
 
-            var errorY = computeError(calcY, j, yObj);
+            var errorY = computeErrorY(calcY, j);
             if(isNumeric(errorY[0]) && isNumeric(errorY[1])) {
                 calcPt.ys = calcY - errorY[0];
                 calcPt.yh = calcY + errorY[1];
                 yVals.push(calcPt.ys, calcPt.yh);
             }
 
-            var errorX = computeError(calcX, j, xObj);
+            var errorX = computeErrorX(calcX, j);
             if(isNumeric(errorX[0]) && isNumeric(errorX[1])) {
                 calcPt.xs = calcX - errorX[0];
                 calcPt.xh = calcX + errorX[1];

src/components/errorbars/compute_error.js

@@ -11,41 +11,64 @@
 
 
 /**
- * Compute the positive and negative error bar magnitudes.
+ * Error bar computing function generator
  *
  * N.B. This function does not clean the dataPt entries, non-numeric
  * entries result in undefined *error*
  *
- * @param {numeric} dataPt data point from where to compute the error magnitue
- * @param {number} index index of dataPt in its corresponding data array
  * @param {object} opts error bar attributes
  *
- * @return {array of two numbers}
- *      - error[0] : error magnitude in the negative direction
- *      - error[1] : " " " " positive "
+ * @return {function} :
+ *      @param {numeric} dataVal error magnitude in the negative direction
+ *      @param {number} index index of dataPt in its corresponding data array
+ *      @return {array}
+ *        - error[0] : error magnitude in the negative direction
+ *        - error[1] : " " " " positive "
  */
-module.exports = function computeError(dataPt, index, opts) {
+module.exports = function makeComputeError(opts) {
     var type = opts.type,
-        error = new Array(2);
+        symmetric = opts.symmetric;
 
     if(type === 'data') {
-        error[1] = +(opts.array[index]);
-        error[0] = (opts.symmetric || opts.arrayminus === undefined) ?
-            error[1] :
-            +(opts.arrayminus[index]);
+        var array = opts.array,
+            arrayminus = opts.arrayminus;
+
+        return (symmetric || arrayminus === undefined) ?
+            function computeError(dataPt, index) {
+                var val = +(array[index]);
+                return [val, val];
+            } :
+            function computeError(dataPt, index) {
+                return [+arrayminus[index], +array[index]];
+            };
     }
     else {
-        error[1] = getErrorVal(type, dataPt, opts.value);
-        error[0] = (opts.symmetric || opts.valueminus === undefined) ?
-            error[1] :
-            getErrorVal(type, dataPt, opts.valueminus);
-    }
+        var value = opts.value,
+            valueminus = opts.valueminus;
 
-
-    return error;
+        return (symmetric || valueminus === undefined) ?
+            function computeError(dataPt) {
+                var val = getErrorVal(type, dataPt, value);
+                return [val, val];
+            } :
+            function computeError(dataPt) {
+                return [
+                    getErrorVal(type, dataPt, valueminus),
+                    getErrorVal(type, dataPt, value)
+                ];
+            };
+    }
 };
 
-// size the error bar itself (for all types except data)
+/**
+ * Compute error bar magnitude (for all types except data)
+ *
+ * @param {string} type error bar type
+ * @param {numeric} dataPt
+ *      data point from where to compute the error magnitude
+ * @param {numeric} [value] error bar value
+ *
+ */
 function getErrorVal(type, dataPt, value) {
     if(type === 'percent') return Math.abs(dataPt * value / 100);
     if(type === 'constant') return Math.abs(value);

src/traces/scatter3d/calc_errors.js

@@ -9,16 +9,17 @@
 
 'use strict';
 
-var computeError = require('../../components/errorbars/compute_error');
+var makeComputeError = require('../../components/errorbars/compute_error');
 
 
 function calculateAxisErrors(data, params, scaleFactor) {
     if(!params || !params.visible) return null;
 
+    var computeError = makeComputeError(params);
     var result = new Array(data.length);
 
     for(var i = 0; i < data.length; i++) {
-        var errors = computeError(+data[i], i, params);
+        var errors = computeError(+data[i], i);
 
         result[i] = [
             -errors[0] * scaleFactor,