Reverse the points. This differs from the
    reversal point pen in RoboFab in that it doesn't
    worry about maintaing the start point position.
    That has no benefit within the context of this module.
438917
def _reversePoints(points):
    
    # copy the points
    points = _copyPoints(points)
    # find the first on curve type and recycle
    # it for the last on curve type
    firstOnCurve = None
    for index, point in enumerate(points):
        if point.segmentType is not None:
            firstOnCurve = index
            break
    lastSegmentType = points[firstOnCurve].segmentType
    # reverse the points
    points = reversed(points)
    # work through the reversed remaining points
    final = []
    for point in points:
        segmentType = point.segmentType
        if segmentType is not None:
            point.segmentType = lastSegmentType
            lastSegmentType = segmentType
        final.append(point)
    # move any offcurves at the end of the points
    # to the start of the points
    _prepPointsForSegments(final)
    # done
    return final
569450
def reverse(self):
        
        return Geometry(shapely.ops.transform(lambda x, y: (y, x), self.geometry), crs=self.crs)
987864
void addPoint(GraphicPoint offPt, int i_src) {
		if (m_offsetPtCount == 0) // TODO: can we have this outside of this
									// method?
		{
			addPoint(offPt);
			return;
		}

		int n_src = m_srcPtCount;
		GraphicPoint pt1, pt;
		pt1 = m_srcPts.get(i_src == 0 ? n_src - 1 : i_src - 1);
		pt = m_srcPts.get(i_src);

		// calculate scalar product to determine if the offset segment goes in
		// the same/opposite direction compared to the original one
		double s = scal(pt1, pt, m_offsetPts.get(m_offsetPtCount - 1), offPt);
		if (s > 0)
		// original segment and offset segment go in the same direction. Just
		// add the point
		{
			addPoint(offPt);
			return;
		}

		if (s < 0) {
			// we will add a loop. We need to make sure the points we introduce
			// don't generate a "reversed" segment
			// let's project the first point of the reversed segment
			// (m_offsetPts + m_offsetPtCount - 1) to check
			// if it falls on the good side of the original segment (scalar
			// product sign again)
			if (scal(pt1, pt, pt, m_offsetPts.get(m_offsetPtCount - 1)) > 0) {
				GraphicPoint p;

				// change value of m_offsetPts + m_offsetPtCount - 1
				int k;
				if (i_src == 0)
					k = n_src - 2;
				else if (i_src == 1)
					k = n_src - 1;
				else
					k = i_src - 2;
				GraphicPoint pt0 = m_srcPts.get(k);

				double a = Math.atan2(pt1.y - pt0.y, pt1.x - pt0.x);
				p = new GraphicPoint(pt1, m_distance, a - half_pi);
				m_offsetPts.set(m_offsetPtCount - 1, p);

				if (m_joins == OperatorOffset.JoinType.Bevel
						|| m_joins == OperatorOffset.JoinType.Miter) {
					// this block is added as well as the commented BAD_SEG in
					// the next block
					p = new GraphicPoint(p, pt1);
					addPoint(p);

					// "bad" segment
					p = new GraphicPoint(pt1, m_distance, m_a1 + half_pi);

					GraphicPoint p_ = new GraphicPoint(p, pt1);
					p_.type |= BAD_SEG;
					addPoint(p_);

					addPoint(p);
				} else {
					// the working stuff for round and square

					// "bad" segment
					p = new GraphicPoint(pt1, m_distance, m_a1 + half_pi);
					p.type |= BAD_SEG;
					addPoint(p);
				}

				// add offPt
				addPoint(offPt, i_src);
			} else {
				GraphicPoint p;

				// we don't add offPt but the loop containing the "bad" segment
				p = new GraphicPoint(pt, m_distance, m_a1 + half_pi);
				addPoint(p);

				if (m_joins == OperatorOffset.JoinType.Bevel
						|| m_joins == OperatorOffset.JoinType.Miter) {
					// this block is added as well as the commented BAD_SEG in
					// the next block
					p = new GraphicPoint(p, pt);
					addPoint(p);

					p = new GraphicPoint(pt, m_distance, m_a2 - half_pi);
					GraphicPoint p_ = new GraphicPoint(p, pt);
					p_.type |= BAD_SEG;
					addPoint(p_);

					addPoint(p);
				} else {
					// the working stuff for round and square
					p = new GraphicPoint(pt, m_distance, m_a2 - half_pi);
					p.type |= BAD_SEG;
					addPoint(p);
				}
			}
		}
	}
