APIMethod: reverseAxisOrder
Returns true if the axis order is reversed for the WMS version and
projection of the layer.

Returns:
{Boolean} true if the axis order is reversed, false otherwise.
168616
function() {
        var projCode = this.projection.getCode();
        return parseFloat(this.params.VERSION) >= 1.3 && 
            !!(this.yx[projCode] || (OpenLayers.Projection.defaults[projCode] && 
            OpenLayers.Projection.defaults[projCode].yx));
    }
1271410
function () {
            var chart = this.chart,
              xAxis = this.xAxis,
              yAxis = this.yAxis;

            // Swap axes for inverted (#2339)
            if (chart.inverted) {
                xAxis = yAxis;
                yAxis = this.xAxis;
            }
            return {
                translateX: xAxis ? xAxis.left : chart.plotLeft,
                translateY: yAxis ? yAxis.top : chart.plotTop,
                scaleX: 1, // #1623
                scaleY: 1
            };
        }
1175792
private boolean isCorrectVertex() {
		try {
			String geomType = service.getIndexService().getGeometryType(service.getGeometry(), index);
			if (Geometry.LINE_STRING.equals(geomType)) {
				GeometryIndex temp = service.getIndexService().getPreviousVertex(service.getInsertIndex());
				return temp.equals(index);
			} else if (Geometry.LINEAR_RING.equals(geomType)) {
				return 0 == service.getIndexService().getValue(index);
			}
		} catch (GeometryIndexNotFoundException e) {
			throw new IllegalStateException(e);
		}
		return false;
	}
879032
function(yOrdering) {

        this.compare = yOrdering ? 
            OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER :
            OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER;

        this.clear();
    }
289822
public static boolean isChartInRuntime(Chart cm) {
    if (cm instanceof ChartWithAxes) {
      Axis bAxis = ((ChartWithAxes) cm).getAxes().get(0);
      EList<Axis> oAxes = bAxis.getAssociatedAxes();
      for (int i = 0; i < oAxes.size(); i++) {
        Axis oAxis = oAxes.get(i);
        EList<SeriesDefinition> oSeries = oAxis.getSeriesDefinitions();
        for (int j = 0; j < oSeries.size(); j++) {
          SeriesDefinition sd = oSeries.get(j);
          if (sd.getRunTimeSeries().size() > 0) {
            return true;
          }
        }
      }
    } else if (cm instanceof ChartWithoutAxes) {
      SeriesDefinition bsd = ((ChartWithoutAxes) cm).getSeriesDefinitions().get(0);
      EList<SeriesDefinition> osds = bsd.getSeriesDefinitions();
      for (int i = 0; i < osds.size(); i++) {
        SeriesDefinition osd = osds.get(i);
        if (osd.getRunTimeSeries().size() > 0) {
          return true;
        }
      }
    }
    return false;
  }
746523
public OrderingList<S> reverseDirections() {
        if (size() == 0) {
            return this;
        }
        OrderingList<S> reversedList = emptyList();
        for (int i=0; i<size(); i++) {
            reversedList = reversedList.concat(get(i).reverse());
        }
        return reversedList;
    }
