Recall the maximum r (triangle furthest from the center of the star) of
        this star at the given time

        :return: maximum r
        :rtype: float
760438
def instantaneous_maxr(self):
        
        logger.debug("{}.instantaneous_maxr".format(self.component))

        if 'maxr' not in self.inst_vals.keys():
            logger.debug("{}.instantaneous_maxr COMPUTING".format(self.component))

            self.inst_vals['maxr'] = max(self.mesh.rs.centers*self._scale)

        return self.inst_vals['maxr']
712889
def B(self):
        '''
        
        '''
        return Point(self.maxX, self.minY, self.origin.z)
665545
def D(self):
        '''
        
        '''
        return Point(self.minX, self.maxY, self.origin.z)
1055522
def max_effect_length(self):
        
        # Method: using each solid's bounding box:
        #   - get vector from start to bounding box center
        #   - get vector from bounding box center to any corner
        #   - add the length of both vectors
        #   - return the maximum of these from all solids
        def max_length_iter():
            for part in self.parts:
                if part.local_obj.findSolid():
                    bb = part.local_obj.findSolid().BoundingBox()
                    yield abs(bb.center - self.location.origin) + (bb.DiagonalLength / 2)
        try:
            return max(max_length_iter())
        except ValueError as e:
            # if iter returns before yielding anything
            return 0
201563
def max(x, y, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_max,
        (
            BigFloat._implicit_convert(x),
            BigFloat._implicit_convert(y),
        ),
        context,
    )
1368836
def get_closest_points(self, max_distance=None, origin_index=0, origin_raw=None):
        
        if not self.dict_response['distance']['value']:
            self.get_distance_values()

        if origin_raw:
            origin = copy.deepcopy(self.dict_response['distance']['value'][origin_raw])
        else:
            origin = copy.deepcopy(self.dict_response['distance']['value'][self.origins[origin_index]])

        tmp_origin = copy.deepcopy(origin)
        if max_distance is not None:
            for k, v in tmp_origin.iteritems():
                if v > max_distance or v == 'ZERO_RESULTS':
                    del(origin[k])

        return origin
19690
def _find_max_lag(x, rho_limit=0.05, maxmaxlag=20000, verbose=0):
    """"""

    # Fetch autocovariance matrix
    acv = autocov(x)
    # Calculate rho
    rho = acv[0, 1] / acv[0, 0]

    lam = -1. / np.log(abs(rho))

    # Initial guess at 1.5 times lambda (i.e. 3 times mean life)
    maxlag = int(np.floor(3. * lam)) + 1

    # Jump forward 1% of lambda to look for rholimit threshold
    jump = int(np.ceil(0.01 * lam)) + 1

    T = len(x)

    while ((abs(rho) > rho_limit) & (maxlag < min(T / 2, maxmaxlag))):

        acv = autocov(x, maxlag)
        rho = acv[0, 1] / acv[0, 0]
        maxlag += jump

    # Add 30% for good measure
    maxlag = int(np.floor(1.3 * maxlag))

    if maxlag >= min(T / 2, maxmaxlag):
        maxlag = min(min(T / 2, maxlag), maxmaxlag)
        "maxlag fixed to %d" % maxlag
        return maxlag

    if maxlag <= 1:
        print_("maxlag = %d, fixing value to 10" % maxlag)
        return 10

    if verbose:
        print_("maxlag = %d" % maxlag)
    return maxlag
1301175
def R(self):
        ''
        self._check_estimated()
        if not self._estimation_finished:
            self._finish_estimation()
        return self._R
641012
def maximum_distance(value):
    
    dic = floatdict(value)
    for trt, magdists in dic.items():
        if isinstance(magdists, list):  # could be a scalar otherwise
            magdists.sort()  # make sure the list is sorted by magnitude
            for mag, dist in magdists:  # validate the magnitudes
                magnitude(mag)
    return IntegrationDistance(dic)
1174769
function(node, l, b, r, t)
{
    return (max(node.bb_r, r) - min(node.bb_l, l))*(max(node.bb_t, t) - min(node.bb_b, b));
}
4550
def get_ra(self):
        

        try:

            return self.ra.value

        except AttributeError:

            # Transform from L,B to R.A., Dec

            return self.sky_coord.transform_to('icrs').ra.value
1135782
def bounds(self):
        
        return np.array([self.vertices.min(axis=0),
                         self.vertices.max(axis=0)])
937337
def nRows(self):
        """"""
        if self.nCols: return max([len(x) for x in self.colData])
        else: return 0
359445
def max(self):
        
        return int(self._max) if not np.isinf(self._max) else self._max
1291257
def MaximumLikelihood(self):
        
        prob, val = max((prob, val) for val, prob in self.Items())
        return val
417985
def effective_max_ar_order(self):
        
        return min(self.max_ar_order, self.ma.order-self.ma.turningpoint[0]-1)
667810
def get_max_bond_distance(self, el1_sym, el2_sym):
        
        return sqrt(
            (self.el_radius[el1_sym] + self.el_radius[el2_sym] + self.tol) ** 2)