Set the 'actual step' parameter for a given pattern.

        Args:
            * patternnumber (integer): 0-7
            * value (integer): 0-7
429686
def set_pattern_actual_step(self, patternnumber, value):
        
        _checkPatternNumber(patternnumber)
        _checkStepNumber(value)
        
        address = _calculateRegisterAddress('actualstep', patternnumber)
        self.write_register(address, value, 0)
852417
def setParams(self, minSupport=0.1, maxPatternLength=10, maxLocalProjDBSize=32000000,
                  sequenceCol="sequence"):
        
        kwargs = self._input_kwargs
        return self._set(**kwargs)
1017699
function setPattern(ptnMap, pattern) {
      if (ptnMap && isStr(ptnMap)) {
        isReg(pattern) ? patterns[ptnMap] = pattern : throwErr('reg');
      } else if (isObj(ptnMap)) {
        forIn(ptnMap, function (ptn, ptnVal) {
          isReg(ptnVal) ? patterns[ptn] = ptnVal : throwErr('reg');
        });
      };
    }
333048
private static boolean hasNumberMacro(String pattern, String macroStart, String macroEnd) {

        String macro = I_CmsFileNameGenerator.MACRO_NUMBER;
        String macroPart = macroStart + macro + MACRO_NUMBER_DIGIT_SEPARATOR;
        int prefixIndex = pattern.indexOf(macroPart);
        if (prefixIndex >= 0) {
            // this macro contains an individual digit setting
            char n = pattern.charAt(prefixIndex + macroPart.length());
            macro = macro + MACRO_NUMBER_DIGIT_SEPARATOR + n;
        }
        return pattern.contains(macroStart + macro + macroEnd);
    }
772778
def sub_step(value, type = :next)
      val = value.abs
      type = :prev if value < 0
      command(type == :next ? "sub_step #{val}" : "sub_step #{-val}" )
    end
1370406
@SuppressWarnings("unchecked")
    private Comparable increment(Object value, Number step) {
        return (Comparable) plus((Number) value, step);
    }
282425
public static int[] setSteps(Last[][][] traceback, boolean local, int[] xyMax, Last last, List<Step> sx,
			List<Step> sy) {
		int x = xyMax[0], y = xyMax[1];
		boolean linear = (traceback[x][y].length == 1);
		while (local ? (linear ? last : traceback[x][y][last.ordinal()]) != null : x > 0 || y > 0) {
			switch (last) {
			case DELETION:
				sx.add(Step.COMPOUND);
				sy.add(Step.GAP);
				last = linear ? traceback[--x][y][0] : traceback[x--][y][1];
				break;
			case SUBSTITUTION:
				sx.add(Step.COMPOUND);
				sy.add(Step.COMPOUND);
				last = linear ? traceback[--x][--y][0] : traceback[x--][y--][0];
				break;
			case INSERTION:
				sx.add(Step.GAP);
				sy.add(Step.COMPOUND);
				last = linear ? traceback[x][--y][0] : traceback[x][y--][2];
			}
		}
		Collections.reverse(sx);
		Collections.reverse(sy);
		return new int[] {x, y};
	}
222575
def set_pattern_step_time(self, patternnumber, stepnumber, timevalue):
        
        _checkPatternNumber(patternnumber)
        _checkStepNumber(stepnumber)
        _checkTimeValue(timevalue, self.time_max)
        
        address = _calculateRegisterAddress('time', patternnumber, stepnumber)
        self.write_register(address, timevalue, 0)
685668
def setParameter(self, parameterName, index, parameterValue):
    
    spec = self.getSpec()
    if parameterName not in spec['parameters']:
      raise Exception("Unknown parameter: " + parameterName)

    setattr(self, parameterName, parameterValue)
1013033
def step(self, **args):
        
        if self.verbosity > 0:
            print("Network.step() called with:", args)
        # First, copy the values into either activations or targets:
        retargs = self.preStep(**args)
        if retargs: args = retargs # replace the args
        # Propagate activation through network:
        self.propagate(**args)
        retargs = self.postPropagate(**args)
        if retargs: args = retargs # replace the args
        # Next, take care of any Auto-association, and copy
        # activations to targets
        for aa in self.association:
            (inName, outName) = aa
            inLayer = self.getLayer(inName)
            if inLayer.type not in ['Input', "Hidden"]:
                raise LayerError('Associated input layer not type \'Input\' or \'Hidden\'.', \
                                   inLayer.type)
            outLayer = self.getLayer(outName)
            if not outLayer.type == 'Output':
                raise LayerError('Associated output layer not type \'Output\'.', \
                                   outLayer.type)
            outLayer.copyTargets(inLayer.activation)
        # Compute error, and back prop it:
        retargs = self.preBackprop(**args)
        if retargs: args = retargs # replace the args
        (error, correct, total, pcorrect) = self.backprop(**args) # compute_error()
        if self.verbosity > 2 or self.interactive:
            self.display()
            if self.interactive:
                self.prompt()
        retargs = self.postBackprop(**args)
        if retargs: args = retargs # replace the args
        # if learning is true, and need to update weights here:
        if self.learning and not self.batch:
            self.change_weights() # else change weights in sweep
        retargs = self.postStep(**args)
        if retargs: args = retargs # replace the args
        self.reportPattern()
        return (error, correct, total, pcorrect)
