resolved type ambiguity in convert, updated Readme

Author: jishnub

README.md

@@ -7,7 +7,16 @@
 
 # Introduction
 
-This package introduces the type `PiTimes` that automatically uses the functions `sinpi` and `cospi` instead of `sin` and `cos` to produce accurate results by avoiding floating-point inaccuracies to some extent. It also provides the constant `Pi` for convenience, defined as `PiTimes(1)`, which behaves like `pi` except it produces results with higher accuracy in certain trigonometric contexts.
+This package exports the type `PiExpTimes{N}` that behaves as a multipying factor of `π^N`, and the type `PiTimes` that is aliased to `PiExpTimes{1}`. It also provides the constant `Pi` for convenience, defined as `PiTimes(1)`, which behaves like `π` except it produces results with higher accuracy in certain trigonometric and algebraic contexts. 
+
+In most scenarios the numbers `Pi` and `pi` are interchangable.
+
+```julia
+julia> Pi^2 == π^2
+true
+```
+
+It's usually possible, and cleaner, to express mathematical relations in terms of `Pi` instead of the more cumbersome `PiExpTimes`, and is recommended unless it's specifically necessary.
 
 ## Rationale
 
@@ -27,9 +36,36 @@ julia> (1//3)Pi + (4//3)Pi == (5//3)Pi
 true
 ```
 
+We may also simplify algebraic expressions involving powers of `Pi` as 
+
+```julia
+julia> (2Pi^2//3) // (4Pi//5)
+(5//6)Pi
+
+julia> Pi^-2 / 4Pi^3
+0.25*Pi^-5
+```
+
+The powers of `Pi` cancel as expected, and `Pi^0` is automatically converted to an ordinary real number wherever possible.
+
+```julia
+julia> Pi^2 / Pi^2
+1.0
+```
+
+Expressions involving `Pi` are automatically promoted to `Complex` as necessary, eg.
+
+```julia
+julia> (1+im)Pi^3 / 2Pi^2
+0.5*Pi + 0.5*Pi*im
+
+julia> (1+im)Pi^3 / 2Pi^2 * 2/Pi
+1.0 + 1.0im
+```
+
 ## Trigonometric functions
 
-The `PiTimes` type uses `sinpi` and `cospi` under the hood when it is used as an argument to `sin` and `cos`. This results in exact results in several contexts where the inaccuracies arise from floating-point conversions.
+The type `PiTimes` uses `sinpi` and `cospi` under the hood when it is used as an argument to `sin` and `cos`. This results in exact results in several contexts where the inaccuracies arise from floating-point conversions.
 
 ```julia
 julia> cos(3π/2)
@@ -51,7 +87,7 @@ julia> tan(Pi/2)
 Inf
 ```
 
-It automatically promotes to `Complex` as necessary, so we may compute complex exponentials exactly for some arguments:
+We may compute complex exponential exactly:
 
 ```julia
 julia> exp(im*π/2)

src/MultiplesOfPi.jl

@@ -265,44 +265,45 @@ function Base.convert(::Type{PiExpTimes{N}},x::Real) where {N}
 	den = N < 0 ? π^float(N) : π^N
 	PiExpTimes{N}(x/den)
 end
-function Base.convert(::Type{PiExpTimes{N,T}},x::Real) where {N,T}
+function Base.convert(::Type{PiExpTimes{N,T}},x::Real) where {N,T<:Real}
 	den = N < 0 ? π^float(N) : π^N
 	PiExpTimes{N}(T(x/den))
 end
 function Base.convert(::Type{PiExpTimes{N}},::Irrational{:π}) where {N}
 	den = N < 1 ? π^float(N-1) : π^(N-1)
 	PiExpTimes{N}(1/den)
 end
-function Base.convert(::Type{PiExpTimes{N,T}},::Irrational{:π}) where {N,T}
+function Base.convert(::Type{PiExpTimes{N,T}},::Irrational{:π}) where {N,T<:Real}
 	den = N < 1 ? π^float(N-1) : π^(N-1)
 	PiExpTimes{N}(T(1/den))
 end
 function Base.convert(::Type{PiExpTimes{N}},p::PiExpTimes{M}) where {M,N}
 	den = N < M ? π^float(N-M) : π^(N-M)
 	PiExpTimes{N}(p.x/den)
 end
-function Base.convert(::Type{PiExpTimes{N,T}},p::PiExpTimes{M}) where {M,N,T}
+function Base.convert(::Type{PiExpTimes{N,T}},p::PiExpTimes{M}) where {M,N,T<:Real}
 	den = N < M ? π^float(N-M) : π^(N-M)
 	PiExpTimes{N}(T(p.x/den))
 end
 Base.convert(::Type{PiExpTimes{N}},p::PiExpTimes{N}) where {N} = p
-Base.convert(::Type{PiExpTimes{N,T}},p::PiExpTimes{N}) where {N,T} = PiExpTimes{N}(T(p.x))
-Base.convert(::Type{PiExpTimes{N,T}},p::PiExpTimes{N,T}) where {N,T} = p
+function Base.convert(::Type{PiExpTimes{N,T}},p::PiExpTimes{N}) where {N,T<:Real}
+	PiExpTimes{N}(T(p.x))
+end
+Base.convert(::Type{PiExpTimes{N,T}},p::PiExpTimes{N,T}) where {N,T<:Real} = p
 
 function Base.show(io::IO,p::PiExpTimes{N}) where {N}
 	x = p.x
-	function expstr(p)
-		ifelse(isone(N),"Pi","Pi^"*string(N))
-	end
+
+	expstr(p) = isone(N) ? "Pi" : "Pi^"*string(N)
 
-	xstrexp(x,p) = isone(x) ? expstr(p) : string(x)*"*"*expstr(p)
-	xstrexp(x::Integer,p) = isone(x) ? expstr(p) : string(x)*expstr(p)
-	xstrexp(x::AbstractFloat,p) = isone(x) ? expstr(p) : 
+	tostr(x,p) = isone(x) ? expstr(p) : string(x)*"*"*expstr(p)
+	tostr(x::Integer,p) = isone(x) ? expstr(p) : string(x)*expstr(p)
+	tostr(x::AbstractFloat,p) = isone(x) ? expstr(p) : 
 								isinf(x) || isnan(x) ? string(x) :
 								string(x)*"*"*expstr(p)
-	xstrexp(x::Rational,p) = "("*string(x)*")"*expstr(p)
+	tostr(x::Rational,p) = "("*string(x)*")"*expstr(p)
 
-	str = iszero(x) ? string(x) : xstrexp(x,p)
+	str = iszero(x) ? string(x) : tostr(x,p)
 	print(io,str)
 end