@@ -1536,8 +1536,8 @@ See also [`range`](@ref) for linearly spaced points.
1536
1536
!!! compat "Julia 1.11"
1537
1537
This function requires at least Julia 1.11.
1538
1538
"""
1539
- logrange (start:: Number , stop:: Number , length:: Integer ) = LogRange (start, stop, Int (length))
1540
- logrange (start:: Number , stop:: Number ; length:: Integer ) = LogRange (start, stop, Int ( length) )
1539
+ logrange (start:: Real , stop:: Real , length:: Integer ) = LogRange (start, stop, Int (length))
1540
+ logrange (start:: Real , stop:: Real ; length:: Integer ) = logrange (start, stop, length)
1541
1541
1542
1542
1543
1543
"""
@@ -1594,58 +1594,15 @@ julia> 2 .^ (0:3:9) |> println
1594
1594
[1, 8, 64, 512]
1595
1595
```
1596
1596
1597
- For complex `T`, all points lie on the same branch of [`log`](@ref) as is used by `log(start)`
1598
- and `log(stop)`. That is, all branch cuts are on the negative real axis.
1599
-
1600
- Other branches can be used by adjusting the arguments. For instance `start * logrange(1, stop/start, length)`
1601
- places the cut where `stop/start` is negative real, i.e. where [`angle`](@ref)`(stop/start) ≈ pi`.
1602
-
1603
- ```jldoctest
1604
- julia> Base.LogRange{ComplexF32}(1, -1+0im, 5) |> collect
1605
- 5-element Vector{ComplexF32}:
1606
- 1.0f0 + 0.0f0im
1607
- 0.70710677f0 + 0.70710677f0im
1608
- 6.123234f-17 + 1.0f0im
1609
- -0.70710677f0 + 0.70710677f0im
1610
- -1.0f0 + 0.0f0im
1611
-
1612
- julia> ans ≈ cis.(LinRange{Float32}(0, pi, 5))
1613
- true
1614
-
1615
- julia> lo = -1+0.01f0im; hi = -1-0.01f0im;
1616
-
1617
- julia> angle(lo), angle(hi) # either side of branch cut
1618
- (3.131593f0, -3.131593f0)
1619
-
1620
- julia> logrange(lo, hi, 5) |> collect # goes near to +1
1621
- 5-element Vector{ComplexF32}:
1622
- -1.0f0 + 0.01f0im
1623
- 0.0050000623f0 + 1.0000376f0im
1624
- 1.00005f0 + 0.0f0im
1625
- 0.0050000623f0 - 1.0000376f0im
1626
- -1.0f0 - 0.01f0im
1627
-
1628
- julia> lo .* logrange(1, hi/lo, 5) # stays near -1
1629
- 5-element Vector{ComplexF32}:
1630
- -1.0f0 + 0.01f0im
1631
- -1.0000374f0 + 0.0050000628f0im
1632
- -1.00005f0 + 0.0f0im
1633
- -1.0000376f0 - 0.0050000623f0im
1634
- -1.0f0 - 0.009999999f0im
1635
-
1636
- julia> angle(hi/lo) # far from branch cut
1637
- 0.01999933f0
1638
- ```
1639
-
1640
1597
!!! compat "Julia 1.11"
1641
1598
This type requires at least Julia 1.11.
1642
1599
"""
1643
- struct LogRange{T<: Number ,X} <: AbstractArray{T,1}
1600
+ struct LogRange{T<: Real ,X} <: AbstractArray{T,1}
1644
1601
start:: T
1645
1602
stop:: T
1646
1603
len:: Int
1647
1604
extra:: Tuple{X,X}
1648
- function LogRange {T} (start:: T , stop:: T , length:: Int ) where {T<: Number }
1605
+ function LogRange {T} (start:: T , stop:: T , length:: Int ) where {T<: Real }
1649
1606
# LogRange(0, 1, 100) could be == [0,0,0,0,...,1], that's the limit start -> 0,
1650
1607
# but seems more likely to give silent surprises than returning NaN.
1651
1608
a = iszero (start) ? T (NaN ) : T (start)
@@ -1657,11 +1614,11 @@ struct LogRange{T<:Number,X} <: AbstractArray{T,1}
1657
1614
elseif len == 1 && start != stop
1658
1615
throw (ArgumentError (LazyString (
1659
1616
" LogRange(" , start, " , " , stop, " , " , len, " ): endpoints differ, while length is 1" )))
1660
- elseif T <: Real && ((start < 0 ) || ( stop< 0 ))
1617
+ elseif start < 0 || stop < 0
1661
1618
throw (DomainError ((start, stop),
1662
- " LogRange will only return complex results if called with a complex argument " ))
1619
+ " LogRange(start, stop, length) does not accept negative numbers " ))
1663
1620
end
1664
- if T <: Integer || T <: Complex{<:Integer}
1621
+ if T <: Integer
1665
1622
# LogRange{Int}(1, 512, 4) produces InexactError: Int64(7.999999999999998)
1666
1623
throw (ArgumentError (" LogRange{T} does not support integer types" ))
1667
1624
end
@@ -1670,10 +1627,10 @@ struct LogRange{T<:Number,X} <: AbstractArray{T,1}
1670
1627
end
1671
1628
end
1672
1629
1673
- function LogRange {T} (start:: Number , stop:: Number , len:: Integer ) where {T}
1630
+ function LogRange {T} (start:: Real , stop:: Real , len:: Integer ) where {T}
1674
1631
LogRange {T} (convert (T, start), convert (T, stop), convert (Int, len))
1675
1632
end
1676
- function LogRange (start:: Number , stop:: Number , len:: Integer )
1633
+ function LogRange (start:: Real , stop:: Real , len:: Integer )
1677
1634
T = float (promote_type (typeof (start), typeof (stop)))
1678
1635
LogRange {T} (convert (T, start), convert (T, stop), convert (Int, len))
1679
1636
end
@@ -1684,7 +1641,7 @@ length(r::LogRange) = r.len
1684
1641
first (r:: LogRange ) = r. start
1685
1642
last (r:: LogRange ) = r. stop
1686
1643
1687
- function _logrange_extra (a:: Number , b:: Number , len:: Int )
1644
+ function _logrange_extra (a:: Real , b:: Real , len:: Int )
1688
1645
loga = log (1.0 * a) # widen to at least Float64
1689
1646
logb = log (1.0 * b)
1690
1647
(loga/ (len- 1 ), logb/ (len- 1 ))
@@ -1708,7 +1665,7 @@ function getindex(r::LogRange{T}, i::Int) where {T}
1708
1665
# accurate, nor does it handle NaN/Inf as desired, hence the cases above.
1709
1666
logx = (r. len- i) * r. extra[1 ] + (i- 1 ) * r. extra[2 ]
1710
1667
x = _exp_allowing_twice64 (logx)
1711
- return T <: Real ? copysign ( T (x), r . start) : T (x)
1668
+ return T (x)
1712
1669
end
1713
1670
1714
1671
function show (io:: IO , r:: LogRange{T} ) where {T}
0 commit comments