359505
def stepBy(self, steps):
        
        self.setValue(self.value() + steps*self.singleStep())
255654
private PatternElement createNewPatternElement(int pattNum, int row, int channel, int note)
	{
		PatternElement pe = new PatternElement(pattNum, row, channel);
		
		pe.setInstrument((note&0xF80000)>>19);

		int oktave = (note&0xF0000000)>>28;
		if (oktave!=-1)
		{
			int ton = (note&0x0F000000)>>24;
			int index = (oktave+3)*12+ton; // fit to it octaves
			pe.setPeriod((index<Helpers.noteValues.length) ? Helpers.noteValues[index] : 0);
			pe.setNoteIndex(index+1);
		}
		else
		{
			pe.setPeriod(0);
			pe.setNoteIndex(0);
		}
	
		pe.setEffekt((note&0xF00)>>8);
		pe.setEffektOp(note&0xFF);
		if (pe.getEffekt()==0x01) // set Tempo needs correction. Do not ask why!
		{
			int effektOp = pe.getEffektOp();
			pe.setEffektOp(((effektOp&0x0F)<<4) | ((effektOp&0xF0)>>4));
		}
		
		int volume =((note&0x70000)>>16) | ((note&0xF000)>>9);
		if (volume<=64)
		{
			pe.setVolumeEffekt(1);
			pe.setVolumeEffektOp(volume);
		}
		
		return pe;
	}
425725
public void beginStep(int step, String stepTitle, Logging logger) {
    setProcessed(step - 1);
    this.stepTitle = stepTitle;
    logger.progress(this);
  }
381474
def incrementor(start=0, step=1):
  
  def fxn(_):
    """Returns the next value in the sequnce defined by [start::step)"""
    nonlocal start
    rval = start
    start += step
    return rval
  return fxn
408425
public function setStep(float $step) : Number
    {
        $this->attributes['step'] = $step;
        $offset = isset($this->attributes['min']) ?
            $this->attributes['min'] :
            0;
        return $this->addTest('step', function ($value) use ($step, $offset) {
            if (!is_numeric($value)) {
                return false;
            }
            return !fmod($value - $offset, $step);
        });
    }
400295
def add(self, rule, method, target, name=None):
        '''  '''
        anons     = 0    # Number of anonymous wildcards found
        keys      = []   # Names of keys
        pattern   = ''   # Regular expression pattern with named groups
        filters   = []   # Lists of wildcard input filters
        builder   = []   # Data structure for the URL builder
        is_static = True

        for key, mode, conf in self._itertokens(rule):
            if mode:
                is_static = False
                if mode == 'default': mode = self.default_filter
                mask, in_filter, out_filter = self.filters[mode](conf)
                if not key:
                    pattern += '(?:%s)' % mask
                    key = 'anon%d' % anons
                    anons += 1
                else:
                    pattern += '(?P<%s>%s)' % (key, mask)
                    keys.append(key)
                if in_filter: filters.append((key, in_filter))
                builder.append((key, out_filter or str))
            elif key:
                pattern += re.escape(key)
                builder.append((None, key))

        self.builder[rule] = builder
        if name: self.builder[name] = builder

        if is_static and not self.strict_order:
            self.static.setdefault(method, {})
            self.static[method][self.build(rule)] = (target, None)
            return

        try:
            re_pattern = re.compile('^(%s)$' % pattern)
            re_match = re_pattern.match
        except re.error:
            raise RouteSyntaxError("Could not add Route: %s (%s)" % (rule, _e()))

        if filters:
            def getargs(path):
                url_args = re_match(path).groupdict()
                for name, wildcard_filter in filters:
                    try:
                        url_args[name] = wildcard_filter(url_args[name])
                    except ValueError:
                        raise HTTPError(400, 'Path has wrong format.')
                return url_args
        elif re_pattern.groupindex:
            def getargs(path):
                return re_match(path).groupdict()
        else:
            getargs = None

        flatpat = _re_flatten(pattern)
        whole_rule = (rule, flatpat, target, getargs)

        if (flatpat, method) in self._groups:
            if DEBUG:
                msg = 'Route <%s %s> overwrites a previously defined route'
                warnings.warn(msg % (method, rule), RuntimeWarning)
            self.dyna_routes[method][self._groups[flatpat, method]] = whole_rule
        else:
            self.dyna_routes.setdefault(method, []).append(whole_rule)
            self._groups[flatpat, method] = len(self.dyna_routes[method]) - 1

        self._compile(method)
299488
public void goToStep(int step) {
        for (int i = 0; i < getWidgetCount(); i++) {
            Widget w = getWidget(i);
            if (w instanceof MaterialStep) {
                ((MaterialStep) w).setActive(false);
            }
        }

        Widget w = getWidget(step - 1);
        if (w instanceof MaterialStep) {
            ((MaterialStep) w).setActive(true);
        }
        setCurrentStepIndex(step - 1);
    }