remove old asserts, finish updating tests

Author: icweaver

src/Spectra.jl

@@ -252,28 +252,23 @@ EchelleSpectrum(Float64, Float64)
 ```
 """
 function spectrum(wave::AbstractVector{<:Real}, flux::AbstractVector{<:Real}; kwds...)
-    @assert size(wave) == size(flux) "wave and flux must have equal size"
     Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end
 
 function spectrum(wave::AbstractVector{<:Real}, flux::AbstractArray{<:Real, 3}; kwds...)
-    @assert size(wave, 1) == size(flux, 1) "wave and flux in each order must have equal size"
     Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end
 
 function spectrum(wave::AbstractMatrix{<:Real}, flux::AbstractMatrix{<:Real}; kwds...)
-    @assert size(wave) == size(flux) "wave and flux must have equal size"
     Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end
 
 function spectrum(wave::AbstractVector{<:Quantity}, flux::AbstractVector{<:Quantity}; kwds...)
-    @assert size(wave) == size(flux) "wave and flux must have equal size"
     @assert dimension(eltype(wave)) == u"𝐋" "wave not recognized as having dimensions of wavelengths"
     Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end
 
 function spectrum(wave::AbstractMatrix{<:Quantity}, flux::AbstractMatrix{<:Quantity}; kwds...)
-    @assert size(wave) == size(flux) "wave and flux must have equal size"
     @assert dimension(eltype(wave)) == u"𝐋" "wave not recognized as having dimensions of wavelengths"
     Spectrum(wave, flux, Dict{Symbol,Any}(kwds))
 end

src/spectrum_echelle.jl

@@ -1,15 +1,15 @@
 const EchelleSpectrum = Spectrum{W, F, 2, 2} where {W, F}
 
 function Base.getindex(spec::EchelleSpectrum, i::Int)
-    w = wave(spec)[i, :]
-    f = flux(spec)[i, :]
+    w = wave(spec)[:, i]
+    f = flux(spec)[:, i]
     m = merge(Dict(:Order => i), meta(spec))
     return Spectrum(w, f, m)
 end
 
 function Base.getindex(spec::EchelleSpectrum, I::AbstractVector)
-    w = wave(spec)[I, :]
-    f = flux(spec)[I, :]
+    w = wave(spec)[:, I]
+    f = flux(spec)[:, I]
     m = merge(Dict(:Orders => (first(I), last(I))), meta(spec))
     return Spectrum(w, f, m)
 end
@@ -21,7 +21,7 @@ function Base.show(io::IO, spec::EchelleSpectrum)
     w = wave(spec)
     f = flux(spec)
     println(io, "EchelleSpectrum($(eltype(wave(spec))), $(eltype(flux(spec))))")
-    println(io, "  # orders: $(size(spec, 1))")
+    println(io, "  # orders: $(size(spec, 2))")
     println(io, "  wave $(size(w)): ", first(w), " .. ", last(w))
     println(io, "  flux $(size(f)): ", first(f), " .. ", last(f))
     print(io, "  meta: ", meta(spec))

test/spectrum.jl

@@ -1,5 +1,25 @@
 Random.seed!(8675309)
 
+@testset "Spectrum types" begin
+    wave, flux = collect(1:5), 1:5
+    @test spectrum(wave, flux) isa SingleSpectrum
+    wave[3] = 10
+    @test_throws ArgumentError spectrum(wave, flux)
+    @test_throws ArgumentError spectrum(wave[begin:end-1], flux)
+
+    wave, flux = repeat(1:5, 1, 3), rand(5, 3)
+    @test spectrum(wave, flux) isa EchelleSpectrum
+    wave[3, 3] = 10
+    @test_throws ArgumentError spectrum(wave, flux)
+    @test_throws ArgumentError spectrum(wave[begin:end-1, :], flux)
+
+    wave, flux = collect(1:5), rand(5, 4, 3)
+    @test spectrum(wave, flux) isa IFUSpectrum
+    wave[3] = 10
+    @test_throws ArgumentError spectrum(wave, flux)
+    @test_throws ArgumentError spectrum(wave[begin:end-1], flux)
+end
+
 @testset "Spectrum - Single" begin
     wave = range(1e4, 5e4, length = 1000)
     sigma = randn(size(wave))
@@ -32,7 +52,7 @@ Random.seed!(8675309)
     @test Measurements.uncertainty.(spec.flux) ≈ sigma
 
     flux_trimmed = flux[200:800]
-    @test_throws AssertionError spectrum(wave, flux_trimmed)
+    @test_throws ArgumentError spectrum(wave, flux_trimmed)
     expected = """
     SingleSpectrum(Float64, Measurements.Measurement{Float64})
       wave (1000,): 10000.0 .. 50000.0
@@ -43,17 +63,17 @@ Random.seed!(8675309)
 end
 
 @testset "Spectrum - Echelle" begin
-    n_orders = 3
     n_wavs = 1000
+    n_orders = 3
     wave_1 = range(1e4, 5e4, length=n_wavs)
-    wave = repeat(wave_1, 1, n_orders)'
+    wave = repeat(wave_1, 1, n_orders)
     sigma = randn(size(wave_1))
     sigma[7] = 1
     sigma[134] = 0.1
     flux_1 = 100 .± sigma
     flux_1[7] = 1000 ± 1
     flux_1[134] = 1 ± 0.1
-    flux = repeat(flux_1, 1, n_orders)'
+    flux = repeat(flux_1, 1, n_orders)
 
     spec = spectrum(wave, flux, name = "Test Echelle Spectrum")
 
@@ -73,23 +93,23 @@ end
     @test Spectra.flux(spec) == spec.flux
     @test eltype(spec) == eltype(spec.flux)
     @test spec.wave == wave
-    @test size(spec) == (n_orders, n_wavs)
-    @test length(spec) == n_orders * n_wavs
+    @test size(spec) == (n_wavs, n_orders)
+    @test length(spec) == n_wavs * n_orders
     @test maximum(spec) == 1000 ± 1
     @test minimum(spec) == 1 ± 0.1
-    @test argmax(spec) == CartesianIndex(1, 7)
-    @test argmin(spec) == CartesianIndex(1, 134)
-    @test findmax(spec) == (1000 ± 1, CartesianIndex(1, 7))
-    @test findmin(spec) == (1 ± 0.1, CartesianIndex(1, 134))
-    @test eachrow(Measurements.uncertainty.(spec.flux)) ≈ fill(sigma, n_orders)
-
-    flux_trimmed = flux[:, 200:800]
-    @test_throws AssertionError spectrum(wave, flux_trimmed)
+    @test argmax(spec) == CartesianIndex(7, 1)
+    @test argmin(spec) == CartesianIndex(134, 1)
+    @test findmax(spec) == (1000 ± 1, CartesianIndex(7, 1))
+    @test findmin(spec) == (1 ± 0.1, CartesianIndex(134, 1))
+    @test eachcol(Measurements.uncertainty.(spec.flux)) ≈ fill(sigma, n_orders)
+
+    flux_trimmed = flux[200:800, :]
+    @test_throws ArgumentError spectrum(wave, flux_trimmed)
     expected = """
     EchelleSpectrum(Float64, Measurements.Measurement{Float64})
       # orders: 3
-      wave (3, 1000): 10000.0 .. 50000.0
-      flux (3, 1000): 100.0 ± -2.8 .. 100.0 ± 0.6
+      wave (1000, 3): 10000.0 .. 50000.0
+      flux (1000, 3): 100.0 ± -2.8 .. 100.0 ± 0.6
       meta: Dict{Symbol, Any}(:name => "Test Echelle Spectrum")"""
     @test sprint(show, spec) == expected
     @test spec.name == "Test Echelle Spectrum"
@@ -166,17 +186,17 @@ end
 end
 
 @testset "Unitful Spectrum - Echelle" begin
-    n_orders = 3
     n_wavs = 1000
+    n_orders = 3
     wave_1 = range(1e4, 5e4, length=n_wavs)
-    wave = repeat(wave_1, 1, n_orders)'
+    wave = repeat(wave_1, 1, n_orders)
     sigma = randn(size(wave_1))
     sigma[7] = 1
     sigma[134] = 0.1
     flux_1 = 100 .± sigma
     flux_1[7] = 1000 ± 1
     flux_1[134] = 1 ± 0.1
-    flux = repeat(flux_1, 1, n_orders)'
+    flux = repeat(flux_1, 1, n_orders)
 
     wunit = u"angstrom"
     funit = u"W/m^2/angstrom"
@@ -192,14 +212,14 @@ end
     @test Spectra.wave(spec) == spec.wave
     @test Spectra.flux(spec) == spec.flux
     @test eltype(spec) == eltype(spec.flux)
-    @test size(spec) === (n_orders, n_wavs)
+    @test size(spec) === (n_wavs, n_orders)
     @test length(spec) == n_wavs * n_orders
     @test maximum(spec) == (1000 ± 1) * funit
     @test minimum(spec) == (1 ± 0.1) * funit
-    @test argmax(spec) == CartesianIndex(1, 7)
-    @test argmin(spec) == CartesianIndex(1, 134)
-    @test findmax(spec) == ((1000 ± 1) * funit, CartesianIndex(1, 7))
-    @test findmin(spec) == ((1 ± 0.1) * funit, CartesianIndex(1, 134))
+    @test argmax(spec) == CartesianIndex(7, 1)
+    @test argmin(spec) == CartesianIndex(134, 1)
+    @test findmax(spec) == ((1000 ± 1) * funit, CartesianIndex(7, 1))
+    @test findmin(spec) == ((1 ± 0.1) * funit, CartesianIndex(134, 1))
     @test spec.name == "test echelle"
 
     # Test stripping
@@ -214,8 +234,8 @@ end
     expected = """
     EchelleSpectrum(Unitful.Quantity{Float64, 𝐋, Unitful.FreeUnits{(Å,), 𝐋, nothing}}, Unitful.Quantity{Measurements.Measurement{Float64}, 𝐌 𝐋^-1 𝐓^-3, Unitful.FreeUnits{(Å^-1, m^-2, W), 𝐌 𝐋^-1 𝐓^-3, nothing}})
       # orders: 3
-      wave (3, 1000): 10000.0 Å .. 50000.0 Å
-      flux (3, 1000): 100.0 ± -2.8 W Å^-1 m^-2 .. 100.0 ± 0.6 W Å^-1 m^-2
+      wave (1000, 3): 10000.0 Å .. 50000.0 Å
+      flux (1000, 3): 100.0 ± -2.8 W Å^-1 m^-2 .. 100.0 ± 0.6 W Å^-1 m^-2
       meta: Dict{Symbol, Any}(:name => "test echelle")"""
     @test sprint(show, spec) == expected
 end