diff --git a/src/ol/tilerange.js b/src/ol/tilerange.js
index e1baa169f8..752716a4dc 100644
--- a/src/ol/tilerange.js
+++ b/src/ol/tilerange.js
@@ -1,23 +1,44 @@
 goog.provide('ol.TileRange');
 
 goog.require('goog.asserts');
-goog.require('ol.Rectangle');
+goog.require('ol.Size');
 goog.require('ol.TileCoord');
 
 
 
 /**
+ * A representation of a contiguous block of tiles.  A tile range is specified
+ * by its min/max tile coordinates and is inclusive of coordinates.
+ *
  * @constructor
- * @extends {ol.Rectangle}
  * @param {number} minX Minimum X.
  * @param {number} minY Minimum Y.
  * @param {number} maxX Maximum X.
  * @param {number} maxY Maximum Y.
  */
 ol.TileRange = function(minX, minY, maxX, maxY) {
-  goog.base(this, minX, minY, maxX, maxY);
+
+  /**
+   * @type {number}
+   */
+  this.minX = minX;
+
+  /**
+   * @type {number}
+   */
+  this.minY = minY;
+
+  /**
+   * @type {number}
+   */
+  this.maxX = maxX;
+
+  /**
+   * @type {number}
+   */
+  this.maxY = maxY;
+
 };
-goog.inherits(ol.TileRange, ol.Rectangle);
 
 
 /**
@@ -62,7 +83,28 @@ ol.TileRange.prototype.containsTileRange = function(tileRange) {
 
 
 /**
- * @inheritDoc
+ * @param {ol.TileRange} range Other range.
+ * @return {boolean} The two ranges are equivalent.
+ */
+ol.TileRange.prototype.equals = function(range) {
+  return this.minX == range.minX && this.minY == range.minY &&
+      this.maxX == range.maxX && this.maxY == range.maxY;
+};
+
+
+/**
+ * Extend this range so it includes the other.
+ * @param {ol.TileRange} other Other range.
+ */
+ol.TileRange.prototype.extend = function(other) {
+  this.minX = Math.min(this.minX, other.minX);
+  this.minY = Math.min(this.minY, other.minY);
+  this.maxX = Math.max(this.maxX, other.maxX);
+  this.maxY = Math.max(this.maxY, other.maxY);
+};
+
+
+/**
  * @return {number} Height.
  */
 ol.TileRange.prototype.getHeight = function() {
@@ -71,9 +113,30 @@ ol.TileRange.prototype.getHeight = function() {
 
 
 /**
- * @inheritDoc
+ * @return {ol.Size} Size.
+ */
+ol.TileRange.prototype.getSize = function() {
+  return new ol.Size(this.getWidth(), this.getHeight());
+};
+
+
+/**
  * @return {number} Width.
  */
 ol.TileRange.prototype.getWidth = function() {
   return this.maxX - this.minX + 1;
 };
+
+
+/**
+ * Test for range intersection.
+ * @param {ol.TileRange} other Other range.
+ * @return {boolean} The two ranges intersect.
+ */
+ol.TileRange.prototype.intersects = function(other) {
+  return this.minX <= other.maxX &&
+      this.maxX >= other.minX &&
+      this.minY <= other.maxY &&
+      this.maxY >= other.minY;
+};
+
diff --git a/test/spec/ol/tilerange.test.js b/test/spec/ol/tilerange.test.js
index fd59068325..6906c57e78 100644
--- a/test/spec/ol/tilerange.test.js
+++ b/test/spec/ol/tilerange.test.js
@@ -2,6 +2,20 @@ goog.provide('ol.test.TileRange');
 
 describe('ol.TileRange', function() {
 
+  describe('constructor', function() {
+    it('creates a range', function() {
+      var range = new ol.TileRange(1, 2, 3, 4);
+      expect(range).toBeA(ol.TileRange);
+    });
+
+    it('can represent a range of one tile', function() {
+      var range = new ol.TileRange(2, 3, 2, 3);
+      expect(range).toBeA(ol.TileRange);
+      expect(range.getHeight()).toBe(1);
+      expect(range.getWidth()).toBe(1);
+    });
+  });
+
   describe('contains', function() {
     it('returns the expected value', function() {
       var tileRange = new ol.TileRange(1, 1, 3, 3);
@@ -53,6 +67,36 @@ describe('ol.TileRange', function() {
     });
   });
 
+  describe('equals', function() {
+    it('determines equivalence of two ranges', function() {
+      var one = new ol.TileRange(0, 1, 2, 4);
+      var same = new ol.TileRange(0, 1, 2, 4);
+      var diff1 = new ol.TileRange(0, 1, 2, 5);
+      var diff2 = new ol.TileRange(0, 1, 3, 4);
+      var diff3 = new ol.TileRange(0, 2, 2, 4);
+      var diff4 = new ol.TileRange(1, 1, 2, 4);
+      expect(one.equals(same)).toBe(true);
+      expect(one.equals(diff1)).toBe(false);
+      expect(one.equals(diff2)).toBe(false);
+      expect(one.equals(diff3)).toBe(false);
+      expect(one.equals(diff4)).toBe(false);
+    });
+  });
+
+  describe('extent', function() {
+    it('modifies range so it includes another', function() {
+      var one = new ol.TileRange(0, 1, 2, 4);
+      var other = new ol.TileRange(-1, 10, -3, 12);
+      one.extend(other);
+
+      expect(one.minX).toBe(-1);
+      expect(one.minY).toBe(1);
+      expect(one.maxX).toBe(2);
+      expect(one.maxY).toBe(12);
+
+    });
+  });
+
   describe('getSize', function() {
     it('returns the expected size', function() {
       var tileRange = new ol.TileRange(0, 1, 2, 4);
@@ -62,6 +106,29 @@ describe('ol.TileRange', function() {
     });
   });
 
+  describe('intersects', function() {
+    it('determines if two ranges overlap', function() {
+      var one = new ol.TileRange(0, 1, 2, 4);
+      var overlapsRight = new ol.TileRange(2, 1, 4, 4);
+      var overlapsLeft = new ol.TileRange(-3, 1, 0, 4);
+      var overlapsTop = new ol.TileRange(0, 4, 2, 5);
+      var overlapsBottom = new ol.TileRange(0, -3, 2, 1);
+      expect(one.intersects(overlapsLeft)).toBe(true);
+      expect(one.intersects(overlapsRight)).toBe(true);
+      expect(one.intersects(overlapsTop)).toBe(true);
+      expect(one.intersects(overlapsBottom)).toBe(true);
+
+      var right = new ol.TileRange(3, 1, 5, 4);
+      var left = new ol.TileRange(-3, 1, -1, 4);
+      var above = new ol.TileRange(0, 5, 2, 6);
+      var below = new ol.TileRange(0, -3, 2, 0);
+      expect(one.intersects(right)).toBe(false);
+      expect(one.intersects(left)).toBe(false);
+      expect(one.intersects(above)).toBe(false);
+      expect(one.intersects(below)).toBe(false);
+    });
+  });
+
 });
 
 goog.require('ol.TileRange');