Returns the step value for this ruler.  If the cached value is None,
        then a default value will be specified based on the ruler type.
        
        :return     <variant>
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
1274871
def getDefaultUncertainty(self, result=None):
        

        if result is None:
            result = self.getResult()

        uncertainties = self.getUncertainties()
        if uncertainties:
            try:
                res = float(result)
            except (TypeError, ValueError):
                # if analysis result is not a number, then we assume in range
                return None

            for d in uncertainties:
                _min = float(d['intercept_min'])
                _max = float(d['intercept_max'])
                if _min <= res and res <= _max:
                    if str(d['errorvalue']).strip().endswith('%'):
                        try:
                            percvalue = float(d['errorvalue'].replace('%', ''))
                        except ValueError:
                            return None
                        uncertainty = res / 100 * percvalue
                    else:
                        uncertainty = float(d['errorvalue'])

                    return uncertainty
        return None
124041
def value(self, progress_indicator):
        
        if progress_indicator <= self.end_of_interpolation:
            return interpolate.interpolate_linear_single(
                self.initial_value, self.final_value, progress_indicator/self.end_of_interpolation
            )
        else:
            return self.final_value
563133
def default_value(self):
        
        if self.has_default:
            if hasattr(self.default, '__call__'):
                return self.default()
            else:
                return self.default
        else:
            raise Exception("No default value specified")
478154
def value(self):
        
        if self.mosaicMethod == "esriMosaicNone" or\
           self.mosaicMethod == "esriMosaicCenter" or \
           self.mosaicMethod == "esriMosaicNorthwest" or \
           self.mosaicMethod == "esriMosaicNadir":
            return {
                "mosaicMethod" : "esriMosaicNone",
                "where" : self._where,
                "ascending" : self._ascending,
                "fids" : self.fids,
                "mosaicOperation" : self._mosaicOperation
            }
        elif self.mosaicMethod == "esriMosaicViewpoint":
            return {
                "mosaicMethod" : "esriMosaicViewpoint",
                "viewpoint" : self._viewpoint.asDictionary,
                "where" : self._where,
                "ascending" : self._ascending,
                "fids" : self._fids,
                "mosaicOperation" : self._mosaicOperation
            }
        elif self.mosaicMethod == "esriMosaicAttribute":
            return {
                "mosaicMethod" : "esriMosaicAttribute",
                "sortField" : self._sortField,
                "sortValue" : self._sortValue,
                "ascending" : self._ascending,
                "where" : self._where,
                "fids" : self._fids,
                "mosaicOperation" : self._mosaicOperation
            }
        elif self.mosaicMethod == "esriMosaicLockRaster":
            return {
                "mosaicMethod" : "esriMosaicLockRaster",
                "lockRasterIds" : self._localRasterIds,
                "where" : self._where,
                "ascending" : self._ascending,
                "fids" : self._fids,
                "mosaicOperation" : self._mosaicOperation
            }
        elif self.mosaicMethod == "esriMosaicSeamline":
            return {
                "mosaicMethod" : "esriMosaicSeamline",
                "where" : self._where,
                "fids" : self._fids,
                "mosaicOperation" : self._mosaicOperation
            }
        else:
            raise AttributeError("Invalid Mosaic Method")
921522
def get_value(self, index=None):
        

        if self.value is None:
            return self.default
        if index is not None:
            if self.value[index] is None:
                return self.default
            else:
                value = self.value[index]
        else:
            value = self.value

        return value
734358
def getIndexForValue(self, value):
        
        return math.trunc(self.slope * float(value) + self.intercept)
346669
def get_default_value(self, state):
        
        if self._default_value_generator:
            return self._default_value_generator(state)
        else:
            return state.project.simos.get_default_value_by_type(self.element_type, state=state)
1236388
function(oStep){
		var sTooltip = oStep.getTooltip_AsString();
		if (!sTooltip && !oStep.getTooltip() && sap.ui.getCore().getConfiguration().getAccessibility()) {
			sTooltip = getText("RDMP_DEFAULT_STEP_TOOLTIP", [oStep.__stepName]);
		}
		return sTooltip || "";
	}
511026
def value(self) -> Optional[int]:
        
        if self.symbolic:
            return None
        assert isinstance(self.raw, z3.BitVecNumRef)
        return self.raw.as_long()
200842
def get_next_step(self):
        
        layer_purpose = self.parent.step_kw_purpose.selected_purpose()
        if layer_purpose != layer_purpose_aggregation:
            subcategory = self.parent.step_kw_subcategory.\
                selected_subcategory()
        else:
            subcategory = {'key': None}

        # Has classifications, go to multi classifications
        if subcategory.get('classifications'):
            if layer_purpose == layer_purpose_hazard:
                return self.parent.step_kw_multi_classifications

        # Check if it can go to inasafe field step
        non_compulsory_fields = get_non_compulsory_fields(
            layer_purpose['key'], subcategory['key'])
        if not skip_inasafe_field(self.parent.layer, non_compulsory_fields):
            # Do not go to InaSAFE Field step if we already visited it.
            # For example in place exposure.
            if (self.parent.step_kw_inasafe_fields not in
                    self.parent.keyword_steps):
                return self.parent.step_kw_inasafe_fields

        # Check if it can go to inasafe default field step
        default_inasafe_fields = get_fields(
            layer_purpose['key'],
            subcategory['key'],
            replace_null=True,
            in_group=False)
        if default_inasafe_fields:
            return self.parent.step_kw_default_inasafe_fields

        # Any other case
        return self.parent.step_kw_source
1084277
def step(self, **kwargs):
        
        kwargs.setdefault('linestyle', kwargs.pop('where', 'steps-post'))
        data = self.append(self.value[-1:], inplace=False)
        return data.plot(**kwargs)
862429
def default_value(self):
        
        data = clips.data.DataObject(self._env)

        lib.EnvDeftemplateSlotDefaultValue(
            self._env, self._tpl, self._name, data.byref)

        return data.value
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()])
964854
def get_next_step(self):
        
        if is_raster_layer(self.parent.layer):
            new_step = self.parent.step_kw_band_selector
        else:
            new_step = self.parent.step_kw_layermode
        return new_step
681519
public String getAccuracy() {
    if (Measure_Type.featOkTst && ((Measure_Type)jcasType).casFeat_accuracy == null)
      jcasType.jcas.throwFeatMissing("accuracy", "ch.epfl.bbp.uima.types.Measure");
    return jcasType.ll_cas.ll_getStringValue(addr, ((Measure_Type)jcasType).casFeatCode_accuracy);}
225731
private int getCurrentStep() {
        int step = -1;
        try {
            XPropertySet xDialogModelPropertySet = (XPropertySet) UnoRuntime.queryInterface(XPropertySet.class, m_xMSFDialogModel);
            step = ((Integer) xDialogModelPropertySet.getPropertyValue("Step")).intValue();
        } catch (com.sun.star.uno.Exception exception) {
            exception.printStackTrace(System.out);
        }
        return step;
    }