Direct Problem (#234)

* Refine problems and add direct prob

* Update docs and remove pkg loading

* Clean dispatch for koopman

* Clean up tests

* Scalarize parameters

* Update docs

* Add more tests for problem

* More koopman tests

Author: AlCap23

docs/src/prob_and_solve.md

@@ -2,26 +2,28 @@
 
 As can be seen from the [introduction examples](@id Quickstart), [DataDrivenDiffEq.jl](https://github.com/SciML/DataDrivenDiffEq.jl) tries to structurize the workflow in a similar fashion to other [SciML](https://sciml.ai/) packages by defining a [`DataDrivenProblem`](@ref), dispatching on the `solve` command to return a [`DataDrivenSolution`](@ref).
 
-A problem in the sense of identification, estimation or inference is defined by the data describing it. This data contains at least measurements of the states `X`, which would be sufficient to describe a `DiscreteDataDrivenProblem` with unit time steps similar to the [first example on dynamic mode decomposition](@ref Linear-Systems-via-Dynamic-Mode-Decomposition). Of course we can extend this to include time points `t`, consecutive measurements `X̃` at the next time point or control signals `U` or a function describing those `u(x,p,t)`. Additionally, any parameters `p` known a priori can be included in the problem. In practice, this looks like
+A problem in the sense of identification, estimation or inference is defined by the data describing it. This data contains at least measurements of the states `X`, which would be sufficient to describe a `DiscreteDataDrivenProblem` with unit time steps similar to the [first example on dynamic mode decomposition](@ref Linear-Systems-via-Dynamic-Mode-Decomposition). Of course we can extend this to include time points `t`, control signals `U` or a function describing those `u(x,p,t)`. Additionally, any parameters `p` known a priori can be included in the problem. In practice, this looks like
 
 ```julia
 problem = DiscreteDataDrivenProblem(X)
 problem = DiscreteDataDrivenProblem(X, t)
-problem = DiscreteDataDrivenProblem(X, t, X̃)
-problem = DiscreteDataDrivenProblem(X, t, X̃, U = U)
-problem = DiscreteDataDrivenProblem(X, t, X̃, U = U, p = p)
-problem = DiscreteDataDrivenProblem(X, t, X̃, U = (x,p,t)->u(x,p,t))
+problem = DiscreteDataDrivenProblem(X, t, U)
+problem = DiscreteDataDrivenProblem(X, t, U, p = p)
+problem = DiscreteDataDrivenProblem(X, t, (x,p,t)->u(x,p,t))
 ```
 
 Similarly, a `ContinuousDataDrivenProblem` would need at least measurements and time-derivatives (`X` and `DX`) or measurements, time information and a way to derive the time derivatives(`X`, `t` and a [Collocation](@ref) method). Again, this can be extended by including a control input as measurements or a function and possible parameters.
 
 ```julia
+problem = ContinuousDataDrivenProblem(X, DX)
+problem = ContinuousDataDrivenProblem(X, t, DX)
+problem = ContinuousDataDrivenProblem(X, t, DX, U, p = p)
+problem = ContinuousDataDrivenProblem(X, t, DX, (x,p,t)->u(x,p,t))
+# Using collocation
 problem = ContinuousDataDrivenProblem(X, t, InterpolationMethod())
-problem = ContinuousDataDrivenProblem(X, DX = DX)
-problem = ContinuousDataDrivenProblem(X, t, DX = DX)
-problem = ContinuousDataDrivenProblem(X, t, DX = DX, U = U)
-problem = ContinuousDataDrivenProblem(X, t, DX = DX, U = U, p = p)
-problem = ContinuousDataDrivenProblem(X, t, DX = DX, U = (x,p,t)->u(x,p,t))
+problem = ContinuousDataDrivenProblem(X, t, GaussianKernel())
+problem = ContinuousDataDrivenProblem(X, t, U, InterpolationMethod())
+problem = ContinuousDataDrivenProblem(X, t, U, GaussianKernel(), p = p)
 ```
 
 You can also directly use a `DESolution` as an input to your [`DataDrivenProblem`](@ref):
@@ -33,6 +35,16 @@ problem = DataDrivenProblem(sol; kwargs...)
 which evaluates the function at the specific timepoints `t` using the parameters `p` of the original problem instead of
 using the interpolation. If you want to use the interpolated data, add the additional keyword `use_interpolation = true`.
 
+An additional type of problem is the `DirectDataDrivenProblem`, which does not assume any kind of causal relationship. It is defined by `X` and an observed output `Y` in addition to the usual arguments:
+
+```julia
+problem = DirectDataDrivenProblem(X, Y)
+problem = DirectDataDrivenProblem(X, t, Y)
+problem = DirectDataDrivenProblem(X, t, Y, U)
+problem = DirectDataDrivenProblem(X, t, Y, p = p)
+problem = DirectDataDrivenProblem(X, t, Y, (x,p,t)->u(x,p,t), p = p)
+```
+
 Next up, we choose a method to `solve` the [`DataDrivenProblem`](@ref). Depending on the input arguments and the type of problem, the function will return a result derived via [`Koopman`](@ref) or [`Sparse Optimization`](@ref) methods. Different options can be provided as well as a [`Basis`](@ref) used for lifting the measurements, to control different options like rounding, normalization or the progressbar depending on the inference method. Possible options are provided [below](@ref optional_arguments).
 
 ```julia

docs/src/quickstart.md

@@ -29,9 +29,8 @@ savefig("DMD_Example_1.png") # hide
 To estimate the underlying operator in the states ``u_1, u_2``, we simply define a discrete [`DataDrivenProblem`](@ref) using the measurements and time and `solve` the estimation problem using the [`DMDSVD`](@ref) algorithm for approximating the operator.
 
 ```@example 4
-X = Array(sol)
 
-prob = DiscreteDataDrivenProblem(X, t = sol.t)
+prob = DiscreteDataDrivenProblem(sol)
 
 res = solve(prob, DMDSVD(), digits = 1)
 system = result(res)
@@ -114,6 +113,7 @@ using ModelingToolkit
 using OrdinaryDiffEq
 using Plots
 using Random
+using Symbolics: scalarize
 
 Random.seed!(1111) # Due to the noise
 
@@ -166,8 +166,11 @@ and returns a pareto optimal solution of the underlying [`sparse_regression!`](@
 ```@example 1
 @variables u[1:2] c[1:1]
 @parameters w[1:2]
+u = scalarize(u)
+c = scalarize(c)
+w = scalarize(w)
 
-h = Num[sin(w[1]*u[1]);cos(w[2]*u[1]); polynomial_basis(u, 5); c]
+h = Num[sin.(w[1].*u[1]);cos.(w[2].*u[1]); polynomial_basis(u, 5); c]
 
 basis = Basis(h, u, parameters = w, controls = c)
 
@@ -248,7 +251,7 @@ for (i, xi) in enumerate(eachcol(X))
     DX[:, i] = michaelis_menten(xi, [], ts[i])
 end
 
-prob = ContinuousDataDrivenProblem(X, ts, DX = DX)
+prob = ContinuousDataDrivenProblem(X, ts, DX)
 
 p1 = plot(ts, X', label = ["Measurement" nothing], color = :black, style = :dash, legend = :bottomleft, ylabel ="Measurement") # hide
 p2 = plot(ts, DX', label = nothing, color = :black, style = :dash, ylabel = "Derivative", xlabel = "Time [s]") # hide

src/DataDrivenDiffEq.jl

@@ -33,7 +33,7 @@ abstract type CollocationKernel end
 abstract type AbstractKoopmanAlgorithm end
 
 # Problem and solution
-abstract type AbstractDataDrivenProblem end
+abstract type AbstractDataDrivenProblem{dType, cType, probType} end
 abstract type AbstractDataDrivenSolution end
 
 
@@ -81,13 +81,31 @@ export update!
 include("./koopman/algorithms.jl")
 export DMDPINV, DMDSVD, TOTALDMD
 
+
+
 ## Problem and Solution
+# Use to distinguish the problem types
+@enum DDProbType begin
+    Direct=1 # Direct problem without further information
+    Discrete=2 # Time discrete problem
+    Continuous=3 # Time continous problem
+end
+
+
+# Define some alias type for easier dispatch
+const AbstractDirectProb{N,C} = AbstractDataDrivenProblem{N,C,DDProbType(1)}
+const AbstractDiscreteProb{N,C} = AbstractDataDrivenProblem{N,C,DDProbType(2)}
+const AbstracContProb{N,C} = AbstractDataDrivenProblem{N,C,DDProbType(3)}
+
+
 include("./problem.jl")
+
 export DataDrivenProblem
-export DiscreteDataDrivenProblem, ContinuousDataDrivenProblem
-export has_timepoints, has_inputs, has_observations, has_derivatives
+export DiscreteDataDrivenProblem, ContinuousDataDrivenProblem, DirectDataDrivenProblem
+export is_autonomous, is_discrete, is_direct, is_continuous, is_parametrized, has_timepoints
 export is_valid
 
+
 include("./solution.jl")
 export DataDrivenSolution
 export result, parameters, parameter_map, metrics, algorithm, inputs