Return the current best value of a parameter
543123
def parameter(self):
        """"""
        D = {}
        for source in PARAM_SOURCE_ORDER:
            D.update(self.params[source])
        return D
319708
function() {
    // Make sure the true largest value is used for max
    return this.options.line ? { start_value: 0, max: Helpers.max([Helpers.max(this.options.line), Helpers.max(this.flat_data)]) } : { start_value: 0 };
  }
880722
def current_parameters(self):
        
        current = []
        for core_param in range(len(self.q)):
            for approx_param in range(self.q[core_param].param_no):
                current.append(self.q[core_param].vi_return_param(approx_param))
        return np.array(current)
1355048
def max(cls):
        """"""
        max_recid = db.session.query(func.max(cls.recid)).scalar()
        return max_recid if max_recid else 0
1127865
def currentValue(self):
        
        enum  = self.enum()
        if ( self.isCheckable() ):
            value = 0
            for i in self.checkedIndexes():
                value |= enum[nativestring(self.itemText(i))]
            return value
        else:
            try:
                return enum[nativestring(self.itemText(self.currentIndex()))]
            except KeyError:
                return 0
897002
def getParam(self, paramName):
        
        param = getattr(self, paramName)
        if isinstance(param, Param):
            return param
        else:
            raise ValueError("Cannot find param with name %s." % paramName)
1252290
def GetValue(self):
    '''
    
    '''
    self.AssertInitialization('Positional')
    if str(self._widget.GetValue()) == EMPTY:
      return None
    return self._widget.GetValue()
216212
def GetValue(self):
    '''
    
    '''
    self.AssertInitialization('Choice')
    if self._widget.GetValue() == self._DEFAULT_VALUE:
      return None
    return ' '.join(
      [self._action.option_strings[0] if self._action.option_strings else '',  # get the verbose copy if available
       self._widget.GetValue()])
608428
def get(self, name, default=None):
        """"""
        value = self.parameters.get(name)
        self._processed_parameters.append(name)
        if value is None:
            return default
        return value
685265
def get_current():
    """"""
    global current
    if exists( SETTINGSFILE ):
        f = open( SETTINGSFILE ).read()
        current = re.findall('config[^\s]+.+', f)[1].split('/')[-1]
        return current
    else:
        return "** Not Set **"
820510
def pop_parameter(key):
    '''

    '''
    names = key.split('/')
    if len(names) > 1:
        with parameter_scope(names[0]):
            return pop_parameter('/'.join(names[1:]))
    global current_scope
    param = current_scope.get(key, None)
    if param is not None:
        del current_scope[key]
    return param
696024
def best(self):
        
        best = None
        for assoc in self.assocs.values():
            if best is None or best.issued < assoc.issued:
                best = assoc
        return best
674287
@Override
    public V getBest(String s, int offset, int length) {
        return getBest(0, s, offset, length);
    }
778886
def current(cls, with_exception=True):
        
        if with_exception and len(cls.stack) == 0:
            raise NoContext()
        return cls.stack.top()
55389
def GET_parameteritemvalues(self) -> None:
        """"""
        for item in state.parameteritems:
            self._outputs[item.name] = item.value
92066
def param(self,key,default=None):
        """"""
        if key in self.parameters:
            return self.parameters[key]
        return default
372966
function getMaxY() {
    if (self.options.maxY) {
      return self.options.maxY;
    }

    var max = -Infinity;

    for(let i = 0; i < data.length; i++) {
      if (data[i].y.length) {
        var current = _.max(data[i].y, parseFloat);
        if (current > max) {
          max = current;
        }
      }
    }

    return max + (max - self.options.minY) * 0.2;
  }