Replace @unknown with @variable, remove Parameter

Author: HarrisonGrodin

README.md

@@ -21,15 +21,15 @@ to manipulate.
 ### Example: ODE
 
 Let's build an ODE. First we define some variables. In a differential equation
-system, we need to differentiate between our unknown (dependent) variables
+system, we need to differentiate between our (dependent) variables
 and parameters. Therefore we label them as follows:
 
 ```julia
 using ModelingToolkit
 
 # Define some variables
 @Param t σ ρ β
-@Unknown x(t) y(t) z(t)
+@Variable x(t) y(t) z(t)
 @Deriv D'~t
 ```
 
@@ -78,10 +78,10 @@ f = ODEFunction(de)
 
 We can also build nonlinear systems. Let's say we wanted to solve for the steady
 state of the previous ODE. This is the nonlinear system defined by where the
-derivatives are zero. We use unknown variables for our nonlinear system.
+derivatives are zero. We use (unknown) variables for our nonlinear system.
 
 ```julia
-@Unknown x y z
+@Variable x y z
 @Param σ ρ β
 
 # Define a nonlinear system
@@ -173,7 +173,7 @@ structure is as follows:
   the system of equations.
 - Name to subtype mappings: these describe how variable `subtype`s are mapped
   to the contexts of the system. For example, for a differential equation,
-  the unknown variable corresponds to given subtypes and then the `eqs` can
+  the variable corresponds to given subtypes and then the `eqs` can
   be analyzed knowing what the state variables are.
 - Variable names which do not fall into one of the system's core subtypes are
   treated as intermediates which can be used for holding subcalculations and
@@ -244,29 +244,29 @@ syntactic sugar in some form. For example, the variable construction:
 
 ```julia
 @Param t σ ρ β
-@Unknown x(t) y(t) z(t)
+@Variable x(t) y(t) z(t)
 @Deriv D'~t
 ```
 
 is syntactic sugar for:
 
 ```julia
-t = Parameter(:t)
-x = Unknown(:x, [t])
-y = Unknown(:y, [t])
-z = Unknown(:z, [t])
+t = Variable(:t; known = true)
+x = Variable(:x, [t])
+y = Variable(:y, [t])
+z = Variable(:z, [t])
 D = Differential(t)
-σ = Parameter(:σ)
-ρ = Parameter(:ρ)
-β = Parameter(:β)
+σ = Variable(:σ; known = true)
+ρ = Variable(:ρ; known = true)
+β = Variable(:β; known = true)
 ```
 
 ### Intermediate Calculations
 
 The system building functions can handle intermediate calculations. For example,
 
 ```julia
