Print method and some more tests for delay systems.

Author: olof3

src/types/DelayLtiSystem.jl

@@ -28,7 +28,7 @@ function DelayLtiSystem{T,S}(sys::StateSpace, Tau::AbstractVector{S} = Float64[]
     ny = noutputs(sys) - length(Tau)
 
     if nu < 0  || ny < 0
-        throw(ArgumentError("Time vector is too long."))
+        throw(ArgumentError("The delay vector of length $length(Tau) is too long."))
     end
 
     psys = PartionedStateSpace{StateSpace{T,Matrix{T}}}(sys, nu, ny)
@@ -144,6 +144,14 @@ function Base.getindex(sys::DelayLtiSystem, i::AbstractArray, j::AbstractArray)
         sys.P.Ts), sys.Tau)
 end
 
+function Base.show(io::IO, sys::DelayLtiSystem)
+    show(io, sys.P.P)
+
+    println(io, "\n\nDelays: $(sys.Tau)")
+end
+
+
+
 function +(sys1::DelayLtiSystem, sys2::DelayLtiSystem)
     psys_new = sys1.P + sys2.P
     Tau_new = [sys1.Tau; sys2.Tau]
@@ -190,15 +198,16 @@ Create a time delay of length `tau` with `exp(-τ*s)` where `s=tf("s")` and `τ`
 
 See also: [`delay`](@ref) which is arguably more conenient than this function.
 """
-function Base.exp(G::TransferFunction{SisoRational})
-    if size(G.matrix) != (1,1)
-        error("G must be a scalar transfer function. Consider using `delay` instead.")
+function Base.exp(G::TransferFunction{<:SisoRational})
+    if size(G.matrix) != (1,1) && iscontinuous(G)
+        error("G must be a continuous-time scalar transfer function. Consider using `delay` instead.")
     end
     G_siso = G.matrix[1,1]
 
-    if degree(G_siso.den) != 0 || degree(G_siso.num) != 1 || G_siso[1].num[1] < 0
+    if !(Polynomials.degree(G_siso.den) == 0 && Polynomials.degree(G_siso.num) == 1
+        && G_siso.num[1]/G_siso.den[0] < 0 && G_siso.num[0] == 0)
         error("Input must be of the form -τ*s, τ>0. Consider using `delay` instead.")
     end
 
-    return delay(-G_siso.den[1] / G_siso.den[0])
+    return delay(-G_siso.num[1] / G_siso.den[0])
 end

test/test_delayed_systems.jl

@@ -5,8 +5,12 @@ using DelayDiffEq
 
 # broken: typeof(promote(delay(0.2), ss(1))[1]) == DelayLtiSystem{Float64}
 
+
 @test typeof(promote(delay(0.2), ss(1.0 + im))[1]) == DelayLtiSystem{Complex{Float64}, Float64}
 
+@test sprint(show, ss(1,1,1,1)*delay(1.0)) == "StateSpace{Float64,Array{Float64,2}}\nA = \n 1.0\nB = \n 0.0  1.0\nC = \n 1.0\n 0.0\nD = \n 0.0  1.0\n 1.0  0.0\n\nContinuous-time state-space model\n\nDelays: [1.0]\n"
+
+
 # Extremely baseic tests
 @test freqresp(delay(1), ω) ≈ reshape(exp.(-im*ω), length(ω), 1, 1) rtol=1e-15
 @test freqresp(delay(2.5), ω)[:] ≈ exp.(-2.5im*ω) rtol=1e-15
@@ -43,6 +47,9 @@ P2_fr = (im*ω .+ 1) ./ (im*ω .+ 2)
 @test freqresp(delay(1) * P2, ω)[:] ≈ P2_fr .* exp.(-im*ω) rtol=1e-15
 
 
+
+
+
 ## Feedback
 # The first tests don't include delays, but the linear system is of DelayLtiForm type
 # (very simple system so easy to troubleshoot)
@@ -76,6 +83,16 @@ G_fr = 0.5 .+ 0.5*exp.(-2*im*ω)# + 0.5*exp.(-3*im*ω)
 @test freqresp(feedback(P2, G), ω)[:] ≈ P2_fr ./(1 .+ P2_fr .* G_fr) rtol=1e-15
 
 s = tf("s")
+
+# Test alternative exp constructor for delays
+d = exp(-2*s)
+@test freqresp(d, [0, 1, 2]) ≈ [1, exp(-2im), exp(-4im)]
+
+@test_throws ErrorException exp(-s^2 - 2*s)
+@test_throws ErrorException exp(-2*s+1) # in principle ok, but not allowed anyway
+@test_throws ErrorException exp([-2*s; -s])
+@test_throws ErrorException exp(2*s) # Non-causal
+
 # Random conversions
 sys1 = DelayLtiSystem(1.0/s)
 @test sys1.P.A == sys1.P.D == fill(0,1,1)
@@ -183,6 +200,4 @@ y_impulse, t, _ = impulse(sys_known, 3, alg=MethodOfSteps(Tsit5()))
 @test y_impulse ≈ dy_expected.(t, K) rtol=1e-2 # Two orders of magnitude better with BS3 in this case, which is default for impulse
 @test maximum(abs, y_impulse - dy_expected.(t, K)) < 1e-2
 
-[s11; s12]
-
 end