Sequenced constructor.
487760
protected function initializeCallQueues()
    {
        $this->inputs = new \Slab\Sequencer\CallQueue();
        $this->operations = new \Slab\Sequencer\CallQueue();
        $this->outputs = new \Slab\Sequencer\CallQueue();
    }
1113314
@Override
    public Object mapSequence(Object sequence) {
        List<?> values = (List<?>) sequence;
        List<List<Integer>> ret = new ArrayList<>();
        for (Object obj : values) {
            ret.add((List<Integer>) map(obj));
        }
        return ret;
    }
202293
protected void train() throws Exception {
      Dataset<Sequence> train = loadDataset();
      if (minFeatureCount > 1) {
         train = train.preprocess(PreprocessorList.create(new MinCountFilter(minFeatureCount).asSequenceProcessor()));
      }
      SequenceLabeler labeler = getLearner().train(train);
      POSTagger tagger = new POSTagger(featurizer.get(), labeler);
      tagger.write(model);
   }
293284
def build_sequence(self, xs, masks, init, is_left_to_right):
        '''
        
        '''
        states = []
        last = init
        if is_left_to_right:
            for i, xs_i in enumerate(xs):
                h = self.build(xs_i, last, masks[i])
                states.append(h)
                last = h
        else:
            for i in range(len(xs) - 1, -1, -1):
                h = self.build(xs[i], last, masks[i])
                states.insert(0, h)
                last = h
        return states
429174
def _initialize_counter(self):
        
        if self._counter is not None:
            return

        if self.counter_reference is self:
            self._counter = _Counter(seq=self.factory._setup_next_sequence())
        else:
            self.counter_reference._initialize_counter()
            self._counter = self.counter_reference._counter
1349892
private void createSequences(Collection<Sequence> sequences, SchemaDescriptor schemaDescriptor, Store store) {
        for (Sequence sequence : sequences) {
            SequenceDesriptor sequenceDesriptor = store.create(SequenceDesriptor.class);
            sequenceDesriptor.setName(sequence.getName());
            sequenceDesriptor.setIncrement(sequence.getIncrement());
            sequenceDesriptor.setMinimumValue(sequence.getMinimumValue().longValue());
            sequenceDesriptor.setMaximumValue(sequence.getMaximumValue().longValue());
            sequenceDesriptor.setCycle(sequence.isCycle());
            schemaDescriptor.getSequences().add(sequenceDesriptor);
        }
    }
1228603
public void setInitialSequence(int[] sequence) {
    if(models != null){
      for(int i = 0; i < models.length; i++)
        models[i].setInitialSequence(sequence);
      return;
    }
    model1.setInitialSequence(sequence);
    model2.setInitialSequence(sequence);
  }
1140997
private Statements createSequencesStatements(Iterable<Sequence> sequences) {
		Statements statements = new Statements();
		for ( Sequence sequence : sequences ) {
			addSequence( statements, sequence );
		}
		return statements;
	}
355662
private static StreamDescriptor copyStreamDescriptorWithSequence(StreamDescriptor streamDescriptor, int sequence)
    {
        List<StreamDescriptor> streamDescriptors = streamDescriptor.getNestedStreams().stream()
                .map(stream -> copyStreamDescriptorWithSequence(stream, sequence))
                .collect(toImmutableList());

        return new StreamDescriptor(
                streamDescriptor.getStreamName(),
                streamDescriptor.getStreamId(),
                streamDescriptor.getFieldName(),
                streamDescriptor.getStreamType(),
                streamDescriptor.getOrcDataSource(),
                streamDescriptors,
                sequence);
    }
927942
private void defineConstructor()
    {
        //
        // declare the constructor
        MethodDefinition constructor = new MethodDefinition(
                a(PUBLIC),
                "<init>",
                type(void.class),
                parameters.getParameters()
        );

        // invoke super (Object) constructor
        constructor.loadThis().invokeConstructor(type(Object.class));

        // this.foo = foo;
        for (FieldDefinition fieldDefinition : parameters.getFields()) {
            constructor.loadThis()
                    .loadVariable(fieldDefinition.getName())
                    .putField(codecType, fieldDefinition);
        }

        // return; (implicit)
        constructor.ret();

        classDefinition.addMethod(constructor);
    }
275114
function each(seq, pred, ctx) {
        return sequencep(seq)?  __each.call(seq, pred, ctx)
             : /* non-seq */    undefined
    }
591895
public function _construct()
    {
        $this->_init(
            \Dotdigitalgroup\Email\Model\Importer::class,
            \Dotdigitalgroup\Email\Model\ResourceModel\Importer::class
        );
    }
873293
private static int[] sequence(int e) {
    int[] a = new int[e];
    for(int i = 0; i < a.length; i++) {
      a[i] = i;
    }
    return a;
  }
875407
def createRandomSequences(self,
                          numSequences,
                          sequenceLength):
    
    for _ in xrange(numSequences):
      self.addObject(
        [numpy.random.randint(0, self.numFeatures)
                                            for _ in xrange(sequenceLength)]
      )
456724
def seq(self):
        """"""

        if self.sequence_file:
            log.debug('{}: reading sequence from sequence file {}'.format(self.id, self.sequence_path))
            tmp_sr = SeqIO.read(self.sequence_path, 'fasta')
            return tmp_sr.seq

        elif self.metadata_file:
            log.debug('{}: reading sequence from metadata file {}'.format(self.id, self.metadata_path))
            tmp_sr = SeqIO.read(self.metadata_path, 'uniprot-xml')
            return tmp_sr.seq

        else:
            if not self._seq:
                log.debug('{}: no sequence stored in memory'.format(self.id))
            else:
                log.debug('{}: reading sequence from memory'.format(self.id))

            return self._seq
221153
protected void analysisSequence(Class<ENTITY> entityClass) {
        Sequence sequence = entityClass.getAnnotation(Sequence.class);
        if (sequence != null) {
            this.sequenceName = sequence.name();
            sequenceGenerator.initialSequence(sequenceName, sequence.size());
        }
    }
1127558
private static function _createOracleSequence()
    {
        $name = self::resolveSequenceName();
        $sql  = "create sequence $name increment by 1 start with 1 nocycle nocache";
        Log::log($sql);
        $stmt = self::query($sql);
        self::closeCursor($stmt);
    }