Check to see if initial position and goal are the same
        if they are, offset slightly so that the forcing term is not 0
427524
def check_offset(self):
        """"""

        for d in range(self.dmps):
            if (self.y0[d] == self.goal[d]):
                self.goal[d] += 1e-4
422504
def xoffset(self, value):
        """"""
        if self._xoffset != value and \
           isinstance(value, (int, float, long)):
            self._xoffset = value
957006
private boolean checkArrivedY(double extrp, double sy, double dy)
    {
        final double y = transformable.getY();
        if (sy < 0 && y <= dy || sy >= 0 && y >= dy)
        {
            transformable.moveLocation(extrp, 0, dy - y);
            return true;
        }
        return false;
    }
677409
def check goal=nil, &block
      goal ||= block
      result = nil
      begin 
        result = goal.true?
      rescue
        check_raised_exception goal, $!
      else
        if result
          check_passed goal, &block
        else
          check_failed goal, &block
        end
      end
      result
    end
865588
def _check_consistent_units_orbitInput(self,orb):
        """"""
        if self._roSet and orb._roSet:
            assert m.fabs(self._ro-orb._ro) < 10.**-10., 'Physical conversion for the actionAngle object is not consistent with that of the Orbit given to it'
        if self._voSet and orb._voSet:
            assert m.fabs(self._vo-orb._vo) < 10.**-10., 'Physical conversion for the actionAngle object is not consistent with that of the Orbit given to it'
        return None
160480
def compare_source_offsets(a, b)
      diff = a[0] - b[0]
      diff = a[1] - b[1] if diff == 0

      if diff < 0
        -1
      elsif diff > 0
        1
      else
        0
      end
    end
845649
function isPointOverlap(p0, p1) {
            return ceil(p0.x) === ceil(p1.x) && ceil(p0.y) === ceil(p1.y);
        }
67496
def check_matching_coordinates(func):
    """"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        data_arrays = ([a for a in args if isinstance(a, xr.DataArray)]
                       + [a for a in kwargs.values() if isinstance(a, xr.DataArray)])
        if len(data_arrays) > 1:
            first = data_arrays[0]
            for other in data_arrays[1:]:
                if not first.metpy.coordinates_identical(other):
                    raise ValueError('Input DataArray arguments must be on same coordinates.')
        return func(*args, **kwargs)
    return wrapper
1197555
protected boolean checkCollision() {

        // sort the positions by their left x coordinate, so we can easily exclude
        // pairs of positions which don't overlap horizontally
        sortByLeft();
        int i;
        for (i = 0; i < m_positions.size(); i++) {
            for (int j = i + 1; (j < m_positions.size())
                && intersectsHorizontally(m_positions.get(i), m_positions.get(j)); j++) {
                if (intersectsVertically(m_positions.get(i), m_positions.get(j))) {
                    handleCollision(m_positions.get(i), m_positions.get(j));
                    return true;
                }
            }
        }
        return false;
    }
1245398
function isOffsetInEl(x, y, el) {
  var offset = getOffset(el);
  return offset.x <= x && offset.x + el.offsetWidth >= x && offset.y <= y && offset.y + el.offsetHeight >= y;
}
956044
protected void checkOffset(long offset) {
    if (offset(offset) < this.offset) {
      throw new IndexOutOfBoundsException();
    } else if (limit == -1) {
      if (offset > maxCapacity)
        throw new IndexOutOfBoundsException();
    } else {
      if (offset > limit)
        throw new IndexOutOfBoundsException();
    }
  }
272121
function sameMove(a, b) {
    return Position.hasSameXY(a.from, b.from) && Position.hasSameXY(a.to, b.to);
}
739117
function offset (ev, target) {
  var cx = ev.clientX || 0
  var cy = ev.clientY || 0
  var rect = bounds(target)
  return [ cx - rect.left, cy - rect.top ]
}
715670
def contains_offset(self, offset):
        """"""
        
        if self.PointerToRawData is None:
           # bss and other sections containing only uninitialized data must have 0
           # and do not take space in the file
           return False
        return ( adjust_FileAlignment( self.PointerToRawData, 
                self.pe.OPTIONAL_HEADER.FileAlignment ) <= 
                    offset < 
                        adjust_FileAlignment( self.PointerToRawData,
                            self.pe.OPTIONAL_HEADER.FileAlignment ) + 
                                self.SizeOfRawData )
772890
function assertReservedSlotInitialized(slotOffset, numSlots) {
    if (firstTemplatePass) {
        var startIndex = tView.bindingStartIndex - slotOffset;
        for (var i = 0; i < numSlots; i++) {
            assertEqual(viewData[startIndex + i], NO_CHANGE, 'The reserved slots should be set to `NO_CHANGE` on first template pass');
        }
    }
}
981264
def _is_target_valid(self, cfg, target):  # pylint:disable=no-self-use
        

        if self.base_state is not None:
            try:
                if self.base_state.solver.is_true((self.base_state.memory.permissions(target) & 4) == 4):
                    return True
            except SimMemoryError:
                pass
            return False

        if cfg._addr_in_exec_memory_regions(target):
            # the jump target is executable
            return True
        if self.project.is_hooked(target):
            # the jump target is hooked
            return True
        return False
94674
private boolean hasChangedPosition(I_CmsDropTarget target) {

        if ((m_currentTarget != target) || (m_currentIndex != target.getPlaceholderIndex())) {
            m_currentTarget = target;
            m_currentIndex = target.getPlaceholderIndex();
            return true;
        }
        return false;
    }