diff --git a/base/complex.jl b/base/complex.jl
index 07e48a005db15..b4606517a30b5 100644
--- a/base/complex.jl
+++ b/base/complex.jl
@@ -118,10 +118,8 @@ convert(::Type{Complex}, x::Real) = complex(x)
 ==(x::Real, z::Complex) = isreal(z) && real(z) == x
 
 isequal(z::Complex, w::Complex) = isequal(real(z),real(w)) & isequal(imag(z),imag(w))
-isequal(z::Complex, x::Real) = isreal(z) && isequal(real(z),x)
-isequal(x::Real, z::Complex) = isreal(z) && isequal(real(z),x)
 
-hash(z::Complex) = (r = hash(real(z)); isreal(z) ? r : bitmix(r,hash(imag(z))))
+hash(z::Complex) = bitmix(hash(real(z)),hash(imag(z)))
 
 conj(z::Complex) = complex(real(z),-imag(z))
 abs(z::Complex)  = hypot(real(z), imag(z))
diff --git a/base/dict.jl b/base/dict.jl
index 31bf5585426e5..4ea7926818642 100644
--- a/base/dict.jl
+++ b/base/dict.jl
@@ -218,28 +218,13 @@ function hash(x::Integer)
     return h
 end
 
-@eval function hash(x::FloatingPoint)
-    if trunc(x) == x
-        # hash as integer if equal to some integer. note the result of
-        # float to int conversion is only defined for in-range values.
-        if x < 0
-            if $(float64(typemin(Int64))) <= x
-                return hash(int64(x))
-            end
-        else
-            # note: float64(typemax(Uint64)) == 2^64
-            if x < $(float64(typemax(Uint64)))
-                return hash(uint64(x))
-            end
-        end
-    end
-    isnan(x) ? $(hash64(NaN)) : hash64(float64(x))
-end
+hash(x::Float32) = hash(reinterpret(Uint32, isnan(x) ? NaN32 : x))
+hash(x::Float64) = hash(reinterpret(Uint64, isnan(x) ? NaN   : x))
 
 function hash(t::Tuple)
     h = int(0)
     for i=1:length(t)
-        h = bitmix(h,int(hash(t[i])))
+        h = bitmix(h,int(hash(t[i]))+42)
     end
     return uint(h)
 end
@@ -252,6 +237,9 @@ function hash(a::Array)
     return uint(h)
 end
 
+# make sure Array{Bool} and BitArray can be equivalent
+hash(a::Array{Bool}) = hash(bitpack(a))
+
 hash(x::ANY) = object_id(x)
 
 if WORD_SIZE == 64
@@ -268,6 +256,8 @@ else
               s.data, length(s.data), uint32(seed))
 end
 
+hash(s::String) = hash(bytestring(s))
+
 
 # dict
 
diff --git a/base/float.jl b/base/float.jl
index eaeefebf5a77a..f93fee64796fd 100644
--- a/base/float.jl
+++ b/base/float.jl
@@ -157,7 +157,7 @@ mod{T<:FloatingPoint}(x::T, y::T) = rem(y+rem(x,y),y)
 <=(x::Float32, y::Float32) = le_float(unbox(Float32,x),unbox(Float32,y))
 <=(x::Float64, y::Float64) = le_float(unbox(Float64,x),unbox(Float64,y))
 
-isequal(x::FloatingPoint, y::FloatingPoint) =
+isequal{T<:FloatingPoint}(x::T, y::T) =
     ((x==y) & (signbit(x)==signbit(y))) | (isnan(x)&isnan(y))
 
 isequal(x::Float32, y::Float32) = fpiseq(unbox(Float32,x),unbox(Float32,y))
@@ -165,8 +165,6 @@ isequal(x::Float64, y::Float64) = fpiseq(unbox(Float64,x),unbox(Float64,y))
 isless (x::Float32, y::Float32) = fpislt(unbox(Float32,x),unbox(Float32,y))
 isless (x::Float64, y::Float64) = fpislt(unbox(Float64,x),unbox(Float64,y))
 
-isequal(a::Integer, b::FloatingPoint) = (a==b) & isequal(float(a),b)
-isequal(a::FloatingPoint, b::Integer) = isequal(b, a)
 isless (a::Integer, b::FloatingPoint) = (a<b) | isless(float(a),b)
 isless (a::FloatingPoint, b::Integer) = (a<b) | isless(a,float(b))
 
diff --git a/base/float16.jl b/base/float16.jl
index e2f9bcdeb7406..39bc167d82fac 100644
--- a/base/float16.jl
+++ b/base/float16.jl
@@ -101,3 +101,5 @@ end
 
 <(x::Float16, y::Float16) = float32(x) < float32(y)
 isless(x::Float16, y::Float16) = isless(float32(x), float32(y))