327543
public void reverse() {
	// overridden for performance only.
	double tmp;
	int limit=size/2;
	int j=size-1;

	double[] theElements = elements;
	for (int i=0; i<limit;) { //swap
		tmp=theElements[i];
		theElements[i++]=theElements[j];
		theElements[j--]=tmp;
	}
}
69361
def reverse_index(self):
        
        top, bottom = self.margins or Margins(0, self.lines - 1)
        if self.cursor.y == top:
            # TODO: mark only the lines within margins?
            self.dirty.update(range(self.lines))
            for y in range(bottom, top, -1):
                self.buffer[y] = self.buffer[y - 1]
            self.buffer.pop(top, None)
        else:
            self.cursor_up()
275023
def reverse(self, point, language=None, sensor=False):
        '''
        '''
        params = {
            'latlng': point,
            'sensor': str(sensor).lower()
        }
        
        if language:
            params['language'] = language

        if not self.premier:
            url = self.get_url(params)
        else:
            url = self.get_signed_url(params)

        return self.GetService_url(url)
914238
def move(self, point, reverse=False):
        
        if reverse:
            point = [-1 * i for i in point]
        return Box(self.x + point[0], self.y + point[1], self.width, self.height)
1158796
def reverse(self):
        
        enabled = self.lib.iperf_get_test_reverse(self._test)

        if enabled:
            self._reverse = True
        else:
            self._reverse = False

        return self._reverse
250523
def reverseCommit(self):
        
        # 
        self.baseClass.setText(self.textBefore)
        self.qteWidget.SCISetStylingEx(0, 0, self.styleBefore)
1142244
def reverseCommit(self):
        
        self.baseClass.setText(self.oldText)
        self.qteWidget.SCISetStylingEx(0, 0, self.style)
505726
def reverse_complement(self):
        '''

        '''
        copy = self.copy()
        # Note: if sequence is double-stranded, swapping strand is basically
        # (but not entirely) the same thing - gaps affect accuracy.
        copy.top = self.top.reverse_complement()
        copy.bottom = self.bottom.reverse_complement()

        # Remove all features - the reverse complement isn't flip!
        copy.features = []

        return copy
535795
def rotate(self, steps):
        
        popped_deque = self.pop(steps)
        if steps >= 0:
            return popped_deque.extendleft(islice(self.reverse(), steps))

        return popped_deque.extend(islice(self, -steps))
635814
public static void reverseBits(byte[] b) {
        for (int k = 0; k < b.length; ++k)
            b[k] = flipTable[b[k] & 0xff];
    }
834332
def reverseCommit(self):
        
        if self.selectionPosOld is None:
            return

        # Shorthand.
        wid = self.qteWidget

        # Select, backup, and delete the selection.
        wid.setSelection(*self.selectionPosNew)
        self.baseClass.replaceSelectedText(self.oldText)

        # Add the styling information.
        line, col = self.selectionPosNew[0:2]
        wid.SCISetStylingEx(line, col, self.oldStyle)
        wid.setCursorPosition(line, col)
1051165
function reverse(param) {
    var ret = new buffer.Buffer(param.length);
    for (var i = 0; i < param.length; i++) {
      ret[i] = param[param.length - i - 1];
    }
    return ret;
  }
1212342
public static Geometry reverse(Geometry geometry) {
        if (geometry == null) {
            return null;
        }
        if (geometry instanceof MultiPoint) {
            return reverseMultiPoint((MultiPoint) geometry);
        }
        return geometry.reverse();
    }
1358330
def draw_point ink, left, top, opts = {}
      draw_rect ink, left, top, 1, 1, opts
    end