Skip to content

Commit

Permalink
rename: MathConst => Irrational
Browse files Browse the repository at this point in the history
  • Loading branch information
StefanKarpinski committed Jun 28, 2015
1 parent f7a4aa3 commit 4b4efaa
Show file tree
Hide file tree
Showing 10 changed files with 150 additions and 145 deletions.
2 changes: 2 additions & 0 deletions NEWS.md
Original file line number Diff line number Diff line change
Expand Up @@ -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].
Expand Down
137 changes: 0 additions & 137 deletions base/constants.jl

This file was deleted.

3 changes: 3 additions & 0 deletions base/deprecated.jl
Original file line number Diff line number Diff line change
Expand Up @@ -535,3 +535,6 @@ end

const UnionType = Union
export UnionType

const MathConst = Irrational
export MathConst
2 changes: 1 addition & 1 deletion base/exports.jl
Original file line number Diff line number Diff line change
Expand Up @@ -70,7 +70,7 @@ export
LinSpace,
LocalProcess,
LowerTriangular,
MathConst,
Irrational,
Matrix,
MergeSort,
Nullable,
Expand Down
137 changes: 137 additions & 0 deletions base/irrationals.jl
Original file line number Diff line number Diff line change
@@ -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
4 changes: 2 additions & 2 deletions base/sysimg.jl
Original file line number Diff line number Diff line change
Expand Up @@ -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")
Expand Down
2 changes: 1 addition & 1 deletion contrib/BBEditTextWrangler-julia.plist
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
2 changes: 1 addition & 1 deletion contrib/julia.xml
Original file line number Diff line number Diff line change
Expand Up @@ -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>
Expand Down
2 changes: 1 addition & 1 deletion doc/manual/methods.rst
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down
4 changes: 2 additions & 2 deletions test/numbers.jl
Original file line number Diff line number Diff line change
Expand Up @@ -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

Expand All @@ -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

Expand Down

0 comments on commit 4b4efaa

Please sign in to comment.