+
+hash(x::Float16) = hash(reinterpret(Uint16, isnan(x) ? NaN16 : x))
diff --git a/base/mpfr.jl b/base/mpfr.jl
index aab4b997ec700..1ec78a5c7a7ea 100644
--- a/base/mpfr.jl
+++ b/base/mpfr.jl
@@ -19,7 +19,7 @@ import
         gamma, lgamma, digamma, erf, erfc, zeta, log1p, airyai, iceil, ifloor,
         itrunc, eps, signbit, sin, cos, tan, sec, csc, cot, acos, asin, atan,
         cosh, sinh, tanh, sech, csch, coth, acosh, asinh, atanh, atan2,
-        serialize, deserialize, inf, nan
+        serialize, deserialize, inf, nan, hash
 
 import Base.Math.lgamma_r
 
@@ -717,4 +717,21 @@ print(io::IO, b::BigFloat) = print(io, string(b))
 show(io::IO, b::BigFloat) = print(io, string(b), " with $(precision(b)) bits of precision")
 showcompact(io::IO, b::BigFloat) = print(io, string(b))
 
+function hash(x::BigFloat)
+    if isnan(x)
+        return hash(NaN)
+    end
+    if isinf(x)
+        return hash(float64(x))
+    end
+    n = ceil(precision(x)/53)
+    h::Uint = signbit(x)
+    for i=1:n
+        f64 = float64(x)
+        h = bitmix(h, hash(f64)$11111)
+        x -= f64
+    end
+    h
+end
+
 end #module
diff --git a/base/operators.jl b/base/operators.jl
index b42f925fa64b8..65db381c8b935 100644
--- a/base/operators.jl
+++ b/base/operators.jl
@@ -22,9 +22,8 @@ isequal(x,y) = is(x,y)
 .> (x,y) = y.<x
 .>=(x,y) = y.<=x
 
-# these definitions allow Number types to implement
-# == and < instead of isequal and isless, which is more idiomatic:
-isequal(x::Number, y::Number) = x==y
+# this definition allows Number types to implement < instead of isless,
+# which is more idiomatic:
 isless(x::Real, y::Real) = x<y
 
 max(x,y) = y < x ? x : y
diff --git a/base/range.jl b/base/range.jl
index f013b0566c6da..862a5830a66c9 100644
--- a/base/range.jl
+++ b/base/range.jl
@@ -150,9 +150,6 @@ done(r::Ranges, i) = (length(r) <= i)
 
 ==(r::Ranges, s::Ranges) = (r.start==s.start) & (step(r)==step(s)) & (r.len==s.len)
 ==(r::Range1, s::Range1) = (r.start==s.start) & (r.len==s.len)
-isequal(r::Ranges, s::Ranges) =
-    isequal(r.start,s.start) & isequal(step(r),step(s)) & (r.len==s.len)
-isequal(r::Range1, s::Range1) = isequal(r.start,s.start) & (r.len==s.len)
 
 # TODO: isless?
 
diff --git a/base/rational.jl b/base/rational.jl
index de74ae3415c4f..4cc07eb51ce81 100644
--- a/base/rational.jl
+++ b/base/rational.jl
@@ -105,9 +105,7 @@ typemax{T<:Integer}(::Type{Rational{T}}) = one(T)//zero(T)
 isinteger(x::Rational) = x.den == 1
 isfloat64(x::Rational) = ispow2(x.den) & (abs(x.num) <= x.den*maxintfloat(Float64))
 
-hash(x::Rational) = isinteger(x) ? hash(x.num) :
-                    isfloat64(x) ? hash(float64(x)) :
-                    bitmix(hash(x.num), hash(x.den))
+hash(x::Rational) = bitmix(hash(x.num), ~hash(x.den))
 
 -(x::Rational) = (-x.num) // x.den
 for op in (:+, :-, :rem, :mod)
diff --git a/base/string.jl b/base/string.jl
index ffb6e8ef63255..8900ae7ca2305 100644
--- a/base/string.jl
+++ b/base/string.jl
@@ -286,8 +286,6 @@ end
 isequal(a::String, b::String) = cmp(a,b) == 0
 isless(a::String, b::String)  = cmp(a,b) <  0
 
-hash(s::String) = hash(bytestring(s))
-
 # begins with and ends with predicates
 
 function beginswith(a::String, b::String)
diff --git a/doc/stdlib/base.rst b/doc/stdlib/base.rst
index 3da2c95d956f7..a92dfcad4be81 100644
--- a/doc/stdlib/base.rst
+++ b/doc/stdlib/base.rst
@@ -109,7 +109,8 @@ All Objects
 .. function:: isequal(x, y)
 
    True if and only if ``x`` and ``y`` have the same contents. Loosely speaking, this means ``x`` and ``y`` would look the same when printed. This is the default comparison function used by hash tables (``Dict``).