-@Unknown x y z
+@Variable x y z
 @Param σ ρ β
 a = y - x
 eqs = [0 ~ σ*a,

src/systems/diffeqs/diffeqsystem.jl

@@ -79,7 +79,7 @@ end
 function generate_ode_iW(sys::DiffEqSystem, simplify=true; version::FunctionVersion = ArrayFunction)
     jac = calculate_jacobian(sys)
 
-    gam = Parameter(:gam)
+    gam = Variable(:gam; known = true)
 
     W = LinearAlgebra.I - gam*jac
     W = SMatrix{size(W,1),size(W,2)}(W)

src/variables.jl

@@ -1,15 +1,14 @@
-export Variable, Unknown, Parameter, @Unknown, @Param
+export Variable, @Variable, @Param
 
 
 struct Variable <: Expression
     name::Symbol
-    known::Bool
     dependents::Vector{Variable}
+    known::Bool
+    Variable(name, dependents = Variable[]; known = false) =
+        new(name, dependents, known)
 end
 
-Parameter(name, dependents = Variable[]) = Variable(name, true, dependents)
-Unknown(name, dependents = Variable[]) = Variable(name, false, dependents)
-
 
 struct Constant <: Expression
     value::Number
@@ -41,7 +40,7 @@ Base.convert(::Type{Expr}, c::Constant) = c.value
 Base.show(io::IO, x::Variable) = print(io, x.name)
 
 # Build variables more easily
-function _parse_vars(macroname, fun, x)
+function _parse_vars(macroname, known, x)
     ex = Expr(:block)
     var_names = Symbol[]
     # if parsing things in the form of
@@ -65,15 +64,15 @@ function _parse_vars(macroname, fun, x)
         end
 
         push!(var_names, var_name)
-        expr = :($var_name = $fun($(Meta.quot(var_name)), $dependents))
+        expr = :($var_name = $Variable($(Meta.quot(var_name)), $dependents; known = $known))
         push!(ex.args, expr)
     end
     push!(ex.args, build_expr(:tuple, var_names))
     return ex
 end
-macro Unknown(xs...)
-    esc(_parse_vars(:Unknown, Unknown, xs))
+macro Variable(xs...)
+    esc(_parse_vars(:Variable, false, xs))
 end
 macro Param(xs...)
-    esc(_parse_vars(:Param, Parameter, xs))
+    esc(_parse_vars(:Param, true, xs))
 end

test/derivatives.jl

@@ -3,7 +3,7 @@ using Test
 
 # Derivatives
 @Param t σ ρ β
-@Unknown x(t) y(t) z(t)
+@Variable x(t) y(t) z(t)
 @Deriv D'~t D2''~t
 
 @test isequal(expand_derivatives(D(t)), 1)
@@ -47,7 +47,7 @@ jac = calculate_jacobian(sys)
 @test isequal(jac[3,3], -1*β)
 
 # Variable dependence checking in differentiation
-@Unknown a(t) b(a)
+@Variable a(t) b(a)
 @test !isequal(D(b), 0)
 
 @test isequal(expand_derivatives(D(x * y)), simplify_constants(y*D(x) + x*D(y)))

test/simplify.jl

@@ -2,7 +2,7 @@ using ModelingToolkit
 using Test
 
 @Param t
-@Unknown x(t) y(t) z(t)
+@Variable x(t) y(t) z(t)
 
 null_op = 0*t
 @test isequal(simplify_constants(null_op), 0)

test/system_construction.jl

@@ -3,7 +3,7 @@ using Test
 
 # Define some variables
 @Param t σ ρ β
-@Unknown x(t) y(t) z(t)
+@Variable x(t) y(t) z(t)
 @Deriv D'~t
 
 # Define a differential equation
@@ -48,7 +48,7 @@ end
 # Conversion to first-order ODEs #17
 @Deriv D3'''~t
 @Deriv D2''~t
-@Unknown u(t) u_tt(t) u_t(t) x_t(t)
+@Variable u(t) u_tt(t) u_t(t) x_t(t)
 eqs = [D3(u) ~ 2(D2(u)) + D(u) + D(x) + 1
        D2(x) ~ D(x) + 2]
 de = DiffEqSystem(eqs, t)
@@ -100,7 +100,7 @@ test_vars_extraction(de, DiffEqSystem(eqs))
 end
 
 # Now nonlinear system with only variables
-@Unknown x y z
+@Variable x y z
 @Param σ ρ β
 
 # Define a nonlinear system

test/variable_parsing.jl

@@ -2,12 +2,12 @@ using ModelingToolkit
 using Test
 
 @Param t
-@Unknown x(t)
-@Unknown y(t)
-@Unknown z(t)
-x1 = Unknown(:x, [t])
-y1 = Unknown(:y, [t])
-z1 = Unknown(:z, [t])
+@Variable x(t)
+@Variable y(t)
+@Variable z(t)
+x1 = Variable(:x, [t])
+y1 = Variable(:y, [t])
+z1 = Variable(:z, [t])
 @test isequal(x1, x)
 @test isequal(y1, y)
 @test isequal(z1, z)
@@ -19,8 +19,8 @@ z1 = Unknown(:z, [t])
     t
     s
 end
-t1 = Parameter(:t)
-s1 = Parameter(:s)
+t1 = Variable(:t; known = true)
+s1 = Variable(:s; known = true)
 @test isequal(t1, t)
 @test isequal(s1, s)
 @test convert(Expr, t) == :t