Merge branch 'jb/working8_10_11' of github.com:JuliaLang/julia

Conflicts:
	j/intfuncs.j

Author: JeffBezanson

j/abstractarray.j

@@ -149,10 +149,40 @@ end
 \(A::Number, B::AbstractArray) = B ./ A
 \(A::AbstractArray, B::Number) = B ./ A
 
+# ^ is difficult, since negative exponents give a different type
+
 .^(x::AbstractArray, y::AbstractArray) = reshape( [ x[i] ^ y[i] | i=1:numel(x) ], size(x) )
 .^(x::Number,        y::AbstractArray) = reshape( [ x    ^ y[i] | i=1:numel(y) ], size(y) )
 .^(x::AbstractArray, y::Number       ) = reshape( [ x[i] ^ y    | i=1:numel(x) ], size(x) )
 
+function .^{S<:Int,T<:Int}(A::AbstractArray{S}, B::AbstractArray{T})
+    F = similar(A, Float64)
+    for i=1:numel(A)
+        F[i] = A[i]^B[i]
+    end
+    return F
+end
+
+function .^{T<:Int}(A::Int, B::AbstractArray{T})
+    F = similar(B, Float64)
+    for i=1:numel(B)
+        F[i] = A^B[i]
+    end
+    return F
+end
+
+function power_array_int_body(F, A, B)
+    for i=1:numel(A)
+        F[i] = A[i]^B
+    end
+    return F
+end
+
+function .^{T<:Int}(A::AbstractArray{T}, B::Int)
+    F = similar(A, B < 0 ? Float64 : promote_type(T,typeof(B)))
+    power_array_int_body(F, A, B)
+end
+
 macro binary_arithmetic_op(f)
     quote
 
@@ -810,12 +840,13 @@ function map(f, A::AbstractArray)
         return A
     end
     first = f(A[1])
-    dest = Array(typeof(first), size(A))
-    dest[1] = first
-    for i=2:numel(A)
-        dest[i] = f(A[i])
-    end
-    return dest
+    dest = similar(A, typeof(first))
+    map_to(dest, f, A)
+    # dest[1] = first
+    # for i=2:numel(A)
+    #     dest[i] = f(A[i])
+    # end
+    # return dest
 end
 
 #obsolete code, mainly here for reference purposes, use gen_cartesian_map

j/darray.j

@@ -490,6 +490,27 @@ end
 
 ## elementwise operators ##
 
+function .^{T}(A::Int, B::DArray{T})
+    S = promote_type(typeof(A),T)
+    darray((T,lsz,da)->.^(A, localize(B)),
+           S, size(B), B.distdim, B.pmap)
+end
+function .^{T}(A::DArray{T}, B::Int)
+    S = promote_type(T,typeof(B))
+    darray((T,lsz,da)->.^(localize(A), B),
+           S, size(A), A.distdim, A.pmap)
+end
+
+function .^{T<:Int}(A::Int, B::DArray{T})
+    darray((T,lsz,da)->.^(A, localize(B)),
+           Float64, size(B), B.distdim, B.pmap)
+end
+function .^{T<:Int}(A::DArray{T}, B::Int)
+    S = B < 0 ? Float64 : promote_type(T,typeof(B))
+    darray((T,lsz,da)->.^(localize(A), B),
+           S, size(A), A.distdim, A.pmap)
+end
+
 macro binary_darray_op(f)
     quote
         function ($f){T}(A::Number, B::DArray{T})

j/intfuncs.j

@@ -101,8 +101,7 @@ function power_by_squaring(x, p::Int)
 end
 
 ^(x, p::Int)          = power_by_squaring(x,p)
-^(x::Int, p::Int)     = power_by_squaring(float64(x),p)
-^{T<:Int}(x::T, p::T) = power_by_squaring(float64(x),p)
+^{T<:Int}(x::T, p::T) = power_by_squaring(x,p)
 
 # x^p mod m
 function powermod(x::Int, p::Int, m::Int)