Rename DependentVariable to Unknown

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 dependent variables, independent
+system, we need to differentiate between our unknown variables, independent
 variables, and parameters. Therefore we label them as follows:
 
 ```julia
 using ModelingToolkit
 
 # Define some variables
 @IVar t
-@DVar x(t) y(t) z(t)
+@Unknown x(t) y(t) z(t)
 @Deriv D'~t
 @Param σ ρ β
 ```
@@ -87,12 +87,12 @@ 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 could use dependent variables for our nonlinear system
+derivatives are zero. We could use unknown variables for our nonlinear system
 (for direct compatibility with the above ODE code), or we can use non-tagged
 variables. Here we will show the latter. We write:
 
 ```julia
-@DVar x y z
+@Unknown x y z
 @Param σ ρ β
 
 # Define a nonlinear system
@@ -191,7 +191,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 dependent variable corresponds to given subtypes and then the `eqs` can
+  the unknown 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
@@ -262,7 +262,7 @@ syntactic sugar in some form. For example, the variable construction:
 
 ```julia
 @IVar t
-@DVar x(t) y(t) z(t)
+@Unknown x(t) y(t) z(t)
 @Deriv D'~t
 @Param σ ρ β
 ```
@@ -271,9 +271,9 @@ is syntactic sugar for:
 
 ```julia
 t = IndependentVariable(:t)
-x = DependentVariable(:x,dependents = [t])
-y = DependentVariable(:y,dependents = [t])
-z = DependentVariable(:z,dependents = [t])
+x = Unknown(:x, dependents = [t])
+y = Unknown(:y, dependents = [t])
+z = Unknown(:z, dependents = [t])
 D = Differential(t) # Default of first derivative, Derivative(t,1)
 σ = Parameter(:σ)
 ρ = Parameter(:ρ)
