Returns the maximum value of the domain.

        :rtype: `float` or `np.inf`
359445
def max(self):
        
        return int(self._max) if not np.isinf(self._max) else self._max
1355048
def max(cls):
        """"""
        max_recid = db.session.query(func.max(cls.recid)).scalar()
        return max_recid if max_recid else 0
1118372
def computeMaxPool(input_width):
  
  wout = math.floor((input_width + 2 * PADDING - KERNEL_SIZE) / STRIDE + 1)
  return int(math.floor(wout / 2.0))
942686
def lmax(self):
        
        """
        if self._lmax is None:
            self.logger.warning('The largest eigenvalue G.lmax is not '
                                'available, we need to estimate it. '
                                'Explicitly call G.estimate_lmax() or '
                                'G.compute_fourier_basis() '
                                'once beforehand to suppress the warning.')
            self.estimate_lmax()
        return self._lmax
1061493
def max_value_length(cls):
        
        if not hasattr(cls, '__max_value_length_'):
            cls.__max_value_length_ = max([len(c.value) for c in list(cls)])
        return cls.__max_value_length_
1143070
def max_n(self):
        """"""
        return max(term.max_n() for term in self.terms if term.ops)
1002177
def maxValue(self, value):
        """"""
        if isinstance(value, [int, float, long]):
            self._rangeMax = value
737017
def max(self):
        
        if(self._clean.isDict()):
            return self._wrap(list())
        return self._wrap(max(self.obj))
393415
def max(self):
        

        if len(self.regions) != 1:
            raise ClaripyVSAOperationError("'max()' onlly works on single-region value-sets.")

        return self.get_si(next(iter(self.regions))).max
605527
def get_domain(self):
        
        if self.polyhedra != []:
            polyhedras_domain = np.vstack([poly.get_domain() 
                                          for poly in self.polyhedra])
        else:
            polyhedras_domain = np.ones((0, 3))
        points = np.vstack((self.surface.get_domain(), 
                            polyhedras_domain, 
                            self.set_of_points))
        return np.array([points.min(axis=0), points.max(axis=0)])
770103
public double getMax() {
        double max = s.minValue();
        for (int c = 0; c < this.size(); c++) {
            double val = getValue(c);
            if (s.gte(val, max)) {
                max = val;
            }
        }
        return max;
    }
763292
def max(self):
        
        return round(np.max(self.array), self.precision)\
            if len(self.array) else None
1188647
public static int whichMax(float[] x) {
        float m = Float.NEGATIVE_INFINITY;
        int which = 0;

        for (int i = 0; i < x.length; i++) {
            if (x[i] > m) {
                m = x[i];
                which = i;
            }
        }

        return which;
    }
463710
def lambda_max(self):
        """"""
        return ((const.b_wien.value / self.temperature) * u.m).to(u.AA).value
223444
def calc_limits(data, dist=None, padding=0.25):
    
    dmin = sys.float_info.max if dist is None else dist.get('min',
                                                            sys.float_info.max)
    dmax = sys.float_info.min if dist is None else dist.get('max',
                                                            sys.float_info.min)
    _min = min(min(data), dmin)
    _max = max(max(data), dmax)

    padding = padding * (_max - _min)
    return _min - padding, _max + padding
125447
def maximum(self, vars_list: List[str]) -> 'TensorFluent':
        '''
        '''
        return self._aggregation_op(tf.reduce_max, self, vars_list)
1096216
function argnanmax( arr ) {
	if ( !Array.isArray( arr ) ) {
		throw new TypeError( 'argnanmax()::invalid input argument. Must provide an array.' );
	}
	var len = arr.length,
		max = Number.NEGATIVE_INFINITY,
		idx = [],
		val;

	for ( var i = 0; i < len; i++ ) {
		val = arr[ i ];
		if ( typeof val !== 'number' || val !== val ) {
			continue;
		}
		if ( val > max ) {
			max = val;
			idx.length = 0;
			idx.push( i );
		}
		else if ( val === max ) {
			idx.push( i );
		}
	}
	return idx;
}