Added examples for ones, eye. Fixed up BitArray docs.

Removed calls to `rand` in the doctests.

Author: kshyatt

base/array.jl

@@ -171,7 +171,42 @@ for (fname, felt) in ((:zeros,:zero), (:ones,:one))
         ($fname){T}(A::AbstractArray{T}) = fill!(similar(A), ($felt)(T))
     end
 end
+"""
+    ones([T::Type=Float64,] dims)
+
+Create an array of all ones of specified type. The type defaults to `Float64` if not specified.
+"""
+function ones(dims::Dims) end
+
+"""
+    ones(A)
+
+Create an array of all ones with the same element type and shape as `A`.
+
+```jldoctest
+julia> A = [1 2 3; 4 5 6; 7 8 9]
+3×3 Array{Int64,2}:
+ 1  2  3
+ 4  5  6
+ 7  8  9
+
+julia> ones(A)
+3×3 Array{Int64,2}:
+ 1  1  1
+ 1  1  1
+ 1  1  1
+```
+
+Note the difference from [`eye`](:func:`eye`).
+"""
+function ones(A) end
+
+"""
+    eye([T::Type=Float64,] m::Integer, n::Integer)
 
+`m`-by-`n` identity matrix.
+The default element type is `Float64`.
+"""
 function eye(T::Type, m::Integer, n::Integer)
     a = zeros(T,m,n)
     for i = 1:min(m,n)
@@ -181,7 +216,35 @@ function eye(T::Type, m::Integer, n::Integer)
 end
 eye(m::Integer, n::Integer) = eye(Float64, m, n)
 eye(T::Type, n::Integer) = eye(T, n, n)
+"""
+    eye([T::Type=Float64,] n::Integer)
+
+`n`-by-`n` identity matrix.
+The default element type is `Float64`.
+"""
 eye(n::Integer) = eye(Float64, n)
+
+"""
+    eye(A)
+
+Constructs an identity matrix of the same dimensions and type as `A`.
+
+```jldoctest
+julia> A = [1 2 3; 4 5 6; 7 8 9]
+3×3 Array{Int64,2}:
+ 1  2  3
+ 4  5  6
+ 7  8  9
+
+julia> eye(A)
+3×3 Array{Int64,2}:
+ 1  0  0
+ 0  1  0
+ 0  0  1
+```
+
+Note the difference from [`ones`](:func:`ones`).
+"""
 eye{T}(x::AbstractMatrix{T}) = eye(T, size(x, 1), size(x, 2))
 
 function one{T}(x::AbstractMatrix{T})

base/bitarray.jl

@@ -1438,35 +1438,8 @@ end
 """
     rol!(dest::BitVector, src::BitVector, i::Integer) -> BitVector
 
-Performs a left rotation operation on `src` and put the result into `dest`.
-
-```jldoctest
-julia> a = bitrand(5)
-5-element BitArray{1}:
- false
- false
-  true
-  true
-  true
-
-julia> b = falses(5);
-
-julia> rol!(b,a,2)
-5-element BitArray{1}:
-  true
-  true
-  true
- false
- false
-
-julia> rol!(b,a,3)
-5-element BitArray{1}:
-  true
-  true
- false
- false
-  true
-```
+Performs a left rotation operation on `src` and puts the result into `dest`.
+`i` controls how far to rotate each bit.
 """
 function rol!(dest::BitVector, src::BitVector, i::Integer)
     length(dest) == length(src) || throw(ArgumentError("destination and source should be of same size"))
