Get an array of words with start/end frame values (10msec/frame) for current hypothesis

 @return [Array] Array of words with start/end frame values (10msec/frame)
331939
def words
      mp_path_score = FFI::MemoryPointer.new(:int32, 1)
      start_frame   = FFI::MemoryPointer.new(:int32, 1)
      end_frame     = FFI::MemoryPointer.new(:int32, 1)

      seg_iter = ps_api.ps_seg_iter(ps_decoder, mp_path_score)
      words    = []

      until seg_iter.null? do
        ps_api.ps_seg_frames(seg_iter, start_frame, end_frame)
        words << Pocketsphinx::Decoder::Word.new(
          ps_api.ps_seg_word(seg_iter),
          start_frame.get_int32(0),
          end_frame.get_int32(0)
        )
        seg_iter = ps_api.ps_seg_next(seg_iter)
      end

      words
    end
1254783
def slice(self, begin, end):
        
        jrdds = self._jdstream.slice(self._jtime(begin), self._jtime(end))
        return [RDD(jrdd, self._sc, self._jrdd_deserializer) for jrdd in jrdds]
151561
def get_current_frames():
    
    return dict(
        (thread_id, {'frame': thread2list(frame), 'time': None})
        for thread_id, frame in sys._current_frames().items()
    )
675484
def get_finished(self):
        
        indices  = []
        for idf, v in self.q.items():
            if v.poll() != None:
                indices.append(idf)

        for i in indices:
            self.q.pop(i)
        return indices
868548
def get(self):
        
        chunk_size = self._smallest_buffer()
        all_full = self._all_full()

        if all_full:
            right_context = 0
            num_frames = chunk_size - self.current_left_context
        else:
            right_context = self.right_context
            num_frames = self.min_frames

        chunk_size_needed = num_frames + self.current_left_context + right_context

        if chunk_size >= chunk_size_needed:
            data = []
            keep_frames = self.left_context + self.right_context
            keep_from = max(0, chunk_size - keep_frames)

            for index in range(self.num_buffers):
                data.append(self.buffers[index][:chunk_size])
                self.buffers[index] = self.buffers[index][keep_from:]

            if self.num_buffers == 1:
                data = data[0]

            chunk = Chunk(data,
                          self.current_frame,
                          all_full,
                          self.current_left_context,
                          right_context)

            self.current_left_context = min(self.left_context, chunk_size)
            self.current_frame = max(self.current_frame + chunk_size - keep_frames, 0)

            return chunk
553322
def long()
			words = []
			7.downto(0) do |x|
				word = (@addr >> 16*x) & 0xffff 
				words.push( word.to_s(16).rjust(4, "0") )
			end
			return words.join(':')
		end
221406
def sample(self, sampling_period, start=None, end=None,
               interpolate='previous'):
        
        start, end, mask = self._check_boundaries(start, end)

        sampling_period = \
            self._check_regularization(start, end, sampling_period)

        result = []
        current_time = start
        while current_time <= end:
            value = self.get(current_time, interpolate=interpolate)
            result.append((current_time, value))
            current_time += sampling_period
        return result
154834
function(start, end){
        //subQueue to Array
        if(start >= 0 && start < end && end <= this._length) {
            var result = [],
                current = this._head,
                i = 0;
            while(i++ < start) {
                current = current.next;
            }

            while(start++ < end) {
                var value = current.data.value;
                if(value != null) {
                    result.push(current.data.value);
                }
                current = current.next;
            }

            return result;
        }

        var result = [],
            current = this._head;
        
        while(current){
            result.push(current.data);
            current = current.next;
        }
        
        return result;
    }
290138
def frame_to_sample(self, frame_index):
        
        start = frame_index * self.hop_size
        end = start + self.frame_size
        return start, end
1133814
def get_tape(self, start=0, end=10):
        ''''''
        self.tape_start = start
        self.tape_end = end
        self.tape_length = end - start
        tmp = '\n'+"|"+str(start)+"|  "
        for i in xrange(len(self.tape[start:end])):
            if i == self.cur_cell:
                tmp += "[" + str(self.tape[i]) + "] "
            else: tmp += ":" + str(self.tape[i]) + ": "
        tmp += " |"+str(end)+"|"
        return tmp
1109718
def arrays(self):
        
        return [x for x in self[self.current_scope].values() if x.class_ == CLASS.array]
743319
def get_chain(start: '', count: 10)
      logger.debug "get_chain", start: Utils.encode_hex(start), count: count

      if start.true?
        return [] unless @index.db.include?(start)

        block = get start
        return [] unless in_main_branch?(block)
      else
        block = head
      end

      blocks = []
      count.times do |i|
        blocks.push block
        break if block.genesis?
        block = block.get_parent
      end

      blocks
    end
1068344
def vectorize(self, token_list):
        '''
        
        '''
        sentence_list = [token_list]
        test_observed_arr = self.__setup_dataset(sentence_list, self.__token_master_list)
        pred_arr = self.__controller.inference(test_observed_arr)
        return self.__controller.get_feature_points()
1225964
function(start, end, options) {
    var values = [], i;
    for (i = start; i < end; i++) {
      if (options && options.skip) {
        if (i % options.skip === 0) {
          values.push(i);
        } else {
          values.push(undefined);
        }
      } else {
        values.push(i);
      }
    }
    return values;
  }
907569
def readQuotes(self, start, end):
        ''' '''
        if self.symbol is None:
            LOG.debug('Symbol is None')
            return []

        return self.__yf.getQuotes(self.symbol, start, end)
1229423
def get_frames(self):
        ""
        nb_frames = self.input_totalframes // self.output_blocksize

        if self.input_totalframes % self.output_blocksize == 0:
            nb_frames -= 1  # Last frame must send eod=True

        for index in xrange(0,
                            nb_frames * self.output_blocksize,
                            self.output_blocksize):
            yield (self.samples[index:index + self.output_blocksize], False)

        yield (self.samples[nb_frames * self.output_blocksize:], True)
384157
def get_reply_states(self, string, dataset):
        
        words = get_words(string)
        if not words:
            return []
        long_word = 4
        long_words = [word for word in words if len(word) >= long_word]
        short_words = [word for word in words if len(word) < long_word]
        for words in (long_words, short_words):
            ret = [
                states
                for states in (
                    self.storage.get_states(dataset, word)
                    for word in words
                )
                if states
            ]
            if ret:
                return ret
        return []