Returns the maximum value for this ruler.  If the cached value is None,
        then a default value will be specified based on the ruler type.
        
        :return     <variant>
485798
def maximum( self ):
        
        if ( self._maximum is not None ):
            return self._maximum
        
        rtype = self.rulerType()
        
        if ( rtype == XChartRuler.Type.Number ):
            self._maximum = 100
            
        elif ( rtype == XChartRuler.Type.Date ):
            self._maximum = QDate.currentDate().addDays(10)
        
        elif ( rtype == XChartRuler.Type.Datetime ):
            self._maximum = QDateTime.currentDateTime().addDays(10)
        
        elif ( rtype == XChartRuler.Type.Time ):
            self._maximum = QDateTime.currentDateTime().time().addSecs(60 * 60)
            
        else:
            notches = self.notches()
            if ( notches ):
                self._maximum = notches[-1]
                
        return self._maximum
908682
def get_default_value(self):
        

        if self.choices:
            return self.choices[0]

        value = self.attribute_type()

        if self.attribute_type is time:
            value = int(value)

        elif self.attribute_type is str:
            value = "A"

        if self.min_length:
            if self.attribute_type is str:
                value = value.ljust(self.min_length, 'a')
            elif self.attribute_type is int:
                value = self.min_length

        elif self.max_length:
            if self.attribute_type is str:
                value = value.ljust(self.max_length, 'a')
            elif self.attribute_type is int:
                value = self.max_length

        return value
359445
def max(self):
        
        return int(self._max) if not np.isinf(self._max) else self._max
1280206
def delete_max(self):
        

        # Attempt to rotate left-leaning reds to the right.
        if self.left.red:
            self = self.rotate_right()

        # Base case: If there are no selfs greater than this self, then this is
        # the self to delete.
        if self.right is NULL:
            return NULL, self.value

        # Acquire more reds if necessary to continue the traversal. NULL is
        # red so this check doesn't need to check for NULL.
        if not self.right.red and not self.right.left.red:
            self = self.move_red_right()

        # Recursive case: Delete the maximum self of all selfs greater than this
        # self.
        right, value = self.right.delete_max()
        self = self._replace(right=right)

        return self.balance(), value
464247
public int getMax() {
        List<Integer> value = new ArrayList<Integer>();
        for (AnalysisType at : analysisType) {
            value.add(at.getValue());
        }
        return Collections.max(value);
    }
981058
private boolean updateMinMaxValues() {

        double min_x_value_new;
        double max_x_value_new;
        double max_y_value_new;

        if (this.measures == null) {
            // no values received yet -> reset axes
            min_x_value_new = 0;
            max_x_value_new = 1;
            max_y_value_new = 1;
        } else {
            min_x_value_new = getMinXValue();
            max_x_value_new = getMaxXValue();
            max_y_value_new = getMaxSelectedValue();
        }

        // resizing needed?
        if (min_x_value_new != this.min_x_value
                || max_x_value_new != this.max_x_value
                || max_y_value_new != this.max_y_value) {
            this.min_x_value = min_x_value_new;
            this.max_x_value = max_x_value_new;
            this.max_y_value = max_y_value_new;
            updateMinXValue();
            updateMaxXValue();
            updateMaxYValue();
            updateLowerXValue();
            updateUpperXValue();
            updateUpperYValue();
            return true;
        }
        return false;
    }
704966
public java.lang.Object getMax() {
		return (java.lang.Object) getStateHelper().eval(PropertyKeys.max, 100);
	}
859719
def values(self):
        
        if self.is_finite:
            return np.arange(self.min, self.max + 1, dtype = self.dtype)
        else:
            return self.example_point
1016126
public long getMax() {
		int lastBin = hits.length() - 1;
		if (hits.get(lastBin) > 0) {
			return Long.MAX_VALUE;
		}

		for (int i = lastBin - 1; i >= 0; i--) {
			if (hits.get(i) > 0) {
				return bins[i];
			}
		}
		return 0;
	}
573707
def get_default_value(self):
        
        default = self.default_value
        if isinstance(default, collections.Callable):
            default = default()
        return default
737017
def max(self):
        
        if(self._clean.isDict()):
            return self._wrap(list())
        return self._wrap(max(self.obj))
789776
def max(self, property):
        
        self.__prepare()
        try:
            return max(self._json_data, key=lambda x: x[property]).get(property)
        except KeyError:
            raise KeyError("Key is not exists")
6109
def step( self ):
        
        if ( self._step is not None ):
            return self._step
        
        elif ( self.rulerType() == XChartRuler.Type.Number ):
            self._step = int((self.maximum() - self.minimum()) / 10.0)
        
        elif ( self.rulerType() == XChartRuler.Type.Date ):
            
            self._step = int(self.minimum().daysTo(self.maximum()) / 10.0) - 1
        
        elif ( self.rulerType() & (XChartRuler.Type.Time | \
                                   XChartRuler.Type.Datetime) ):
            self._step = int(self.minimum().secsTo(self.maximum()) / 10.0) - 1
        
        return self._step
398700
public final int getMaxValue(int which) {
        int max;

        max=indexes[IX_MAX_VALUES];
        switch(which) {
        case UProperty.BIDI_CLASS:
            return (max&CLASS_MASK);
        case UProperty.JOINING_GROUP:
            return (max&MAX_JG_MASK)>>MAX_JG_SHIFT;
        case UProperty.JOINING_TYPE:
            return (max&JT_MASK)>>JT_SHIFT;
        case UProperty.BIDI_PAIRED_BRACKET_TYPE:
            return (max&BPT_MASK)>>BPT_SHIFT;
        default:
            return -1; /* undefined */
        }
    }
1060100
private boolean updateMinMaxValues() {
        double min_y_value_new = min_y_value;
        double max_y_value_new = max_y_value;
        double max_x_value_new = max_x_value;

        if (measure0 != null && measure1 != null) {
            min_y_value_new = Math.min(measure0.getMinValue(measureSelected), measure1.getMinValue(measureSelected));
            max_y_value_new = Math.max(measure0.getMaxValue(measureSelected), measure1.getMaxValue(measureSelected));
            max_x_value_new = Math.max(measure0.getNumberOfValues(measureSelected), max_x_value);
        } else {
            if (measure0 != null) {
                min_y_value_new = measure0.getMinValue(measureSelected);
                max_y_value_new = measure0.getMaxValue(measureSelected);
                max_x_value_new = Math.max(measure0.getNumberOfValues(measureSelected), max_x_value);
            }
        }

        //resizing needed?
        if (max_x_value_new != max_x_value || max_y_value_new != max_y_value || min_y_value_new != min_y_value) {
            min_y_value = min_y_value_new;
            max_y_value = max_y_value_new;
            max_x_value = max_x_value_new;
            return true;
        }
        return false;
    }
977649
def max_value(self):
        

        if self._is_completely_masked:
            return np.nan * self._data_unit
        else:
            return np.max(self.values)
722174
def find_max(self, predicate, max_=None):
        
        if predicate(self.value):
            max_ = self.value
            next_node = self._greater
        else:
            next_node = self._lesser
        if next_node is None:
            return max_
        return next_node.find_max(predicate, max_)