Returns a generator over (index, start coordinate) pairs,
        excluding the origin.
188691
def iter_starts_with_index(self):
        """"""
        for i in range(1, len(self.endpoints)):
            yield i, self.get_coordinates(i)
1218564
def gen_lower(x: Iterable[str]) -> Generator[str, None, None]:
    
    for string in x:
        yield string.lower()
588379
def yield_pair_gradients(self, index1, index2):
        """"""
        strength = self.strengths[index1, index2]
        distance = self.distances[index1, index2]
        yield -6*strength*distance**(-7), np.zeros(3)
162012
def iter_surrounding(self, center_key):
        """"""
        for shift in self.neighbor_indexes:
            key = tuple(np.add(center_key, shift).astype(int))
            if self.integer_cell is not None:
                key = self.wrap_key(key)
            bin = self._bins.get(key)
            if bin is not None:
                yield key, bin
42147
def index(self, sub, start=None, end=None):
        
        return self.value_no_colors.index(sub, start, end)
909292
def int_global_to_local_start(self, index, axis=0):
        
        if index >= self.__mask[axis].stop-self.__halos[1][axis]:
            return None

        if index < self.__mask[axis].start:
            return 0

        return index-self.__mask[axis].start
565088
def match_indices(match):
    """"""
    a, b, size = match
    for i in range(size):
        yield a + i, b + i
402109
public int[] getChildIndexes(int index) {
    if (index == 0) {
      if (isConstant()) {
        return new int[0];
      } else {
        int[] result = new int[subexpressions.size()];
        int startIndex = 1;
        for (int i = 0; i < subexpressions.size(); i++) {
          result[i] = startIndex;
          startIndex += subexpressions.get(i).size();
        }
        return result;
      }
    } else {
      int[] parts = findSubexpression(index);
      int[] result = subexpressions.get(parts[0]).getChildIndexes(parts[1]);
      for (int i = 0; i < result.length; i++) {
        result[i] += parts[2];
      }
      return result;
    }
  }
281799
def iter_initial_relations(self, subject_graph):
        """"""
        vertex0 = self.start_vertex
        for vertex1 in range(subject_graph.num_vertices):
            if self.compare(vertex0, vertex1, subject_graph):
                yield vertex0, vertex1
1328034
def neighbors((x, y)):
    """"""
    yield x + 1, y
    yield x - 1, y
    yield x, y + 1
    yield x, y - 1
    yield x + 1, y + 1
    yield x + 1, y - 1
    yield x - 1, y + 1
    yield x - 1, y - 1
751667
def slice_global_to_local(self, index_slice, axis=0):
        
        if index_slice.stop < self.__mask[axis].start+self.__halos[0][axis]:
            return None

        if index_slice.start > self.__mask[axis].stop-self.__halos[1][axis]:
            return None

        local_start = self.int_global_to_local_start(index_slice.start, axis)
        local_stop = self.int_global_to_local_stop(index_slice.stop, axis)

        return slice(local_start,local_stop,index_slice.step)
1360080
def genfirstvalues(cursor: Cursor, arraysize: int = 1000) \
        -> Generator[Any, None, None]:
    
    return (row[0] for row in genrows(cursor, arraysize))
1304888
public final int getIndex( int coordinate[] ) {
		int index = coordinate[0]*strides[0];
		for (int i = 1; i < coordinate.length; i++) {
			index += strides[i]*coordinate[i];
		}

		return index;
	}
780043
public Pair<Integer, Integer> getStartPosition() {
        return Pair.makePair(iterationNumber.get(), epochNumber.get());
    }
256394
function(start, end) {
		var props = ['pageX', 'pageY'];
		return getAngle(end[1], end[0], props) - getAngle(start[1], start[0], props);
	}
657146
def getBigIndexFromIndices(self, indices):
        
        return reduce(operator.add, [self.dimProd[i]*indices[i]
                                     for i in range(self.ndims)], 0)
757889
def generate_matches(self, nodes):
        
        r = {}
        if nodes and self.match(nodes[0], r):
            yield 1, r