@@ -285,7 +285,7 @@ D = Differential(t) # Default of first derivative, Derivative(t,1)
 The system building functions can handle intermediate calculations. For example,
 
 ```julia
-@DVar a x y z
+@Unknown a x y z
 @Param σ ρ β
 eqs = [a ~ y-x,
        0 ~ σ*a,

src/equations.jl

@@ -13,7 +13,7 @@ Base.:~(lhs::Number    , rhs::Expression) = Equation(lhs, rhs)
 
 
 _is_derivative(x::Variable) = x.diff !== nothing
-_is_dependent(x::Variable) = x.subtype === :DependentVariable && !isempty(x.dependents)
+_is_dependent(x::Variable) = x.subtype === :Unknown && !isempty(x.dependents)
 _subtype(subtype::Symbol) = x -> x.subtype === subtype
 
 function extract_elements(eqs, predicates)

src/systems/diffeqs/diffeqsystem.jl

@@ -18,15 +18,15 @@ function DiffEqSystem(eqs, ivs, dvs, vs, ps)
 end
 
 function DiffEqSystem(eqs; iv_name = :IndependentVariable,
-                           dv_name = :DependentVariable,
+                           dv_name = :Unknown,
                            p_name = :Parameter)
     predicates = [_is_derivative, _subtype(iv_name), _is_dependent, _subtype(dv_name), _subtype(p_name)]
     _, ivs, dvs, vs, ps = extract_elements(eqs, predicates)
     DiffEqSystem(eqs, ivs, dvs, vs, ps, iv_name, dv_name, p_name, Matrix{Expression}(undef,0,0))
 end
 
 function DiffEqSystem(eqs, ivs;
-                      dv_name = :DependentVariable,
+                      dv_name = :Unknown,
                       p_name = :Parameter)
     predicates = [_is_derivative, _is_dependent, _subtype(dv_name), _subtype(p_name)]
     _, dvs, vs, ps = extract_elements(eqs, predicates)
@@ -98,7 +98,7 @@ function generate_ode_iW(sys::DiffEqSystem, simplify=true)
     diff_exprs = filter(!isintermediate, sys.eqs)
     jac = sys.jac
 
-    gam = DependentVariable(:gam)
+    gam = Unknown(:gam)
 
     W = LinearAlgebra.I - gam*jac
     W = SMatrix{size(W,1),size(W,2)}(W)

src/systems/nonlinear/nonlinear_system.jl

@@ -7,13 +7,13 @@ struct NonlinearSystem <: AbstractSystem
 end
 
 function NonlinearSystem(eqs, vs, ps;
-                         v_name = :DependentVariable,
+                         v_name = :Unknown,
                          p_name = :Parameter)
     NonlinearSystem(eqs, vs, ps, [v_name], p_name)
 end
 
 function NonlinearSystem(eqs;
-                         v_name = :DependentVariable,
+                         v_name = :Unknown,
                          p_name = :Parameter)
     vs, ps = extract_elements(eqs, [_subtype(v_name), _subtype(p_name)])
     NonlinearSystem(eqs, vs, ps, [v_name], p_name)

src/variables.jl

@@ -10,10 +10,10 @@ Variable(name; subtype::Symbol, dependents::Vector{Variable} = Variable[]) =
 
 Parameter(name,args...;kwargs...) = Variable(name,args...;subtype=:Parameter,kwargs...)
 IndependentVariable(name,args...;kwargs...) = Variable(name,args...;subtype=:IndependentVariable,kwargs...)
-DependentVariable(name,args...;kwargs...) = Variable(name,args...;subtype=:DependentVariable,kwargs...)
+Unknown(name,args...;kwargs...) = Variable(name,args...;subtype=:Unknown,kwargs...)
 
-export Variable,Parameter,Constant,DependentVariable,IndependentVariable,
-       @Param, @Const, @DVar, @IVar
+export Variable,Parameter,Constant,Unknown,IndependentVariable,
+       @Param, @Const, @Unknown, @IVar
 
 
 Base.copy(x::Variable) = Variable(x.name, x.subtype, x.diff, x.dependents)
@@ -83,7 +83,7 @@ function _parse_vars(macroname, fun, x)
     return ex
 end
 
-for funs in [(:DVar, :DependentVariable), (:IVar, :IndependentVariable), (:Param, :Parameter)]
+for funs in [(:Unknown, :Unknown), (:IVar, :IndependentVariable), (:Param, :Parameter)]
     @eval begin
         macro ($(funs[1]))(x...)
             esc(_parse_vars(String($funs[1]), $funs[2], x))

test/ambiguity.jl

@@ -2,7 +2,7 @@ using ModelingToolkit
 using Test
 
 @IVar t
-@DVar x(t) y(t) z(t)
+@Unknown x(t) y(t) z(t)
 
 struct __MyType__ end
 Base.:~(::__MyType__,::Number) = 2

test/basic_variables_and_operations.jl

@@ -2,15 +2,15 @@ using ModelingToolkit
 using Test
 
 @IVar t
-@DVar x(t) y(t) z(t)
+@Unknown x(t) y(t) z(t)
 
 @Deriv D'~t # Default of first derivative, Derivative(t,1)
 @Param σ ρ β
 @Const c=0
 
 # Default values
 p = Parameter(:p)
-u = DependentVariable(:u, dependents = [t])
+u = Unknown(:u, dependents = [t])
 
 σ*(y-x)
 D(x)

test/components.jl

@@ -17,7 +17,7 @@ function generate_lorenz_eqs(t,x,y,z,σ,ρ,β)
      D(z) ~ x*y - β*z]
 end
 function Lorenz(t)
-    @DVar x(t) y(t) z(t)
+    @Unknown x(t) y(t) z(t)
     @Param σ ρ β
     Lorenz(x, y, z, σ, ρ, β, generate_lorenz_eqs(t, x, y, z, σ, ρ, β))
 end

test/derivatives.jl

@@ -3,7 +3,7 @@ using Test
 
 # Derivatives
 @IVar t
-@DVar x(t) y(t) z(t)
+@Unknown x(t) y(t) z(t)
 @Param σ ρ β
 @Deriv D'~t
 dsin = D(sin(t))
@@ -43,5 +43,5 @@ jac = ModelingToolkit.calculate_jacobian(sys)
 @test jac[3,3] == -1*β
 
 # Variable dependence checking in differentiation
-@DVar a(t) b(a)
+@Unknown a(t) b(a)
 @test D(b) ≠ Constant(0)

test/internal.jl

@@ -4,7 +4,7 @@ using Test
 # `Expr`, `Number` -> `Operation`
 @IVar a
 @Param b
-@DVar x(t) y()
+@Unknown x(t) y()
 @test convert(Expression, 2) == 2
 expr = :(-inv(2sqrt(+($a, $b))))
 op   = Operation(-, [Operation(inv,