mirror of
https://github.com/tgorordo/WignerSymbols.jl.git
synced 2026-06-13 02:02:14 -07:00
Partially revamp the HalfInteger type (#4)
* Call the HalfInteger field twofold Makes it more immediately obvious what the meaning of the value stored in the field is. * Introduce new constructors for HalfInteger The primary inner constructor mirrors the two-argument constructor of the Rational type, where the user provides the numerator and denominator values. There is also a single argument outer constructor that makes HalfInteger behave like a normal numeric type such that HalfInteger(n) == n. * Move HalfInteger tests to a separate file The using statements in halfinteger.jl are there so that it would be possible to run the file separately from the other tests. * Test the single-argument HalfInteger constructor * Organize halfinteger.jl a bit Prioritise the convert methods. * Add multiplication with integer to HalfInteger * Implement parsing and printing for HalfInteger * parse(::HalfInteger, x) method * Overload show to pretty-print HalfInteger * Overload Base.numerator/denominator And add tests for the other supplementary functions and methods as well. * Add HalfIntegerRange type Can be constructed using the range operator :. Currently only supports unit steps in the positive direction. * Address feedback * Rename .twofold -> .numerator * Consistent variable names * Remove unnecessary methods for HalfIntegerRange * Allow constructing HalfIntegerRange with non-integer difference * Add docs and ceil(::HalfInteger)
This commit is contained in:
Morten Piibeleht
Jutho
parent
80038db6a3
commit
8ebb2c791b
4 changed files with 341 additions and 46 deletions
|
|
@ -1,25 +1,72 @@
|
|||
# HalfInteger
|
||||
|
||||
"""
|
||||
struct HalfInteger <: Real
|
||||
|
||||
Represents half-integer values.
|
||||
|
||||
---
|
||||
|
||||
HalfInteger(numerator::Integer, denominator::Integer)
|
||||
|
||||
Constructs a `HalfInteger` object as a rational number from the given integer numerator
|
||||
and denominator values.
|
||||
|
||||
# Examples
|
||||
|
||||
```jldoctest
|
||||
julia> HalfInteger(1, 2)
|
||||
1/2
|
||||
|
||||
julia> HalfInteger(-2, 1)
|
||||
-2
|
||||
```
|
||||
"""
|
||||
struct HalfInteger <: Real
|
||||
num::Int
|
||||
numerator::Int # with an implicit denominator of 2
|
||||
|
||||
function HalfInteger(num::Integer, den::Integer)
|
||||
(den == 2) && return new(num)
|
||||
(den == 1) && return new(2*num)
|
||||
(den == 0) && throw(ArgumentError("Denominator can not be zero."))
|
||||
# If non-trivial, we'll see if we can reduce it down to a half-integer
|
||||
numerator, r = divrem(2*num, den)
|
||||
if r == 0
|
||||
return new(numerator)
|
||||
else
|
||||
throw(ArgumentError("$num // $den is not a half-integer value."))
|
||||
end
|
||||
end
|
||||
end
|
||||
Base.:+(a::HalfInteger, b::HalfInteger) = HalfInteger(a.num+b.num)
|
||||
Base.:-(a::HalfInteger, b::HalfInteger) = HalfInteger(a.num-b.num)
|
||||
Base.:-(a::HalfInteger) = HalfInteger(-a.num)
|
||||
Base.:<=(a::HalfInteger, b::HalfInteger) = a.num <= b.num
|
||||
Base.:<(a::HalfInteger, b::HalfInteger) = a.num < b.num
|
||||
Base.one(::Type{HalfInteger}) = HalfInteger(2)
|
||||
Base.zero(::Type{HalfInteger}) = HalfInteger(0)
|
||||
|
||||
"""
|
||||
HalfInteger(x::Real)
|
||||
|
||||
Attempts to create a `HalfInteger` out of the real number `x`. Throws an `InexactError` if
|
||||
`x` can not be represented as a half-integer value.
|
||||
|
||||
# Examples
|
||||
|
||||
```jldoctest
|
||||
julia> HalfInteger(3)
|
||||
3
|
||||
|
||||
julia> HalfInteger(1.5)
|
||||
3/2
|
||||
```
|
||||
"""
|
||||
HalfInteger(x::Real) = convert(HalfInteger, x)
|
||||
|
||||
Base.promote_rule(::Type{HalfInteger}, ::Type{<:Integer}) = HalfInteger
|
||||
Base.promote_rule(::Type{HalfInteger}, T::Type{<:Rational}) = T
|
||||
Base.promote_rule(::Type{HalfInteger}, T::Type{<:Real}) = T
|
||||
|
||||
Base.convert(::Type{HalfInteger}, n::Integer) = HalfInteger(2*n)
|
||||
Base.convert(::Type{HalfInteger}, n::Integer) = HalfInteger(2*n, 2)
|
||||
function Base.convert(::Type{HalfInteger}, r::Rational)
|
||||
if r.den == 1
|
||||
return HalfInteger(2*r.num)
|
||||
return HalfInteger(2*r.num, 2)
|
||||
elseif r.den == 2
|
||||
return HalfInteger(r.num)
|
||||
return HalfInteger(r.num, 2)
|
||||
else
|
||||
throw(InexactError(:HalfInteger, HalfInteger, r))
|
||||
end
|
||||
|
|
@ -27,19 +74,39 @@ end
|
|||
function Base.convert(::Type{HalfInteger}, r::Real)
|
||||
num = 2*r
|
||||
if isinteger(num)
|
||||
return HalfInteger(convert(Int, num))
|
||||
return HalfInteger(convert(Int, num), 2)
|
||||
else
|
||||
throw(InexactError(:HalfInteger, HalfInteger, r))
|
||||
end
|
||||
end
|
||||
Base.convert(T::Type{<:Integer}, s::HalfInteger) = iseven(s.num) ? convert(T, s.num>>1) : throw(InexactError(Symbol(T), T, s))
|
||||
Base.convert(T::Type{<:Rational}, s::HalfInteger) = convert(T, s.num//2)
|
||||
Base.convert(T::Type{<:Real}, s::HalfInteger) = convert(T, s.num/2)
|
||||
Base.convert(T::Type{<:Integer}, s::HalfInteger) = iseven(s.numerator) ? convert(T, s.numerator>>1) : throw(InexactError(Symbol(T), T, s))
|
||||
Base.convert(T::Type{<:Rational}, s::HalfInteger) = convert(T, s.numerator//2)
|
||||
Base.convert(T::Type{<:Real}, s::HalfInteger) = convert(T, s.numerator/2)
|
||||
Base.convert(::Type{HalfInteger}, s::HalfInteger) = s
|
||||
|
||||
# Arithmetic
|
||||
|
||||
Base.:+(a::HalfInteger, b::HalfInteger) = HalfInteger(a.numerator+b.numerator, 2)
|
||||
Base.:-(a::HalfInteger, b::HalfInteger) = HalfInteger(a.numerator-b.numerator, 2)
|
||||
Base.:-(a::HalfInteger) = HalfInteger(-a.numerator, 2)
|
||||
Base.:*(a::Integer, b::HalfInteger) = HalfInteger(a * b.numerator, 2)
|
||||
Base.:*(a::HalfInteger, b::Integer) = b * a
|
||||
Base.:<=(a::HalfInteger, b::HalfInteger) = a.numerator <= b.numerator
|
||||
Base.:<(a::HalfInteger, b::HalfInteger) = a.numerator < b.numerator
|
||||
Base.one(::Type{HalfInteger}) = HalfInteger(2, 2)
|
||||
Base.zero(::Type{HalfInteger}) = HalfInteger(0, 2)
|
||||
|
||||
Base.floor(x::HalfInteger) = isinteger(x) ? x : x - HalfInteger(1, 2)
|
||||
Base.floor(::Type{T}, x::HalfInteger) where T <: Integer = convert(T, floor(x))
|
||||
|
||||
Base.ceil(x::HalfInteger) = isinteger(x) ? x : x + HalfInteger(1, 2)
|
||||
Base.ceil(::Type{T}, x::HalfInteger) where T <: Integer = convert(T, ceil(x))
|
||||
|
||||
# Hashing
|
||||
|
||||
function Base.hash(a::HalfInteger, h::UInt)
|
||||
iseven(a.num) && return hash(a.num>>1, h)
|
||||
num, den = a.num, 2
|
||||
iseven(a.numerator) && return hash(a.numerator>>1, h)
|
||||
num, den = a.numerator, 2
|
||||
den = 1
|
||||
pow = -1
|
||||
if abs(num) < 9007199254740992
|
||||
|
|
@ -51,10 +118,73 @@ function Base.hash(a::HalfInteger, h::UInt)
|
|||
return h
|
||||
end
|
||||
|
||||
Base.isinteger(a::HalfInteger) = iseven(a.num)
|
||||
# Parsing and printing
|
||||
|
||||
"""
|
||||
parse(HalfInteger, s)
|
||||
|
||||
Parses the string `s` into the corresponding `HalfInteger`-value. String can either be a
|
||||
number or a fraction of the form `n/2`.
|
||||
"""
|
||||
function Base.parse(::Type{HalfInteger}, s::AbstractString)
|
||||
if in('/', s)
|
||||
num, den = split(s, '/'; limit=2)
|
||||
parse(Int, den) == 2 ||
|
||||
throw(ArgumentError("Denominator not 2 in HalfInteger string '$s'."))
|
||||
HalfInteger(parse(Int, num), 2)
|
||||
elseif !isempty(strip(s))
|
||||
HalfInteger(parse(Int, s))
|
||||
else
|
||||
throw(ArgumentError("input string is empty or only contains whitespace"))
|
||||
end
|
||||
end
|
||||
|
||||
Base.show(io::IO, x::HalfInteger) =
|
||||
print(io, iseven(x.numerator) ? "$(div(x.numerator, 2))" : "$(x.numerator)/2")
|
||||
|
||||
# Other methods
|
||||
|
||||
Base.isinteger(a::HalfInteger) = iseven(a.numerator)
|
||||
ishalfinteger(a::HalfInteger) = true
|
||||
ishalfinteger(a::Integer) = true
|
||||
ishalfinteger(a::Rational) = a.den == 1 || a.den == 2
|
||||
ishalfinteger(a::Real) = isinteger(2*a)
|
||||
|
||||
converthalfinteger(a::Number) = convert(HalfInteger, a)
|
||||
|
||||
Base.numerator(a::HalfInteger) = iseven(a.numerator) ? div(a.numerator, 2) : a.numerator
|
||||
Base.denominator(a::HalfInteger) = iseven(a.numerator) ? 1 : 2
|
||||
|
||||
# Range of HalfIntegers
|
||||
|
||||
"""
|
||||
struct HalfIntegerRange <: AbstractVector{HalfInteger}
|
||||
|
||||
A range of `HalfInteger` values from `start` to `stop`, spaced by `1`. The `a:b` syntax
|
||||
where both `a` and `b` are `HalfInteger`s can also be use to construct this range.
|
||||
"""
|
||||
struct HalfIntegerRange <: AbstractVector{HalfInteger}
|
||||
start :: HalfInteger
|
||||
stop :: HalfInteger
|
||||
|
||||
function HalfIntegerRange(start::HalfInteger, stop::HalfInteger)
|
||||
(start <= stop) ||
|
||||
throw(ArgumentError("Second argument must be greater or equal to the first."))
|
||||
return new(start, stop)
|
||||
end
|
||||
end
|
||||
Base.iterate(it::HalfIntegerRange) = (it.start, it.start + 1)
|
||||
Base.iterate(it::HalfIntegerRange, s) = (s <= it.stop) ? (s, s+1) : nothing
|
||||
Base.length(it::HalfIntegerRange) = floor(Int, it.stop - it.start) + 1
|
||||
Base.size(it::HalfIntegerRange) = (length(it),)
|
||||
function Base.getindex(it::HalfIntegerRange, i::Integer)
|
||||
1 <= i <= length(it) || throw(BoundsError(it, i))
|
||||
it.start + i - 1
|
||||
end
|
||||
|
||||
"""
|
||||
(:)(i::HalfInteger, j::HalfInteger)
|
||||
|
||||
Constructs a `HalfIntegerRange` out of two `HalfInteger` values.
|
||||
"""
|
||||
Base.:(:)(i::HalfInteger, j::HalfInteger) = HalfIntegerRange(i, j)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue