Deprecate functions vectorized via @vectorize_(1|2)arg in favor of compact broadcast syntax

base/complex.jl

@@ -366,7 +366,6 @@ function cis(z::Complex)
     v = exp(-imag(z))
     Complex(v*cos(real(z)), v*sin(real(z)))
 end
-@vectorize_1arg Number cis
 
 """
     angle(z)
@@ -807,16 +806,13 @@ function round{T<:AbstractFloat, MR, MI}(z::Complex{T}, ::RoundingMode{MR}, ::Ro
 end
 round(z::Complex) = Complex(round(real(z)), round(imag(z)))
 
-@vectorize_1arg Complex round
-
 function round(z::Complex, digits::Integer, base::Integer=10)
     Complex(round(real(z), digits, base),
             round(imag(z), digits, base))
 end
 
 float{T<:AbstractFloat}(z::Complex{T}) = z
 float(z::Complex) = Complex(float(real(z)), float(imag(z)))
-@vectorize_1arg Complex float
 
 big{T<:AbstractFloat}(z::Complex{T}) = Complex{BigFloat}(z)
 big{T<:Integer}(z::Complex{T}) = Complex{BigInt}(z)

base/dates/accessors.jl

@@ -59,21 +59,6 @@ yearmonth(dt::TimeType) = yearmonth(days(dt))
 monthday(dt::TimeType) = monthday(days(dt))
 yearmonthday(dt::TimeType) = yearmonthday(days(dt))
 
-@vectorize_1arg TimeType year
-@vectorize_1arg TimeType month
-@vectorize_1arg TimeType day
-@vectorize_1arg TimeType week
-@vectorize_1arg DateTime hour
-@vectorize_1arg DateTime minute
-@vectorize_1arg DateTime second
-@vectorize_1arg DateTime millisecond
-
-@vectorize_1arg TimeType dayofmonth
-@vectorize_1arg TimeType yearmonth
-@vectorize_1arg TimeType monthday
-@vectorize_1arg TimeType yearmonthday
-
-
 # Documentation for exported accessors
 for func in (:year, :month)
     name = string(func)

base/dates/adjusters.jl

@@ -42,9 +42,6 @@ function lastdayofweek end
 lastdayofweek(dt::Date) = Date(UTD(value(dt) + (7 - dayofweek(dt))))
 lastdayofweek(dt::DateTime) = DateTime(lastdayofweek(Date(dt)))
 
-@vectorize_1arg TimeType firstdayofweek
-@vectorize_1arg TimeType lastdayofweek
-
 """
     firstdayofmonth(dt::TimeType) -> TimeType
 
@@ -68,9 +65,6 @@ function lastdayofmonth(dt::Date)
 end
 lastdayofmonth(dt::DateTime) = DateTime(lastdayofmonth(Date(dt)))
 
-@vectorize_1arg TimeType firstdayofmonth
-@vectorize_1arg TimeType lastdayofmonth
-
 """
     firstdayofyear(dt::TimeType) -> TimeType
 
@@ -94,9 +88,6 @@ function lastdayofyear(dt::Date)
 end
 lastdayofyear(dt::DateTime) = DateTime(lastdayofyear(Date(dt)))
 
-@vectorize_1arg TimeType firstdayofyear
-@vectorize_1arg TimeType lastdayofyear
-
 """
     firstdayofquarter(dt::TimeType) -> TimeType
 
@@ -125,9 +116,6 @@ function lastdayofquarter(dt::Date)
 end
 lastdayofquarter(dt::DateTime) = DateTime(lastdayofquarter(Date(dt)))
 
-@vectorize_1arg TimeType firstdayofquarter
-@vectorize_1arg TimeType lastdayofquarter
-
 # Temporal Adjusters
 immutable DateFunction
     f::Function

base/dates/conversions.jl

@@ -46,9 +46,6 @@ See `convert(Int64,dt::Date)` for inverse.
 """
 Base.convert{R<:Real}(::Type{Date}, x::R) = Date(UTD(x))
 
-@vectorize_1arg DateTime Date
-@vectorize_1arg Date DateTime
-
 ### External Conversions
 const UNIXEPOCH = value(DateTime(1970)) #Rata Die milliseconds for 1970-01-01T00:00:00
 
@@ -132,10 +129,3 @@ Takes the given `DateTime` and returns the number of Julian calendar days since
 epoch `-4713-11-24T12:00:00` as a `Float64`.
 """
 datetime2julian(dt::DateTime) = (value(dt) - JULIANEPOCH)/86400000.0
-
-@vectorize_1arg Real unix2datetime
-@vectorize_1arg DateTime datetime2unix
-@vectorize_1arg Real rata2datetime
-@vectorize_1arg DateTime datetime2rata
-@vectorize_1arg Real julian2datetime
-@vectorize_1arg DateTime datetime2julian

