Rename LazyFloat64 -> AutoFloat

Author: MilesCranmer

src/lazy_float.jl

@@ -1,36 +1,36 @@
 # This is used to store floats without forcing promotion on other
 # numeric types.
-struct LazyFloat64 <: AbstractFloat
+struct AutoFloat <: AbstractFloat
     value::Float64
 
-    LazyFloat64(x::AbstractFloat) = new(convert(Float64, x))
+    AutoFloat(x::AbstractFloat) = new(convert(Float64, x))
 end
 
-Base.float(x::LazyFloat64) = x.value
+Base.float(x::AutoFloat) = x.value
 
-Base.convert(::Type{LazyFloat64}, x::LazyFloat64) = x
-Base.convert(::Type{LazyFloat64}, x::FixedRational) = LazyFloat64(convert(Float64, x))
-Base.convert(::Type{LazyFloat64}, x::Number) = LazyFloat64(x)
-Base.convert(::Type{T}, x::LazyFloat64) where {T<:Number} = convert(T, float(x))
-Base.promote_rule(::Type{LazyFloat64}, ::Type{T}) where {T<:AbstractFloat} = T
-Base.promote_rule(::Type{LazyFloat64}, ::Type{T}) where {T} = promote_type(Float64, T)
+Base.convert(::Type{AutoFloat}, x::AutoFloat) = x
+Base.convert(::Type{AutoFloat}, x::FixedRational) = AutoFloat(convert(Float64, x))
+Base.convert(::Type{AutoFloat}, x::Number) = AutoFloat(x)
+Base.convert(::Type{T}, x::AutoFloat) where {T<:Number} = convert(T, float(x))
+Base.promote_rule(::Type{AutoFloat}, ::Type{T}) where {T<:AbstractFloat} = T
+Base.promote_rule(::Type{AutoFloat}, ::Type{T}) where {T} = promote_type(Float64, T)
 
-Base.show(io::IO, x::LazyFloat64) = print(io, float(x))
+Base.show(io::IO, x::AutoFloat) = print(io, float(x))
 
-Base.:+(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) + float(b))
-Base.:-(a::LazyFloat64) = LazyFloat64(-float(a))
-Base.:-(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) - float(b))
-Base.:*(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) * float(b))
-Base.inv(a::LazyFloat64) = LazyFloat64(inv(float(a)))
-Base.abs(a::LazyFloat64) = LazyFloat64(abs(float(a)))
-Base.:/(a::LazyFloat64, b::LazyFloat64) = a * inv(b)
-Base.:^(a::LazyFloat64, b::Int) = LazyFloat64(float(a) ^ b)
-Base.:^(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) ^ float(b))
-Base.sqrt(a::LazyFloat64) = LazyFloat64(sqrt(float(a)))
-Base.cbrt(a::LazyFloat64) = LazyFloat64(cbrt(float(a)))
-Base.eps(::Type{LazyFloat64}) = eps(Float64)
+Base.:+(a::AutoFloat, b::AutoFloat) = AutoFloat(float(a) + float(b))
+Base.:-(a::AutoFloat) = AutoFloat(-float(a))
+Base.:-(a::AutoFloat, b::AutoFloat) = AutoFloat(float(a) - float(b))
+Base.:*(a::AutoFloat, b::AutoFloat) = AutoFloat(float(a) * float(b))
+Base.inv(a::AutoFloat) = AutoFloat(inv(float(a)))
+Base.abs(a::AutoFloat) = AutoFloat(abs(float(a)))
+Base.:/(a::AutoFloat, b::AutoFloat) = a * inv(b)
+Base.:^(a::AutoFloat, b::Int) = AutoFloat(float(a) ^ b)
+Base.:^(a::AutoFloat, b::AutoFloat) = AutoFloat(float(a) ^ float(b))
+Base.sqrt(a::AutoFloat) = AutoFloat(sqrt(float(a)))
+Base.cbrt(a::AutoFloat) = AutoFloat(cbrt(float(a)))
+Base.eps(::Type{AutoFloat}) = eps(Float64)
 
 # Ambiguities:
 for T in (:(Rational{<:Any}), :(Base.TwicePrecision), :AbstractChar, :Complex, :Number)
-    @eval LazyFloat64(x::$T) = LazyFloat64(float(x))
+    @eval AutoFloat(x::$T) = AutoFloat(float(x))
 end

src/units.jl

@@ -4,9 +4,9 @@ import ..DEFAULT_DIM_TYPE
 import ..DEFAULT_VALUE_TYPE
 import ..Quantity
 import ..Quantity
-import ..LazyFloat64
+import ..AutoFloat
 
-const DEFAULT_UNIT_BASE_TYPE = LazyFloat64
+const DEFAULT_UNIT_BASE_TYPE = AutoFloat
 const DEFAULT_UNIT_TYPE = Quantity{DEFAULT_UNIT_BASE_TYPE,DEFAULT_DIM_TYPE}
 
 const _UNIT_SYMBOLS = Symbol[]