-   New types with a notion of equality should implement this function, except for numbers, which should implement ``==`` instead. However, numeric types with special values might need to implement ``isequal`` as well. For example, floating point ``NaN`` values are not ``==``, but are all equivalent in the sense of ``isequal``.
+   New types with a notion of equality should implement this function, except for numbers, which should implement ``==`` instead. However, numeric types with special values might need to implement ``isequal`` as well. For example, floating point ``NaN`` values are not ``==``, but are all equivalent in the sense of ``isequal``. Numbers of different types are considered unequal.
+   Mutable containers should generally implement ``isequal`` by calling ``isequal`` recursively on all contents.
 
 .. function:: isless(x, y)
 
diff --git a/test/arrayops.jl b/test/arrayops.jl
index 57796c38960c2..3212014629681 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -200,8 +200,8 @@ v = pop!(l)
 @test length(l)==2
 
 # concatenation
-@test isequal([ones(2,2)  2*ones(2,1)], [1 1 2; 1 1 2])
-@test isequal([ones(2,2), 2*ones(1,2)], [1 1; 1 1; 2 2])
+@test isequal([ones(2,2)  2*ones(2,1)], [1. 1 2; 1 1 2])
+@test isequal([ones(2,2), 2*ones(1,2)], [1. 1; 1 1; 2 2])
 
 # typed array literals
 X = Float64[1 2 3]
diff --git a/test/bitarray.jl b/test/bitarray.jl
index 8b24014ee945d..011e301e05e29 100644
--- a/test/bitarray.jl
+++ b/test/bitarray.jl
@@ -45,7 +45,7 @@ s4 = 4
 
 b1 = randbool(n1, n2)
 @test isequal(bitpack(bitunpack(b1)), b1)
-i1 = rand(1:2, n1, n2) - 1
+i1 = rand(false:true, n1, n2)
 @test isequal(bitunpack(bitpack(i1)), i1)
 
 timesofar("conversions")
diff --git a/test/hashing.jl b/test/hashing.jl
index d2df7483d55b5..2370e3c31598b 100644
--- a/test/hashing.jl
+++ b/test/hashing.jl
@@ -29,8 +29,4 @@ for T=types, S=types, x=vals
     # end
 end
 
-f = prevfloat(float64(typemax(Uint64)))
-@test hash(f) == hash(0xfffffffffffff800)
-@test hash(f) == hash(-2048)
-
 @test hash(RopeString("1","2")) == hash("12")
diff --git a/test/mpfr.jl b/test/mpfr.jl
index 31327db47b610..257d09a7b85d8 100644
--- a/test/mpfr.jl
+++ b/test/mpfr.jl
@@ -377,7 +377,7 @@ with_bigfloat_precision(53) do
         end
     end
     for f in (:sin,:cos,:tan,:sec,:csc,:cot,:cosh,:sinh,:tanh,
-            :sech,:csch,:coth,:acosh,:asinh),
+              :sech,:csch,:coth,:acosh,:asinh),
         j in (1., 1.5, 1.9)
         @eval begin
             @test_approx_eq ($f)(BigFloat($j)) ($f)($j)
@@ -393,7 +393,7 @@ end
 
 # atan2
 with_bigfloat_precision(53) do
-    @test isequal(atan2(12,2), atan2(BigFloat(12), BigFloat(2)))
+    @test atan2(12,2) == atan2(BigFloat(12), BigFloat(2))
 end
 
 # ldexp
diff --git a/test/numbers.jl b/test/numbers.jl
index 2393252834339..e9ecdb59d9713 100644
--- a/test/numbers.jl
+++ b/test/numbers.jl
@@ -346,8 +346,8 @@
 @test !isequal(+1.0,-1.0)
 @test !isequal(+Inf,-Inf)
 
-@test  isequal(-0.0f0,-0.0)
-@test  isequal( 0.0f0, 0.0)
+@test !isequal(-0.0f0,-0.0)
+@test !isequal( 0.0f0, 0.0)
 @test !isequal(-0.0f0, 0.0)
 @test !isequal(0.0f0 ,-0.0)
 
@@ -423,8 +423,8 @@
 @test !isless(+NaN,-NaN)
 @test !isless(+NaN,+NaN)
 
-@test  isequal(   0, 0.0)
-@test  isequal( 0.0,   0)
+@test !isequal(   0, 0.0)
+@test !isequal( 0.0,   0)
 @test !isequal(   0,-0.0)
 @test !isequal(-0.0,   0)
 @test   isless(-0.0,   0)