Calculate the absolute value element-wise.

        Returns:
          absolute (Timeseries):
            Absolute value. For complex input (a + b*j) gives sqrt(a**a + b**2)
484865
def absolute(self):
        
        return Timeseries(np.absolute(self), self.tspan, self.labels)
1254270
def getBottomLeft(self):
        
        return (float(self.get_cx()) - float(self.get_r()), float(self.get_cy()) - float(self.get_r()))
809123
def computeA(self, j, timeSeries):
        
        seasonLength = self.get_parameter("seasonLength")
        A_j = 0
        for i in range(seasonLength):
            A_j += timeSeries[(seasonLength * (j)) + i][1]
        return A_j / seasonLength
1105146
def Abs(input_vertex: vertex_constructor_param_types, label: Optional[str]=None) -> Vertex:
    
    return Double(context.jvm_view().AbsVertex, label, cast_to_double_vertex(input_vertex))
1305340
def is_absolute(self):
        

        # FIXME(Ole): It is unfortunate that decision about whether points
        # are absolute or not lies with the georeference object. Ross pointed this out.
        # Moreover, this little function is responsible for a large fraction of the time
        # using in data fitting (something in like 40 - 50%.
        # This was due to the repeated calls to allclose.
        # With the flag method fitting is much faster (18 Mar 2009).

        # FIXME(Ole): HACK to be able to reuse data already cached (18 Mar 2009).
        # Remove at some point
        if not hasattr(self, 'absolute'):
            self.absolute = num.allclose([self.xllcorner, self.yllcorner], 0)

        # Return absolute flag
        return self.absolute
1144288
def _mean_absolute_error(y, y_pred, w):
    """"""
    return np.average(np.abs(y_pred - y), weights=w)
331303
def compute_absolute_error(self, predicted_data, record, dataframe_record):
        ''''''
        absolute_error = abs(record['DDG'] - predicted_data[self.ddg_analysis_type])
        dataframe_record['AbsoluteError'] = absolute_error
1124205
def p_abs(p):
    
    if is_unsigned(p[2]):
        p[0] = p[2]
        warning(p.lineno(1), "Redundant operation ABS for unsigned value")
        return

    p[0] = make_builtin(p.lineno(1), 'ABS', p[2], lambda x: x if x >= 0 else -x)
1274979
def value(self):
        
        with self.lock:
            now = time.time()
            dt = now - self.t0
            self.t0 = now
            self.p = self.p * (math.pow(self.e, self.r * dt))
            return self.p
703224
def _sumSeries(a: float, b: float, steps: int) -> float:
        
        return a * (exp(b * steps) - 1) / (exp(b) - 1)
1367082
public static BigFloat abs(BigFloat x) {
		if (x.isSpecial())
			return x.isInfinity() ? POSITIVE_INFINITY : NaN;
		return x.context.valueOf(x.value.abs());
	}
940503
function absoluteValue(node) {
  if (!Node.Type.isFunction(node, 'abs')) {
    return Node.Status.noChange(node);
  }
  if (node.args.length > 1) {
    return Node.Status.noChange(node);
  }
  let newNode = clone(node);
  const argument = newNode.args[0];
  if (Node.Type.isConstant(argument, true)) {
    newNode = Node.Creator.constant(math.abs(argument.eval()));
    return Node.Status.nodeChanged(
      ChangeTypes.ABSOLUTE_VALUE, node, newNode);
  }
  else if (Node.Type.isConstantFraction(argument, true)) {
    const newNumerator = Node.Creator.constant(
      math.abs(argument.args[0].eval()));
    const newDenominator =  Node.Creator.constant(
      math.abs(argument.args[1].eval()));
    newNode = Node.Creator.operator('/', [newNumerator, newDenominator]);
    return Node.Status.nodeChanged(
      ChangeTypes.ABSOLUTE_VALUE, node, newNode);
  }
  else {
    return Node.Status.noChange(node);
  }
}
1109492
function absolute(rem){return{abs:{position:'absolute'},
top0:{top:0},
right0:{right:0},
bottom0:{bottom:0},
left0:{left:0},

top1:{top:1*rem},
right1:{right:1*rem},
bottom1:{bottom:1*rem},
left1:{left:1*rem},

top2:{top:2*rem},
right2:{right:2*rem},
bottom2:{bottom:2*rem},
left2:{left:2*rem},

top3:{top:3*rem},
right3:{right:3*rem},
bottom3:{bottom:3*rem},
left3:{left:3*rem},

top4:{top:4*rem},
right4:{right:4*rem},
bottom4:{bottom:4*rem},
left4:{left:4*rem},

z1:{zIndex:1,elevation:1},
z2:{zIndex:2,elevation:2},
z3:{zIndex:4,elevation:4},
z4:{zIndex:8,elevation:8}};

}
646431
def bbox(self):
        
        bbox = self._data.get(b'keyOriginShapeBBox')
        if bbox:
            return (
                bbox.get(b'Left').value,
                bbox.get(b'Top ').value,
                bbox.get(b'Rght').value,
                bbox.get(b'Btom').value,
            )
        return (0, 0, 0, 0)
305302
def getBottomRight(self):
        
        return (float(self.get_cx()) + float(self.get_rx()), float(self.get_cy()) - float(self.get_ry()))
55674
def alpha(self):
        
        return round(
            float(
                self.calc_alpha(
                    self.annualize_return,
                    self.benchmark_annualize_return,
                    self.beta,
                    0.05
                )
            ),
            2
        )
493572
def variable_absolute(self, a: float) -> mm.ModelMapper:
        
        return self.previous_variable.mapper_from_gaussian_tuples(self.gaussian_tuples, a=a)