Fix plus and minus for LinSpace, and other missing methods. Close #12195

Author: yuyichao

base/abstractarray.jl

@@ -427,6 +427,11 @@ map(::Type{Unsigned}, a::Array) = map!(Unsigned, similar(a,typeof(Unsigned(one(e
 map{T<:Real}(::Type{T}, r::StepRange) = T(r.start):T(r.step):T(last(r))
 map{T<:Real}(::Type{T}, r::UnitRange) = T(r.start):T(last(r))
 map{T<:FloatingPoint}(::Type{T}, r::FloatRange) = FloatRange(T(r.start), T(r.step), r.len, T(r.divisor))
+function map{T<:FloatingPoint}(::Type{T}, r::LinSpace)
+    new_len = T(r.len)
+    new_len == r.len || error("$r: too long for $T")
+    LinSpace(T(r.start), T(r.stop), new_len, T(r.divisor))
+end
 
 ## unsafe/pointer conversions ##
 

base/float.jl

@@ -469,6 +469,11 @@ for fn in (:float,:big)
         $fn(r::StepRange) = $fn(r.start):$fn(r.step):$fn(last(r))
         $fn(r::UnitRange) = $fn(r.start):$fn(last(r))
         $fn(r::FloatRange) = FloatRange($fn(r.start), $fn(r.step), r.len, $fn(r.divisor))
+        function $fn(r::LinSpace)
+            new_len = $fn(r.len)
+            new_len == r.len || error(string(r, ": too long for ", $fn))
+            LinSpace($fn(r.start), $fn(r.stop), new_len, $fn(r.divisor))
+        end
     end
 end
 

base/operators.jl

@@ -327,13 +327,15 @@ for f in (:+, :-)
     @eval begin
         function $f(r1::OrdinalRange, r2::OrdinalRange)
             r1l = length(r1)
-            r1l == length(r2) || error("argument dimensions must match")
+            (r1l == length(r2) ||
+             throw(DimensionMismatch("argument dimensions must match")))
             range($f(r1.start,r2.start), $f(step(r1),step(r2)), r1l)
         end
 
         function $f{T<:FloatingPoint}(r1::FloatRange{T}, r2::FloatRange{T})
             len = r1.len
-            len == r2.len || error("argument dimensions must match")
+            (len == r2.len ||
+             throw(DimensionMismatch("argument dimensions must match")))
             divisor1, divisor2 = r1.divisor, r2.divisor
             if divisor1 == divisor2
                 FloatRange{T}($f(r1.start,r2.start), $f(r1.step,r2.step),
@@ -349,9 +351,23 @@ for f in (:+, :-)
             end
         end
 
-        $f(r1::FloatRange, r2::FloatRange) = $f(promote(r1,r2)...)
-        $f(r1::FloatRange, r2::OrdinalRange) = $f(promote(r1,r2)...)
-        $f(r1::OrdinalRange, r2::FloatRange) = $f(promote(r1,r2)...)
+        function $f{T<:FloatingPoint}(r1::LinSpace{T}, r2::LinSpace{T})
+            len = r1.len
+            (len == r2.len ||
+             throw(DimensionMismatch("argument dimensions must match")))
+            divisor1, divisor2 = r1.divisor, r2.divisor
+            if divisor1 == divisor2
+                LinSpace{T}($f(r1.start, r2.start), $f(r1.stop, r2.stop),
+                            len, divisor1)
+            else
+                linspace(convert(T, $f(first(r1), first(r2))),
+                         convert(T, $f(last(r1), last(r2))), len)
+            end
+        end
+
+        $f(r1::Union{FloatRange, OrdinalRange, LinSpace},
+           r2::Union{FloatRange, OrdinalRange, LinSpace}) =
+               $f(promote(r1, r2)...)
     end
 end
 

base/range.jl

@@ -197,6 +197,7 @@ function linspace{T<:FloatingPoint}(start::T, stop::T, len::T)
     len - n == 1 || error("linspace($start, $stop, $len): too long for $T")
     a0, b = rat(start)
     a = convert(T,a0)
+    p::T
     if a/convert(T,b) == start
         c0, d = rat(stop)
         c = convert(T,c0)
@@ -546,17 +547,26 @@ end
 .+(x::Real, r::Range) = (x+first(r)):step(r):(x+last(r))
 #.+(x::Real, r::StepRange)  = range(x + r.start, r.step, length(r))
 .+(x::Real, r::FloatRange) = FloatRange(r.divisor*x + r.start, r.step, r.len, r.divisor)
-.+(x::Real, r::LinSpace)   = LinSpace(x + r.start, x + r.stop, r.len, r.divisor)
+function .+(x::Real, r::LinSpace)
+    x2 = ifelse(r.len == 0, x, x * r.divisor / (r.len - 1))
+    LinSpace(x2 + r.start, x2 + r.stop, r.len, r.divisor)
+end
 .+(r::Range, x::Real)      = x + r
 #.+(r::FloatRange, x::Real) = x + r
 
 .-(x::Real, r::Range)      = (x-first(r)):-step(r):(x-last(r))
 .-(x::Real, r::FloatRange) = FloatRange(r.divisor*x - r.start, -r.step, r.len, r.divisor)
-.-(x::Real, r::LinSpace)   = LinSpace(x - r.start, x - r.stop, r.len, r.divisor)
+function .-(x::Real, r::LinSpace)
+    x2 = ifelse(r.len == 0, x, x * r.divisor / (r.len - 1))
+    LinSpace(x2 - r.start, x2 - r.stop, r.len, r.divisor)
+end
 .-(r::UnitRange, x::Real)  = range(r.start-x, length(r))
 .-(r::StepRange , x::Real) = range(r.start-x, r.step, length(r))
 .-(r::FloatRange, x::Real) = FloatRange(r.start - r.divisor*x, r.step, r.len, r.divisor)
-.-(r::LinSpace, x::Real)   = LinSpace(r.start - x, r.stop - x, r.len, r.divisor)
+function .-(r::LinSpace, x::Real)
+    x2 = ifelse(r.len == 0, x, x * r.divisor / (r.len - 1))
+    LinSpace(r.start - x2, r.stop - x2, r.len, r.divisor)
+end
 
 .*(x::Real, r::OrdinalRange) = range(x*r.start, x*step(r), length(r))
 .*(x::Real, r::FloatRange)   = FloatRange(x*r.start, x*r.step, r.len, r.divisor)
@@ -611,6 +621,14 @@ convert{T}(::Type{LinSpace{T}}, r::OrdinalRange) =
 convert{T}(::Type{LinSpace}, r::OrdinalRange{T}) =
     convert(LinSpace{typeof(float(first(r)))}, r)
 
+# Promote FloatRange to LinSpace
+promote_rule{F,OR<:FloatRange}(::Type{LinSpace{F}}, ::Type{OR}) =
+    LinSpace{promote_type(F,eltype(OR))}
+convert{T}(::Type{LinSpace{T}}, r::FloatRange) =
+    linspace(convert(T, first(r)), convert(T, last(r)), convert(T, length(r)))
+convert{T}(::Type{LinSpace}, r::FloatRange{T}) =
+    convert(LinSpace{T}, r)
+
 
 # +/- of ranges is defined in operators.jl (to be able to use @eval etc.)
 

test/ranges.jl

@@ -245,8 +245,11 @@ end
 @test all(((1:5) - [1:5;]) .== 0)
 
 # exercise fallback addition of ranges
-@test ((linspace(1.,5.,5) - linspace(1.,5.,5)) == zeros(5))
+@test ((linspace(1.,5.,5) - linspace(1.,5.,5)) == linspace(0, 0, 5))
+@test_throws DimensionMismatch (linspace(1.,5.,5) + linspace(1.,5.,6))
 @test_throws DimensionMismatch (linspace(1.,5.,5) - linspace(1.,5.,6))
+@test_throws DimensionMismatch (linspace(1.,5.,5) .* linspace(1.,5.,6))
+@test_throws DimensionMismatch (linspace(1.,5.,5) ./ linspace(1.,5.,6))
 
 # tricky floating-point ranges