Completing symbolic tests

docs/src/pmops.md

@@ -25,7 +25,7 @@ issymmetric
 
 ```@docs
 
-LinearAlgebra.norm(A::PeriodicFunctionMatrix, p::Real; rtol)
+norm(A::Union{HarmonicArray, PeriodicFunctionMatrix}, p::Real; rtol)
 trace(A::Union{HarmonicArray, PeriodicFunctionMatrix}; rtol)
 pmderiv
 ```
@@ -36,7 +36,7 @@ pmderiv
 
 ```@docs
 Base.reverse
-LinearAlgebra.norm(A::PeriodicArray, p::Real)
+norm(A::PeriodicArray)
 trace(A::PeriodicArray)
 pmshift
 pmsymadd!

src/types/PeriodicMatrix.jl

@@ -64,6 +64,9 @@ function set_period(A::AbstractPeriodicArray{:d,T}, period::Real) where T
       PeriodicMatrix{:d,T}(A.M, Aperiod/n, nperiod)
    end
 end
+# function set_period(A::PM, period::Real) where {T, PM <: AbstractPeriodicArray{:c,T}}
+#    PM{:c,T}(A,period)
+# end
 
 
 # function PeriodicMatrix{:d,T}(A::Vector{Matrix{T1}}, period::Real) where {T,T1}
@@ -593,7 +596,7 @@ function PeriodicFunctionMatrix{:c,T}(at::PeriodicFunctionMatrix, period::Real)
    end
 end
 PeriodicFunctionMatrix(at::PeriodicFunctionMatrix, period::Real) = PeriodicFunctionMatrix{:c,eltype(at)}(at, period) 
-#set_period(A::PeriodicFunctionMatrix, period::Real) = PeriodicFunctionMatrix{:c,eltype(A)}(A,period)
+set_period(A::PeriodicFunctionMatrix, period::Real) = PeriodicFunctionMatrix{:c,eltype(A)}(A,period)
 
 # function PeriodicFunctionMatrix(at::PeriodicFunctionMatrix, period::Real = at.period; isconst::Bool = isconstant(at))
 #    # at.period = period

src/types/PeriodicMatrix_sym.jl

@@ -48,14 +48,14 @@ function PeriodicSymbolicMatrix{:c,T}(A::PeriodicSymbolicMatrix, period::Real) w
    n, d = numerator(r), denominator(r)
    min(n,d) == 1 || error("new period is incommensurate with the old period")
    if period >= Aperiod
-      PeriodicSymbolicMatrix{:c,T,Matrix{Fun}}(A.F, Aperiod*d, A.nperiod*d)
+      PeriodicSymbolicMatrix{:c,T,Matrix{Num}}(A.F, Aperiod*d, A.nperiod*d)
    elseif period < Aperiod
       nperiod = div(A.nperiod,n)
       nperiod < 1 && error("new period is incommensurate with the old period")
-      PeriodicSymbolicMatrix{:c,T,Matrix{Fun}}(A.F, Aperiod/n, A.nperiod)
+      PeriodicSymbolicMatrix{:c,T,Matrix{Num}}(A.F, Aperiod/n, nperiod)
    end
 end
-set_period(A::PM, period::Real) where {T, PM <: AbstractPeriodicArray{:c,T}} = PM(A,period)
+set_period(A::PeriodicSymbolicMatrix, period::Real) = PeriodicSymbolicMatrix{:c,eltype(A)}(A,period)
 
 # properties 
 isconstant(A::PeriodicSymbolicMatrix) = all(length.(Symbolics.get_variables.(A.F)) .== 0)
@@ -86,24 +86,26 @@ function Base.convert(::Type{PeriodicFunctionMatrix{:c,T}}, A::PeriodicSymbolicM
    f = eval(build_function(A.F, t, expression=Val{false}, nanmath=false)[1])
    PeriodicFunctionMatrix{:c,T}(x -> f(T(x)), A.period, size(A), A.nperiod, isconstant(A))
 end
-function Base.convert(::Type{PeriodicFunctionMatrix}, A::PeriodicSymbolicMatrix) 
-   @variables t
-   f = eval(build_function(A.F, t, expression=Val{false}, nanmath=false)[1])
-   return PeriodicFunctionMatrix{:c,Float64}(x -> f(x), A.period, size(A), A.nperiod, isconstant(A))
-end
+# function Base.convert(::Type{PeriodicFunctionMatrix}, A::PeriodicSymbolicMatrix) 
+#    @variables t
+#    f = eval(build_function(A.F, t, expression=Val{false}, nanmath=false)[1])
+#    return PeriodicFunctionMatrix{:c,Float64}(x -> f(x), A.period, size(A), A.nperiod, isconstant(A))
+# end
+Base.convert(::Type{PeriodicFunctionMatrix}, A::PeriodicSymbolicMatrix) = convert(PeriodicFunctionMatrix{:c,Float64}, A)
+
 
 
 # conversions to continuous-time PeriodicSymbolicMatrix
-function Base.convert(::Type{PeriodicSymbolicMatrix}, A::PeriodicFunctionMatrix) 
-   @variables t
-   # PeriodicSymbolicMatrix(Num.(A.f(t)), A.period; nperiod = A.nperiod)
-   M = try 
-      Num.(A.f(t))
-   catch 
-      return convert(PeriodicSymbolicMatrix,convert(HarmonicArray,A))
-   end
-   PeriodicSymbolicMatrix(M, A.period; nperiod = A.nperiod)
-end
+# function Base.convert(::Type{PeriodicSymbolicMatrix}, A::PeriodicFunctionMatrix) 
+#    @variables t
+#    # PeriodicSymbolicMatrix(Num.(A.f(t)), A.period; nperiod = A.nperiod)
+#    M = try 
+#       Num.(A.f(t))
+#    catch 
+#       return convert(PeriodicSymbolicMatrix,convert(HarmonicArray,A))
+#    end
+#    PeriodicSymbolicMatrix(M, A.period; nperiod = A.nperiod)
+# end
 function Base.convert(::Type{PeriodicSymbolicMatrix{:c,T}}, A::PeriodicFunctionMatrix) where {T}
    try 
       @variables t
@@ -112,6 +114,7 @@ function Base.convert(::Type{PeriodicSymbolicMatrix{:c,T}}, A::PeriodicFunctionM
       convert(PeriodicSymbolicMatrix,convert(HarmonicArray,A))
    end
 end
+Base.convert(::Type{PeriodicSymbolicMatrix}, A::PeriodicFunctionMatrix) = convert(PeriodicSymbolicMatrix{:c,eltype(A)}, A)
 Base.convert(::Type{PeriodicSymbolicMatrix}, ahr::HarmonicArray) = 
    PeriodicSymbolicMatrix(hr2psm(ahr), ahr.period; nperiod = ahr.nperiod)
 Base.convert(::Type{PeriodicSymbolicMatrix}, A::PeriodicTimeSeriesMatrix) = 
@@ -122,12 +125,19 @@ Base.convert(::Type{PeriodicSymbolicMatrix}, A::PeriodicTimeSeriesMatrix) =
 Base.convert(::Type{HarmonicArray}, A::PeriodicSymbolicMatrix) = psm2hr(A)
 
 # conversions to PeriodicTimeSeriesMatrix
+# function Base.convert(::Type{PeriodicTimeSeriesMatrix}, A::PeriodicSymbolicMatrix; ns::Int = 128)
+#    ns > 0 || throw(ArgumentError("number of samples must be positive, got $ns"))
+#    tA = convert(PeriodicFunctionMatrix,A)
+#    PeriodicTimeSeriesMatrix(tA.f.((0:ns-1)*tA.period/ns/tA.nperiod), tA.period; nperiod = tA.nperiod)
+# end
+
 function Base.convert(::Type{PeriodicTimeSeriesMatrix}, A::PeriodicSymbolicMatrix; ns::Int = 128)
    ns > 0 || throw(ArgumentError("number of samples must be positive, got $ns"))
-   tA = convert(PeriodicFunctionMatrix,A)
-   PeriodicTimeSeriesMatrix(tA.f.((0:ns-1)*tA.period/ns/tA.nperiod), tA.period; nperiod = tA.nperiod)
+   ts = (0:ns-1)*A.period/ns/A.nperiod
+   PeriodicTimeSeriesMatrix(tpmeval.(Ref(A),ts), A.period; nperiod = A.nperiod)
 end
 
+
 function PeriodicFunctionMatrix(A::VecOrMat{Num}, period::Real) 
    @variables t
    f = eval(build_function(reshape(A,size(A,1),size(A,2)), t, expression=Val{false})[1])

test/test_pmops.jl

@@ -119,6 +119,23 @@ Cds = PeriodicSymbolicMatrix(-(A11'*X1+X1*A11+X1der),2*pi)
 Xs = PeriodicSymbolicMatrix(X1,2*pi)
 Xders = PeriodicSymbolicMatrix(X1der,2*pi)
 
+@test set_period(set_period(As,4pi),2pi) == As
+
+At=convert(PeriodicFunctionMatrix,As)
+@test ≈(convert(PeriodicSymbolicMatrix,At),As)
+
+Ats = convert(PeriodicTimeSeriesMatrix,At);
+@test ≈(convert(PeriodicSymbolicMatrix,Ats),As)
+
+Ah = convert(HarmonicArray,As)
+@test ≈(convert(PeriodicSymbolicMatrix,Ah),As)
+
+Ats2 = convert(PeriodicTimeSeriesMatrix,As)
+@test ≈(convert(PeriodicSymbolicMatrix,Ats2),As)
+
+At1=PeriodicFunctionMatrix(A11,2pi)
+@test ≈(convert(PeriodicSymbolicMatrix,At1),As)
+
 @test issymmetric(Cs) && issymmetric(Cds) && issymmetric(Xs) && issymmetric(Xders)
 @test As*Xs+Xs*As'+Cs ==  pmderiv(Xs) == Xders
 @test As'*Xs+Xs*As+Cds == -pmderiv(Xs) 
@@ -145,7 +162,7 @@ Xders = PeriodicSymbolicMatrix(X1der,16*pi,nperiod = 8)
 @test (Symbolics.simplify(inv(As)*As) ≈ I) && (I ≈ Symbolics.simplify(As*inv(As))) 
 @test inv(As)*As == I == As*inv(As) 
 
-@test iszero(As[1:2,1:1].F - As.F[1:2,1:1]) && lastindex(As,1) == 2 && lastindex(As,2) == 2
+@test iszero(As[1:2,1:1].F - As.F[1:2,1:1]) && lastindex(As,1) == size(As,1) && lastindex(As,2) == size(As,2)
 
 t = rand(); 
 @test [As Cs](t) ≈ [As(t) Cs(t)]