make rounding name modes consistent with symbols

base/floatfuncs.jl

@@ -44,16 +44,16 @@ end
 @vectorize_1arg Number isfinite
 
 
-round(x::Real, ::RoundingMode{:TowardZero}) = trunc(x)
-round(x::Real, ::RoundingMode{:TowardPositive}) = ceil(x)
-round(x::Real, ::RoundingMode{:TowardNegative}) = floor(x)
+round(x::Real, ::RoundingMode{:ToZero}) = trunc(x)
+round(x::Real, ::RoundingMode{:Up}) = ceil(x)
+round(x::Real, ::RoundingMode{:Down}) = floor(x)
 # C-style round
-function round(x::FloatingPoint, ::RoundingMode{:TiesToAway})
+function round(x::FloatingPoint, ::RoundingMode{:NearestTiesAway})
     y = trunc(x)
     ifelse(x==y,y,trunc(2*x-y))
 end
 # Java-style round
-function round(x::FloatingPoint, ::RoundingMode{:TiesToPositive})
+function round(x::FloatingPoint, ::RoundingMode{:NearestTiesUp})
     y = floor(x)
     ifelse(x==y,y,copysign(floor(2*x-y),x))
 end

base/mpfr.jl

@@ -628,11 +628,11 @@ end
 maxintfloat(x::BigFloat) = BigFloat(2)^precision(x)
 maxintfloat(::Type{BigFloat}) = BigFloat(2)^get_bigfloat_precision()
 
-to_mpfr(::RoundingMode{:TiesToEven}) = Cint(0)
-to_mpfr(::RoundingMode{:TowardZero}) = Cint(1)
-to_mpfr(::RoundingMode{:TowardPositive}) = Cint(2)
-to_mpfr(::RoundingMode{:TowardNegative}) = Cint(3)
-to_mpfr(::RoundingMode{:AwayFromZero}) = Cint(4)
+to_mpfr(::RoundingMode{:Nearest}) = Cint(0)
+to_mpfr(::RoundingMode{:ToZero}) = Cint(1)
+to_mpfr(::RoundingMode{:Up}) = Cint(2)
+to_mpfr(::RoundingMode{:Down}) = Cint(3)
+to_mpfr(::RoundingMode{:FromZero}) = Cint(4)
 
 function from_mpfr(c::Integer)
     if c == 0
@@ -705,7 +705,7 @@ function round(x::BigFloat)
     ccall((:mpfr_rint, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}, Cint), &z, &x, ROUNDING_MODE[end])
     return z
 end
-function round(x::BigFloat,::RoundingMode{:TiesToAway})
+function round(x::BigFloat,::RoundingMode{:NearestTiesAway})
     z = BigFloat()
     ccall((:mpfr_round, :libmpfr), Int32, (Ptr{BigFloat}, Ptr{BigFloat}), &z, &x)
     return z

base/rational.jl

@@ -224,18 +224,18 @@ trunc{T}(::Type{T}, x::Rational) = convert(T,div(x.num,x.den))
 floor{T}(::Type{T}, x::Rational) = convert(T,fld(x.num,x.den))
 ceil {T}(::Type{T}, x::Rational) = convert(T,cld(x.num,x.den))
 
-function round{T}(::Type{T}, x::Rational, ::RoundingMode{:TiesToEven})
+function round{T}(::Type{T}, x::Rational, ::RoundingMode{:Nearest})
     q,r = divrem(x.num,x.den)
     s = abs(r) < (x.den+one(x.den)+iseven(q))>>1 ? q : q+copysign(one(q),x.num)
     convert(T,s)
 end
 round{T}(::Type{T}, x::Rational) = round(T,x,RoundNearest)
-function round{T}(::Type{T}, x::Rational, ::RoundingMode{:TiesToAway})
+function round{T}(::Type{T}, x::Rational, ::RoundingMode{:NearestTiesAway})
     q,r = divrem(x.num,x.den)
     s = abs(r) < (x.den+one(x.den))>>1 ? q : q+copysign(one(q),x.num)
     convert(T,s)
 end
-function round{T}(::Type{T}, x::Rational, ::RoundingMode{:TiesToPositive})
+function round{T}(::Type{T}, x::Rational, ::RoundingMode{:NearestTiesUp})
     q,r = divrem(x.num,x.den)
     s = abs(r) < (x.den+one(x.den)+(x.num<0))>>1 ? q : q+copysign(one(q),x.num)
     convert(T,s)

base/rounding.jl

@@ -9,20 +9,20 @@ export
 ## rounding modes ##
 immutable RoundingMode{T} end
 
-const RoundNearest = RoundingMode{:TiesToEven}()
-const RoundToZero = RoundingMode{:TowardZero}()
-const RoundUp = RoundingMode{:TowardPositive}()
-const RoundDown = RoundingMode{:TowardNegative}()
-const RoundFromZero = RoundingMode{:AwayFromZero}() # mpfr only
+const RoundNearest = RoundingMode{:Nearest}()
+const RoundToZero = RoundingMode{:ToZero}()
+const RoundUp = RoundingMode{:Up}()
+const RoundDown = RoundingMode{:Down}()
+const RoundFromZero = RoundingMode{:FromZero}() # mpfr only
 # C-style round behaviour
-const RoundNearestTiesAway = RoundingMode{:TiesToAway}()
+const RoundNearestTiesAway = RoundingMode{:NearestTiesAway}()
 # Java-style round behaviour
-const RoundNearestTiesUp = RoundingMode{:TiesToPositive}()
+const RoundNearestTiesUp = RoundingMode{:NearestTiesUp}()
 
-to_fenv(::RoundingMode{:TiesToEven}) = JL_FE_TONEAREST
-to_fenv(::RoundingMode{:TowardZero}) = JL_FE_TOWARDZERO
-to_fenv(::RoundingMode{:TowardPositive}) = JL_FE_UPWARD
-to_fenv(::RoundingMode{:TowardNegative}) = JL_FE_DOWNWARD
+to_fenv(::RoundingMode{:Nearest}) = JL_FE_TONEAREST
+to_fenv(::RoundingMode{:ToZero}) = JL_FE_TOWARDZERO
+to_fenv(::RoundingMode{:Up}) = JL_FE_UPWARD
+to_fenv(::RoundingMode{:Down}) = JL_FE_DOWNWARD
 
 function from_fenv(r::Integer)
     if r == JL_FE_TONEAREST
@@ -65,16 +65,16 @@ end
 # To avoid ambiguous dispatch with methods in mpfr.jl:
 call{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode) = _convert_rounding(T,x,r)
 
-_convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:TiesToEven}) = convert(T,x)
-function _convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:TowardNegative})
+_convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:Nearest}) = convert(T,x)
+function _convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:Down})
     y = convert(T,x)
     y > x ? prevfloat(y) : y
 end
-function _convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:TowardPositive})
+function _convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:Up})
     y = convert(T,x)
     y < x ? nextfloat(y) : y
 end
-function _convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:TowardZero})
+function _convert_rounding{T<:FloatingPoint}(::Type{T},x::Real,r::RoundingMode{:ToZero})
     y = convert(T,x)
     if x > 0.0
         y > x ? prevfloat(y) : y