rename: MathConst => Irrational

NEWS.md

@@ -275,6 +275,8 @@ Library improvements
 
     * Optional `log` and `log1p` functions implemented in pure Julia (experimental) ([#10008]).
 
+    * The `MathCont` type has been renamed `Irrational`.
+
   * Random numbers
 
     * Streamlined random number generation APIs [#8246].

base/deprecated.jl

@@ -535,3 +535,6 @@ end
 
 const UnionType = Union
 export UnionType
+
+const MathConst = Irrational
+export MathConst

base/exports.jl

@@ -70,7 +70,7 @@ export
     LinSpace,
     LocalProcess,
     LowerTriangular,
-    MathConst,
+    Irrational,
     Matrix,
     MergeSort,
     Nullable,

base/irrationals.jl

@@ -0,0 +1,137 @@
+# This file is a part of Julia. License is MIT: http://julialang.org/license
+
+## general machinery for irrational mathematical constants
+
+immutable Irrational{sym} <: Real end
+
+show{sym}(io::IO, x::Irrational{sym}) = print(io, "$sym = $(string(float(x))[1:15])...")
+
+promote_rule{s}(::Type{Irrational{s}}, ::Type{Float32}) = Float32
+promote_rule{s,t}(::Type{Irrational{s}}, ::Type{Irrational{t}}) = Float64
+promote_rule{s,T<:Number}(::Type{Irrational{s}}, ::Type{T}) = promote_type(Float64,T)
+
+convert(::Type{FloatingPoint}, x::Irrational) = Float64(x)
+convert(::Type{Float16}, x::Irrational) = Float16(Float32(x))
+convert{T<:Real}(::Type{Complex{T}}, x::Irrational) = convert(Complex{T}, convert(T,x))
+convert{T<:Integer}(::Type{Rational{T}}, x::Irrational) = convert(Rational{T}, Float64(x))
+
+@generated function call{T<:Union{Float32,Float64},s}(t::Type{T},c::Irrational{s},r::RoundingMode)
+    f = T(big(c()),r())
+    :($f)
+end
+
+=={s}(::Irrational{s}, ::Irrational{s}) = true
+==(::Irrational, ::Irrational) = false
+
+# MathConsts are irrational, so unequal to everything else
+==(x::Irrational, y::Real) = false
+==(x::Real, y::Irrational) = false
+
+# Irrational vs FloatingPoint
+<(x::Irrational, y::Float64) = Float64(x,RoundUp) <= y
+<(x::Float64, y::Irrational) = x <= Float64(y,RoundDown)
+<(x::Irrational, y::Float32) = Float32(x,RoundUp) <= y
+<(x::Float32, y::Irrational) = x <= Float32(y,RoundDown)
+<(x::Irrational, y::Float16) = Float32(x,RoundUp) <= y
+<(x::Float16, y::Irrational) = x <= Float32(y,RoundDown)
+<(x::Irrational, y::BigFloat) = with_bigfloat_precision(precision(y)+32) do
+    big(x) < y
+end
+<(x::BigFloat, y::Irrational) = with_bigfloat_precision(precision(x)+32) do
+    x < big(y)
+end
+
+<=(x::Irrational,y::FloatingPoint) = x < y
+<=(x::FloatingPoint,y::Irrational) = x < y
+
+# Irrational vs Rational
+@generated function <{T}(x::Irrational, y::Rational{T})
+    bx = big(x())
+    bx < 0 && T <: Unsigned && return true
+    rx = rationalize(T,bx,tol=0)
+    rx < bx ? :($rx < y) : :($rx <= y)
+end
+@generated function <{T}(x::Rational{T}, y::Irrational)
+    by = big(y())
+    by < 0 && T <: Unsigned && return false
+    ry = rationalize(T,by,tol=0)
+    ry < by ? :(x <= $ry) : :(x < $ry)
+end
+<(x::Irrational, y::Rational{BigInt}) = big(x) < y
+<(x::Rational{BigInt}, y::Irrational) = x < big(y)
+
+<=(x::Irrational,y::Rational) = x < y
+<=(x::Rational,y::Irrational) = x < y
+
+
+hash(x::Irrational, h::UInt) = 3*object_id(x) - h
+
+-(x::Irrational) = -Float64(x)
+for op in Symbol[:+, :-, :*, :/, :^]
+    @eval $op(x::Irrational, y::Irrational) = $op(Float64(x),Float64(y))
+end
+
+macro math_const(sym, val, def)
+    esym = esc(sym)
+    qsym = esc(Expr(:quote, sym))
+    bigconvert = isa(def,Symbol) ? quote
+        function Base.convert(::Type{BigFloat}, ::Irrational{$qsym})
+            c = BigFloat()
+            ccall(($(string("mpfr_const_", def)), :libmpfr),
+                  Cint, (Ptr{BigFloat}, Int32),
+                  &c, MPFR.ROUNDING_MODE[end])
+            return c
+        end
+    end : quote
+        Base.convert(::Type{BigFloat}, ::Irrational{$qsym}) = $(esc(def))
+    end
+    quote
+        const $esym = Irrational{$qsym}()
+        $bigconvert
+        Base.convert(::Type{Float64}, ::Irrational{$qsym}) = $val
+        Base.convert(::Type{Float32}, ::Irrational{$qsym}) = $(Float32(val))
+        @assert isa(big($esym), BigFloat)
+        @assert Float64($esym) == Float64(big($esym))
+        @assert Float32($esym) == Float32(big($esym))
+    end
+end
+
+big(x::Irrational) = convert(BigFloat,x)
+
+## specific mathematical constants
+
+@math_const π        3.14159265358979323846  pi
+@math_const e        2.71828182845904523536  exp(big(1))
+@math_const γ        0.57721566490153286061  euler
+@math_const catalan  0.91596559417721901505  catalan
+@math_const φ        1.61803398874989484820  (1+sqrt(big(5)))/2
+
+# aliases
+const pi = π
+const eu = e
+const eulergamma = γ
+const golden = φ
+
+# special behaviors
+
+# use exp for e^x or e.^x, as in
+#    ^(::Irrational{:e}, x::Number) = exp(x)
+#    .^(::Irrational{:e}, x) = exp(x)
+# but need to loop over types to prevent ambiguity with generic rules for ^(::Number, x) etc.
+for T in (Irrational, Rational, Integer, Number)
+    ^(::Irrational{:e}, x::T) = exp(x)
+end
+for T in (Range, BitArray, SparseMatrixCSC, StridedArray, AbstractArray)
+    .^(::Irrational{:e}, x::T) = exp(x)
+end
+^(::Irrational{:e}, x::AbstractMatrix) = expm(x)
+
+log(::Irrational{:e}) = 1 # use 1 to correctly promote expressions like log(x)/log(e)
+log(::Irrational{:e}, x) = log(x)
+
+#Align along = for nice Array printing
+function alignment(x::Irrational)
+    m = match(r"^(.*?)(=.*)$", sprint(showcompact_lim, x))
+    m == nothing ? (length(sprint(showcompact_lim, x)), 0) :
+    (length(m.captures[1]), length(m.captures[2]))
+end

base/sysimg.jl

@@ -276,8 +276,8 @@ end
 include("sysinfo.jl")
 import .Sys.CPU_CORES
 
-# mathematical constants
-include("constants.jl")
+# irrational mathematical constants
+include("irrationals.jl")
 
 # Numerical integration
 include("quadgk.jl")

contrib/BBEditTextWrangler-julia.plist

@@ -1207,7 +1207,7 @@
               <string>LoadError</string>
               <string>LocalProcess</string>
               <string>MIME</string>
-              <string>MathConst</string>
+              <string>Irrational</string>
               <string>Matrix</string>
               <string>MersenneTwister</string>
               <string>Meta</string>

contrib/julia.xml

@@ -139,7 +139,7 @@
       <item> IOStream </item>
       <item> LocalProcess </item>
       <item> LU </item>
-      <item> MathConst </item>
+      <item> Irrational </item>
       <item> Matrix </item>
       <item> NTuple </item>
       <item> Number </item>

doc/manual/methods.rst

@@ -267,7 +267,7 @@ Julia language. Core operations typically have dozens of methods::
     +(a::Base.MPFR.BigFloat,b::Base.MPFR.BigFloat,c::Base.MPFR.BigFloat) at mpfr.jl:318
     +(a::Base.MPFR.BigFloat,b::Base.MPFR.BigFloat,c::Base.MPFR.BigFloat,d::Base.MPFR.BigFloat) at mpfr.jl:324
     +(a::Base.MPFR.BigFloat,b::Base.MPFR.BigFloat,c::Base.MPFR.BigFloat,d::Base.MPFR.BigFloat,e::Base.MPFR.BigFloat) at mpfr.jl:331
-    +(x::MathConst{sym},y::MathConst{sym}) at constants.jl:71
+    +(x::Irrational{sym},y::Irrational{sym}) at constants.jl:71
     +{T<:Number}(x::T<:Number,y::T<:Number) at promotion.jl:205
     +{T<:FloatingPoint}(x::Bool,y::T<:FloatingPoint) at bool.jl:43
     +(x::Number,y::Number) at promotion.jl:167

test/numbers.jl

@@ -2408,7 +2408,7 @@ end
 @test bswap(reinterpret(Float32,0x0000c03f)) === 1.5f0
 
 #isreal(x::Real) = true
-for x in [1.23, 7, e, 4//5] #[FP, Int, MathConst, Rat]
+for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
     @test isreal(x) == true
 end
 
@@ -2423,7 +2423,7 @@ for x in [subtypes(Complex); subtypes(Real)]
 end
 
 #getindex(x::Number) = x
-for x in [1.23, 7, e, 4//5] #[FP, Int, MathConst, Rat]
+for x in [1.23, 7, e, 4//5] #[FP, Int, Irrational, Rat]
     @test getindex(x) == x
 end