453022
function getDirection(gradient) {
    var segs;
    var angle;
    var result = {};

    if (gradient.sideCorner) {
        segs = gradient.sideCorner.split(/\s+/);

        var to = segs[0] === 'to';
        if (to) {
            // sideCorner starts with "to" so we shift it off since we don't
            // need this element anymore, and continue with generating the
            // gradient in the normal direction.
            segs.shift();
        } else {
            // sideCorner does not start with "to", so we need to reverse the
            // direction.
            var reverseDirections = {
                top: 'bottom',
                bottom: 'top',
                left: 'right',
                right: 'left'
            };
            segs[0] = reverseDirections[segs[0]];
        }

        result.direction = segs[0];
        // side corner is  `top right` or `bottom left` etc.
        if (segs.length > 1) {
            // fallback to one direction
            result.isFallback = true;
            result.message =
                'IE filter doesn\'t support side corner gradient, ' +
                'we use the first side of the side corner as fallback.';
        }
    } else {
        angle = normalizeAngle(gradient.angle.value, gradient.angle.unit);
        result = angleToDirection(angle);
    }

    return result;
}
109940
public function reverse(Model\InStore\Reversal $orderReversal, HandlerStack $stack = null)
    {
        try {
            $params = $this->generateParams($orderReversal, $stack);

            $result = $this->getClient()->post('orders/reverse', $params);

            /** @var Model\InStore\Reversal $reversal */
            $reversal = $this->getSerializer()->deserialize(
                (string) $result->getBody(),
                Model\InStore\Reversal::class,
                'json'
            );

            return $reversal;
        } catch (BadResponseException $e) {
            throw new ApiException(
                $this->getSerializer()->deserialize(
                    (string) $e->getResponse()->getBody(),
                    Model\ErrorResponse::class,
                    'json'
                ),
                $e
            );
        }
    }
30126
function(data, sortOrder) {
  if(sortOrder){
    data = _.sortBy(data, sortOrder.substr(1));
    if(sortOrder[0] === '-'){
      data.reverse();
    }
  }
  return data;
}
758596
def reversed(self):
        """"""
        newpath = [seg.reversed() for seg in self]
        newpath.reverse()
        return Path(*newpath)
431684
private boolean separatorDown(Rectangular pos)
    {
        if (pos.getY2() < getTopology().getTopologyHeight()-1)
        {
            Rectangular spos = getTopology().toPixelPositionAbsolute(new Rectangular(pos.getX1(), pos.getY2(), pos.getX2(), pos.getY2()));
            Rectangular epos = getTopology().toPixelPositionAbsolute(new Rectangular(pos.getX1(), pos.getY2() + 1, pos.getX2(), pos.getY2() + 1));
            return seps.isSeparatorAt(spos.midX(), spos.getY2()) ||
                   seps.isSeparatorAt(epos.midX(), epos.getY1());
        }
        else
            return true;
    }
890395
def reverse(self):
        
        return BBox((self.min_y, self.min_x, self.max_y, self.max_x), crs=self.crs)
1006628
function() {
            var u = new CSG.Vector3D(this.elements[0], this.elements[4], this.elements[8]);
            var v = new CSG.Vector3D(this.elements[1], this.elements[5], this.elements[9]);
            var w = new CSG.Vector3D(this.elements[2], this.elements[6], this.elements[10]);

            // for a true orthogonal, non-mirrored base, u.cross(v) == w
            // If they have an opposite direction then we are mirroring
            var mirrorvalue = u.cross(v).dot(w);
            var ismirror = (mirrorvalue < 0);
            return ismirror;
        }
284511
function(){
		if(!this.enableUndo){ return false;}
		var opes = this.history[this.position-1];
		this.reqReset = this.checkReqReset(opes);
		this.preproc();
		this.undoCore();
		this.postproc();
		return this.enableUndo;
	}
948633
def _powershell_script_order_reverse_conversion(cls, val, **kwargs):
        '''
        
        '''
        if val.upper() == 'Run Windows PowerShell scripts first'.upper():
            return 'true'
        elif val.upper() == 'Run Windows PowerShell scripts last'.upper():
            return 'false'
        elif val is 'Not Configured':
            return None
        else:
            return 'Invalid Value'
46708
def map_axes(dim_vars, reverse_map=False):
    
    ret_val = defaultdict(list)
    axes = ['X', 'Y', 'Z', 'T']

    for k, v in dim_vars.items():
        axis = getattr(v, 'axis', '')
        if not axis:
            continue

        axis = axis.upper()
        if axis in axes:
            if reverse_map:
                ret_val[k].append(axis)
            else:
                ret_val[axis].append(k)

    return dict(ret_val)
971432
function reverse(array) {
  return array.map(function (v) {
    return {
      name: v.name,
      rank: -v.rank,
      node: v.node,
    }
  }).reverse()
}