@@ -1483,56 +1456,46 @@ end
 """
     rol!(B::BitVector, i::Integer) -> BitVector
 
-Performs a left rotation operation on `B`.
+Performs a left rotation operation in-place on `B`.
+`i` controls how far to rotate each bit.
+"""
+function rol!(B::BitVector, i::Integer)
+    return rol!(B, B, i)
+end
+
+"""
+    rol(B::BitVector, i::Integer) -> BitVector
+
+Performs a left rotation operation, returning a new `BitVector`.
+`i` controls how far to rotate each bit.
+See also [`rol!`](:func:`rol!`).
 
 ```jldoctest
-julia> a = bitrand(5)
+julia> A = BitArray([true, true, false, false, true])
 5-element BitArray{1}:
   true
+  true
  false
  false
   true
-  true
 
-julia> rol!(a,4)
+julia> rol(A,1)
 5-element BitArray{1}:
   true
-  true
  false
  false
   true
-"""
-function rol!(B::BitVector, i::Integer)
-    return rol!(B, B, i)
-end
-
-"""
-    rol(B::BitVector, i::Integer) -> BitVector
-
-Performs a left rotation operation without modifying `B`.
-See also [`rol!`](:func:`rol!`).
-"""
-function rol(B::BitVector, i::Integer)
-    return rol!(similar(B), B, i)
-end
-
-"""
-    ror!(dest::BitVector, src::BitVector, i::Integer) -> BitVector
-
-Performs a right rotation operation on `src` and put the result into `dest`.
+  true
 
-```jldoctest
-julia> a = bitrand(5)
+julia> rol(A,2)
 5-element BitArray{1}:
  false
  false
   true
   true
   true
 
-julia> b = falses(5);
-
-julia> ror!(b,a,2)
+julia> rol(A,5)
 5-element BitArray{1}:
   true
   true
@@ -1541,6 +1504,16 @@ julia> ror!(b,a,2)
   true
 ```
 """
+function rol(B::BitVector, i::Integer)
+    return rol!(similar(B), B, i)
+end
+
+"""
+    ror!(dest::BitVector, src::BitVector, i::Integer) -> BitVector
+
+Performs a right rotation operation on `src` and puts the result into `dest`.
+`i` controls how far to rotate each bit.
+"""
 function ror!(dest::BitVector, src::BitVector, i::Integer)
     length(dest) == length(src) || throw(ArgumentError("destination and source should be of same size"))
     n = length(dest)
@@ -1556,36 +1529,54 @@ end
 """
     ror!(B::BitVector, i::Integer) -> BitVector
 
-Performs a right rotation operation on `B`.
+Performs a right rotation operation in-place on `B`.
+`i` controls how far to rotate each bit.
+"""
+function ror!(B::BitVector, i::Integer)
+    return ror!(B, B, i)
+end
+
+"""
+    ror(B::BitVector, i::Integer) -> BitVector
+
+Performs a right rotation operation on `B`, returning a new `BitVector`.
+`i` controls how far to rotate each bit.
+See also [`ror!`](:func:`ror!`).
 
 ```jldoctest
-julia> a = bitrand(5)
+julia> A = BitArray([true, true, false, false, true])
 5-element BitArray{1}:
- false
   true
+  true
+ false
  false
   true
+
+julia> ror(A,1)
+5-element BitArray{1}:
+  true
+  true
+  true
+ false
  false
 
-julia> ror!(a,3)
+julia> ror(A,2)
 5-element BitArray{1}:
  false
   true
+  true
+  true
+ false
+
+julia> ror(A,5)
+5-element BitArray{1}:
+  true
+  true
  false
  false
   true
 ```
 """
-function ror!(B::BitVector, i::Integer)
-    return ror!(B, B, i)
-end
-
-"""
-    ror(B::BitVector, i::Integer) -> BitVector
-
-Performs a right rotation operation without modifying `B`.
-See also [`ror!`](:func:`ror!`).
-"""
 function ror(B::BitVector, i::Integer)
     return ror!(similar(B), B, i)
 end

base/docs/helpdb/Base.jl

@@ -1225,20 +1225,6 @@ of the problem that is solved on each processor.
 """
 peakflops
 
-"""
-    ones(type, dims)
-
-Create an array of all ones of specified type. The type defaults to `Float64` if not specified.
-"""
-ones(t,dims)
-
-"""
-    ones(A)
-
-Create an array of all ones with the same element type and shape as `A`.
-"""
-ones(A)
-
 """
     ind2chr(string, i)
 
@@ -4068,27 +4054,6 @@ Euler integral of the first kind ``\\operatorname{B}(x,y) = \\Gamma(x)\\Gamma(y)
 """
 beta
 
-"""
-    eye(n)
-
-`n`-by-`n` identity matrix.
-"""
-eye(n::Int)
-
-"""
-    eye(m, n)
-
-`m`-by-`n` identity matrix.
-"""
-eye(m, n)
-
-"""
-    eye(A)
-
-Constructs an identity matrix of the same dimensions and type as `A`.
-"""
-eye(A)
-
 """
     diagind(M[, k])