Returns the absolute value of a number
180226
def _abs(ctx, number):
    
    return conversions.to_decimal(abs(conversions.to_decimal(number, ctx)), ctx)
115277
def _convert_number(self, number):
        """"""

        number = float(number)
        return int(number) if number.is_integer() else float(number)
749653
def number(self):
        
        return int(math.ceil(self.total_size / float(self.size)))
582143
public long getCurrentValue(int nth) {
    long v = min.getCurrent(nth).get();
    return (v == Long.MAX_VALUE) ? 0L : v;
  }
1066532
function( v ) {
			v = +v;
			if ( isNaN( v ) ) return +0;
			if ( v === 0 || !isFinite( v ) ) return v;
			return ( v < 0 ? -1 : 1 ) * abs( floor( v ) );
		}
423849
function(a) {
    var i, v, m = 0xff00;
    for (i = 0; i < a.length; ++i) {
      v = a[i];
      a[i] = (v >>> 24) | ((v >>> 8) & m) | ((v & m) << 8) | (v << 24);
    }
    return a;
  }
528324
function(){
    var s = this.selection.selection;
    return Math.abs(s.second.x - s.first.x) >= 5 || 
           Math.abs(s.second.y - s.first.y) >= 5;
  }
1018080
function() {
            	var m = 0, i = this.elements.length, nj = this.elements[0].length, j;
            	while (i--) {
            	    j = nj;
            	    while (j--) {
            		if (Math.abs(this.elements[i][j]) > Math.abs(m)) { m = this.elements[i][j]; }
            	    }
            	}
            	return m;
                }
1028796
def decimals(self):
        
        self._decimals, value = self.get_attr_int(self._decimals, 'decimals')
        return value
658463
function abs()
    {
        $temp = new static();

        switch (MATH_BIGINTEGER_MODE) {
            case self::MODE_GMP:
                $temp->value = gmp_abs($this->value);
                break;
            case self::MODE_BCMATH:
                $temp->value = (bccomp($this->value, '0', 0) < 0) ? substr($this->value, 1) : $this->value;
                break;
            default:
                $temp->value = $this->value;
        }

        return $temp;
    }
520061
function() {
    var m = 0, ni = this.elements.length, ki = ni, i, nj, kj = this.elements[0].length, j;
    do { i = ki - ni;
      nj = kj;
      do { j = kj - nj;
        if (Math.abs(this.elements[i][j]) > Math.abs(m)) { m = this.elements[i][j]; }
      } while (--nj);
    } while (--ni);
    return m;
  }
355934
function _toInteger (value) {
    var n = +value;

    if (n !== n) { // eslint-disable-line no-self-compare
        return 0;
    } else if (n % 1 === 0) {
        return n;
    } else {
        return Math.floor(Math.abs(n)) * (n < 0 ? -1 : 1);
    }
}
608988
protected int absolutePosition()
  {
    if (tc.isEntryEnabled()) Tr.entry(tc, "absolutePosition", this);
    if (tc.isEntryEnabled()) Tr.exit(tc, "absolutePosition", new Integer(_absolutePosition));
    return _absolutePosition;
  }
278681
function (num) {
      switch (typeof num) {
        case 'number':
          return num;
        case 'string':
          if (!isNaN(num)) {
            return num.indexOf('.') > -1 ? parseFloat(num) : parseInt(num, 10);
          }
      }

      return num;
    }
742096
function (num, min, max) {
        if (typeof num !== 'number' || num < min) {
            return min;
        }
        if (num === Infinity) {
            return _.isNil(max) ? min : max;
        }

        return num;
    }
260846
private static Object toExternalNumber( BigDecimal number)
    {
    return
      Optional.ofNullable(
        toObject(
          number,
          ObjectUtils::toInt,
          ObjectUtils::toLong))

      .orElse( number);
    }
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);
  }
}