base/dates/query.jl

@@ -97,12 +97,6 @@ function daysofweekinmonth(dt::TimeType)
            (d in THIRTYONE) ? 5 : 4
 end
 
-@vectorize_1arg TimeType dayname
-@vectorize_1arg TimeType dayabbr
-@vectorize_1arg TimeType dayofweek
-@vectorize_1arg TimeType dayofweekofmonth
-@vectorize_1arg TimeType daysofweekinmonth
-
 ### Months
 const January,February,March,April,May,June = 1,2,3,4,5,6
 const July,August,September,October,November,December = 7,8,9,10,11,12
@@ -139,10 +133,6 @@ Returns the number of days in the month of `dt`. Value will be 28, 29, 30, or 31
 """
 daysinmonth(dt::TimeType) = ((y,m) = yearmonth(dt); return daysinmonth(y,m))
 
-@vectorize_1arg TimeType monthname
-@vectorize_1arg TimeType monthabbr
-@vectorize_1arg TimeType daysinmonth
-
 ### Years
 """
     isleapyear(dt::TimeType) -> Bool
@@ -160,10 +150,6 @@ dayofyear(dt::TimeType) = ((y,m,d) = yearmonthday(dt); return dayofyear(y,m,d))
 
 daysinyear(dt::TimeType) = 365 + isleapyear(dt)
 
-@vectorize_1arg TimeType isleapyear
-@vectorize_1arg TimeType dayofyear
-@vectorize_1arg TimeType daysinyear
-
 ### Quarters
 """
     quarterofyear(dt::TimeType) -> Int
@@ -182,6 +168,3 @@ const QUARTERDAYS = [0,90,181,273]
 Returns the day of the current quarter of `dt`. Range of value is 1:92.
 """
 dayofquarter(dt::TimeType) = dayofyear(dt) - QUARTERDAYS[quarterofyear(dt)]
-
-@vectorize_1arg TimeType quarterofyear
-@vectorize_1arg TimeType dayofquarter

base/deprecated.jl

@@ -865,4 +865,134 @@ for f in (:sin, :sinh, :sind, :asin, :asinh, :asind,
     @eval @deprecate $f(A::SparseMatrixCSC) $f.(A)
 end
 
+# For deprecating vectorized functions in favor of compact broadcast syntax
+macro dep_vectorize_1arg(S, f)
+    S = esc(S)
+    f = esc(f)
+    T = esc(:T)
+    x = esc(:x)
+    AbsArr = esc(:AbstractArray)
+    :( @deprecate $f{$T<:$S}($x::$AbsArr{$T}) $f.($x) )
+end
+macro dep_vectorize_2arg(S, f)
+    S = esc(S)
+    f = esc(f)
+    T1 = esc(:T1)
+    T2 = esc(:T2)
+    x = esc(:x)
+    y = esc(:y)
+    AbsArr = esc(:AbstractArray)
+    quote
+        @deprecate $f{$T1<:$S}($x::$S, $y::$AbsArr{$T1}) $f.($x,$y)
+        @deprecate $f{$T1<:$S}($x::$AbsArr{$T1}, $y::$S) $f.($x,$y)
+        @deprecate $f{$T1<:$S,$T2<:$S}($x::$AbsArr{$T1}, $y::$AbsArr{$T2}) $f.($x,$y)
+    end
+end
+
+# Deprecate @vectorize_1arg-vectorized functions from...
+for f in (
+        # base/special/trig.jl
+        :sinpi, :cospi, :sinc, :cosc,
+        # base/special/log.jl
+        :log, :log1p,
+        # base/special/gamma.jl
+        :gamma, :lfact, :digamma, :trigamma, :zeta, :eta,
+        # base/special/erf.jl
+        :erfcx, :erfi, :dawson,
+        # base/special/bessel.jl
+        :airyprime, :airyai, :airyaiprime, :airybi, :airybiprime,
+        :airy, :airyx, :besselj0, :besselj1, :bessely0, :bessely1,
+        # base/math.jl
+        :cbrt, :sinh, :cosh, :tanh, :atan, :asinh, :exp, :erf, :erfc, :exp2,
+        :expm1, :exp10, :sin, :cos, :tan, :asin, :acos, :acosh, :atanh,
+        #=:log,=# :log2, :log10, :lgamma, #=:log1p,=# :sqrt,
+        # base/floatfuncs.jl
+        :abs, :abs2, :angle, :isnan, :isinf, :isfinite,
+        # base/fastmath.jl
+        :acos_fast, :acosh_fast, :angle_fast, :asin_fast, :asinh_fast,
+        :atan_fast, :atanh_fast, :cbrt_fast, :cis_fast, :cos_fast,
+        :cosh_fast, :exp10_fast, :exp2_fast, :exp_fast, :expm1_fast,
+        :lgamma_fast, :log10_fast, :log1p_fast, :log2_fast, :log_fast,
+        :sin_fast, :sinh_fast, :sqrt_fast, :tan_fast, :tanh_fast,
+        # base/complex.jl
+        :cis,
+        )
+    @eval @dep_vectorize_1arg Number $f
+end
+for f in (
+        :invdigamma, # base/special/gamma.jl
+        :erfinc, :erfcinv, # base/special/erf.jl
+        :trunc, :floor, :ceil, :round, # base/floatfuncs.jl
+        :rad2deg, :deg2rad, :exponent, :significand, # base/math.jl
+        :unix2datetime, :rata2datetime, :julian2datetime, # base/dates/conversions.jl
+        :sind, :cosd, :tand, :asind, :acosd, :atand, :asecd, :acscd, :acotd, # base/special/trig.jl
+        )
+    @eval @dep_vectorize_1arg Real $f
+end
+# base/complex.jl
+@dep_vectorize_1arg Complex round
+@dep_vectorize_1arg Complex float
+for f in (
+        # base/dates/accessors.jl
+        :year, :month, :day, :week, :dayofmonth, :yearmonth, :monthday, :yearmonthday,
+        # base/dates/adjusters.jl
+        :firstdayofweek, :lastdayofweek, :firstdayofmonth,
+        :lastdayofmonth, :firstdayofyear, :lastdayofyear,
+        :firstdayofquarter, :lastdayofquarter,
+        # base/dates/query.jl
+        :dayname, :dayabbr, :dayofweek, :dayofweekofmonth,
+        :daysofweekinmonth, :monthname, :monthabbr, :daysinmonth,
+        :isleapyear, :dayofyear, :daysinyear, :quarterofyear, :dayofquarter,
+    )
+    @eval @dep_vectorize_1arg Dates.TimeType $f
+end
+for f in (
+    :hour, :minute, :second, :millisecond, # base/dates/accessors.jl
+    :Date, :datetime2unix, :datetime2rata, :datetime2julian, # base/dates/conversions.jl
+    )
+    @eval @dep_vectorize_1arg Dates.DateTime $f
+end
+@dep_vectorize_1arg Dates.Date Datetime # base/dates/conversions.jl
+
+# Deprecate @vectorize_2arg-vectorized functions from...
+for f in (
+        # base/special/gamma.jl
+        :polygamma, :zeta, :beta, :lbeta,
+        # base/special/bessel.jl
+        :airy, :airyx, :besseli, :besselix, :besselj, :besseljx,
+        :besselk, :besselkx, :bessely, :besselyx, :besselh,
+        :besselhx, :hankelh1, :hankelh2, :hankelh1x, :hankelh2x,
+        # base/math.jl
+        :log, :hypot, :atan2,
+        # base/fastmath.jl
+        :pow_fast, :atan2_fast, :hypot_fast, :max_fast, :min_fast, :minmax_fast,
+    )
+    @eval @dep_vectorize_2arg Number $f
+end
+for f in (
+        :max, :min, # base/math.jl
+        :copysign, :flipsign, # base/floatfuncs.jl
+    )
+    @eval @dep_vectorize_2arg Real $f
+end
+
+# Deprecate @vectorize_1arg and @vectorize_2arg themselves
+macro vectorize_1arg(S,f)
+    depwarn(string("`@vectorize_1arg` is deprecated in favor of compact broadcast syntax. ",
+        "Instead of `@vectorize_1arg`'ing function `f` and calling `f(arg)`, call `f.(arg)`."),
+        :vectorize_1arg)
+    quote
+        @dep_vectorize_1arg($(esc(S)),$(esc(f)))
+    end
+end
+macro vectorize_2arg(S,f)
+    depwarn(string("`@vectorize_2arg` is deprecated in favor of compact broadcast syntax. ",
+        "Instead of `@vectorize_2arg`'ing function `f` and calling `f(arg1, arg2)`, call ",
+        "`f.(arg1,arg2)`. "), :vectorize_2arg)
+    quote
+        @dep_vectorize_2arg($(esc(S)),$(esc(f)))
+    end
+end
+export @vectorize_1arg, @vectorize_2arg
+
 # End deprecations scheduled for 0.6

base/docs/helpdb/Base.jl

@@ -560,7 +560,9 @@ randsubseq!
 """
     maximum(A, dims)
 
-Compute the maximum value of an array over the given dimensions.
+Compute the maximum value of an array over the given dimensions. See also the
+[`max(a,b)`](:func:`max`) function to take the maximum of two or more arguments,
+which can be applied elementwise to arrays via `max.(a,b)`.
 """
 maximum(A,dims)
 
@@ -1531,7 +1533,9 @@ asinh
 """
     minimum(A, dims)
 
-Compute the minimum value of an array over the given dimensions.
+Compute the minimum value of an array over the given dimensions. See also the
+[`min(a,b)`](:func:`min`) function to take the minimum of two or more arguments,
+which can be applied elementwise to arrays via `min.(a,b)`.
 """
 minimum(A,dims)
 

base/exports.jl

@@ -1396,8 +1396,6 @@ export
     @generated,
     @gensym,
     @eval,
-    @vectorize_1arg,
-    @vectorize_2arg,
     @deprecate,
 
     # performance annotations

base/fastmath.jl

@@ -343,7 +343,6 @@ for f in (:acos, :acosh, :angle, :asin, :asinh, :atan, :atanh, :cbrt,
     f_fast = fast_op[f]
     @eval begin
         $f_fast(x) = $f(x)
-        @vectorize_1arg Number $f_fast
     end
 end
 
@@ -356,7 +355,6 @@ for f in (:^, :atan2, :hypot, :max, :min, :minmax)
         $f_fast(x::Number, y::Number) = $f_fast(promote(x, y)...)
         # fall-back implementation that applies after promotion
         $f_fast{T<:Number}(x::T, y::T) = $f(x, y)
-        @vectorize_2arg Number $f_fast
     end
 end
 

base/floatfuncs.jl

@@ -6,13 +6,11 @@ copysign(x::Float64, y::Float64) = box(Float64,copysign_float(unbox(Float64,x),u
 copysign(x::Float32, y::Float32) = box(Float32,copysign_float(unbox(Float32,x),unbox(Float32,y)))
 copysign(x::Float32, y::Real) = copysign(x, Float32(y))
 copysign(x::Float64, y::Real) = copysign(x, Float64(y))
-@vectorize_2arg Real copysign
 
 flipsign(x::Float64, y::Float64) = box(Float64,xor_int(unbox(Float64,x),and_int(unbox(Float64,y),0x8000000000000000)))
 flipsign(x::Float32, y::Float32) = box(Float32,xor_int(unbox(Float32,x),and_int(unbox(Float32,y),0x80000000)))
 flipsign(x::Float32, y::Real) = flipsign(x, Float32(y))
 flipsign(x::Float64, y::Real) = flipsign(x, Float64(y))
-@vectorize_2arg Real flipsign
 
 signbit(x::Float64) = signbit(reinterpret(Int64,x))
 signbit(x::Float32) = signbit(reinterpret(Int32,x))
@@ -40,14 +38,6 @@ function hex2num(s::AbstractString)
     return box(Float64,unbox(UInt64,parse(UInt64,s,16)))
 end
 
-@vectorize_1arg Number abs
-@vectorize_1arg Number abs2
-@vectorize_1arg Number angle
-
-@vectorize_1arg Number isnan
-@vectorize_1arg Number isinf
-@vectorize_1arg Number isfinite
-
 """
     round([T,] x, [digits, [base]], [r::RoundingMode])
 
@@ -107,7 +97,6 @@ julia> round(pi, 3, 2)
     ```
 """
 round(T::Type, x)
-
 round(x::Real, ::RoundingMode{:ToZero}) = trunc(x)
 round(x::Real, ::RoundingMode{:Up}) = ceil(x)
 round(x::Real, ::RoundingMode{:Down}) = floor(x)
@@ -123,11 +112,6 @@ function round(x::AbstractFloat, ::RoundingMode{:NearestTiesUp})
 end
 round{T<:Integer}(::Type{T}, x::AbstractFloat, r::RoundingMode) = trunc(T,round(x,r))
 
-@vectorize_1arg Real trunc
-@vectorize_1arg Real floor
-@vectorize_1arg Real ceil
-@vectorize_1arg Real round
-
 for f in (:trunc,:floor,:ceil,:round)
     @eval begin
         function ($f){T,R}(::Type{T}, x::AbstractArray{R,1})

base/irrationals.jl

@@ -174,7 +174,7 @@ for T in (Irrational, Rational, Integer, Number)
     ^(::Irrational{:e}, x::T) = exp(x)
 end
 for T in (Range, BitArray, StridedArray, AbstractArray)
-    .^(::Irrational{:e}, x::T) = exp(x)
+    .^(::Irrational{:e}, x::T) = exp.(x)
 end
 
 log(::Irrational{:e}) = 1 # use 1 to correctly promote expressions like log(x)/log(e)

base/linalg/arnoldi.jl

@@ -382,7 +382,7 @@ function _svds(X; nsv::Int = 6, ritzvec::Bool = true, tol::Float64 = 0.0, maxite
     end
     ex    = eigs(SVDOperator(X), I; ritzvec = ritzvec, nev = ncv, tol = tol, maxiter = maxiter, v0=padv0)
     ind   = [1:2:ncv;]
-    sval  = abs(ex[1][ind])
+    sval  = abs.(ex[1][ind])
 
     if ritzvec
         # calculating singular vectors