Merge pull request #86 from JuliaDiffEq/hg/refactor/variable

Fold IndependentVariable into Parameter

Author: ChrisRackauckas

README.md

@@ -21,17 +21,16 @@ 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, independent
-variables, and parameters. Therefore we label them as follows:
+system, we need to differentiate between our unknown (dependent) variables
+and parameters. Therefore we label them as follows:
 
 ```julia
 using ModelingToolkit
 
 # Define some variables
-@IVar t
+@Param t σ ρ β
 @Unknown x(t) y(t) z(t)
 @Deriv D'~t
-@Param σ ρ β
 ```
 
 Then we build the system:
@@ -259,16 +258,15 @@ is accessible via a function-based interface. This means that all macros are
 syntactic sugar in some form. For example, the variable construction:
 
 ```julia
-@IVar t
+@Param t σ ρ β
 @Unknown x(t) y(t) z(t)
 @Deriv D'~t
-@Param σ ρ β
 ```
 
 is syntactic sugar for:
 
 ```julia
-t = IndependentVariable(:t)
+t = Parameter(:t)
 x = Unknown(:x, dependents = [t])
 y = Unknown(:y, dependents = [t])
 z = Unknown(:z, dependents = [t])

src/equations.jl

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

src/systems/diffeqs/diffeqsystem.jl

@@ -9,13 +9,15 @@ end
 DiffEqSystem(eqs, ivs, dvs, ps) = DiffEqSystem(eqs, ivs, dvs, ps, Matrix{Expression}(undef,0,0))
 
 function DiffEqSystem(eqs)
-    predicates = [_is_derivative, _subtype(:IndependentVariable), _is_dependent, _subtype(:Parameter)]
-    _, ivs, dvs, ps = extract_elements(eqs, predicates)
+    predicates = [_is_derivative, _is_dependent]
+    _, dvs = extract_elements(eqs, predicates)
+    ivs = unique(vcat((dv.dependents for dv ∈ dvs)...))
+    ps, = extract_elements(eqs, [_is_parameter(ivs)])
     DiffEqSystem(eqs, ivs, dvs, ps, Matrix{Expression}(undef,0,0))
 end
 
 function DiffEqSystem(eqs, ivs)
-    predicates = [_is_derivative, _is_dependent, _subtype(:Parameter)]
+    predicates = [_is_derivative, _is_dependent, _is_parameter(ivs)]
     _, dvs, ps = extract_elements(eqs, predicates)
     DiffEqSystem(eqs, ivs, dvs, ps, Matrix{Expression}(undef,0,0))
 end
@@ -85,7 +87,7 @@ function generate_ode_iW(sys::DiffEqSystem, simplify=true)
     diff_exprs = filter(!isintermediate, sys.eqs)
     jac = sys.jac
 
-    gam = Unknown(:gam)
+    gam = Parameter(:gam)
 
     W = LinearAlgebra.I - gam*jac
     W = SMatrix{size(W,1),size(W,2)}(W)

src/variables.jl

@@ -8,12 +8,10 @@ end
 Variable(name; subtype::Symbol, dependents::Vector{Variable} = Variable[]) =
     Variable(name, subtype, nothing, dependents)
 
-Parameter(name,args...;kwargs...) = Variable(name,args...;subtype=:Parameter,kwargs...)
-IndependentVariable(name,args...;kwargs...) = Variable(name,args...;subtype=:IndependentVariable,kwargs...)
-Unknown(name,args...;kwargs...) = Variable(name,args...;subtype=:Unknown,kwargs...)
+Parameter(name; kwargs...) = Variable(name; subtype=:Parameter, kwargs...)
+Unknown(name, ;kwargs...) = Variable(name; subtype=:Unknown, kwargs...)
 
-export Variable,Parameter,Constant,Unknown,IndependentVariable,
-       @Param, @Const, @Unknown, @IVar
+export Variable, Unknown, Parameter, Constant, @Unknown, @Param, @Const
 
 
 Base.copy(x::Variable) = Variable(x.name, x.subtype, x.diff, x.dependents)
@@ -53,7 +51,7 @@ end
 # Build variables more easily
 function _parse_vars(macroname, fun, x)
     ex = Expr(:block)
-    lhss = Symbol[]
+    var_names = Symbol[]
     # if parsing things in the form of
     # begin
     #     x
@@ -62,33 +60,30 @@ function _parse_vars(macroname, fun, x)
     # end
     x = flatten_expr!(x)
     for _var in x
-        iscall = typeof(_var) <: Expr && _var.head == :call
+        iscall = isa(_var, Expr) && _var.head == :call
         issym    = _var isa Symbol
-        @assert iscall || issym "@$macroname expects a tuple of expressions!\nE.g. `@$macroname x y z`"
+        @assert iscall || issym "@$macroname expects a tuple of expressions (`@$macroname x y z(t)`)"
 
         if iscall
             dependents = :(Variable[$(_var.args[2:end]...)])
-            lhs = _var.args[1]
+            var_name = _var.args[1]
         else
             dependents = Variable[]
-            lhs = _var
+            var_name = _var
         end
 
-        push!(lhss, lhs)
-        expr = :( $lhs = $fun( Symbol($(String(lhs))) ,
-                  dependents = $dependents))
+        push!(var_names, var_name)
+        expr = :($var_name = $fun($(Meta.quot(var_name)), dependents = $dependents))
         push!(ex.args, expr)
     end
-    push!(ex.args, build_expr(:tuple, lhss))
+    push!(ex.args, build_expr(:tuple, var_names))
     return ex
 end
-
-for funs in [(:Unknown, :Unknown), (:IVar, :IndependentVariable), (:Param, :Parameter)]
-    @eval begin
-        macro ($(funs[1]))(x...)
-            esc(_parse_vars(String($funs[1]), $funs[2], x))
-        end
-    end
+macro Unknown(xs...)
+    esc(_parse_vars(:Unknown, Unknown, xs))
+end
+macro Param(xs...)
+    esc(_parse_vars(:Param, Parameter, xs))
 end
 
 function _const_assign(x)

test/ambiguity.jl

@@ -1,7 +1,7 @@
 using ModelingToolkit
 using Test
 
-@IVar t
+@Param t
 @Unknown x(t) y(t) z(t)
 
 struct __MyType__ end

test/basic_variables_and_operations.jl

@@ -1,11 +1,9 @@
 using ModelingToolkit
 using Test
 
-@IVar t
+@Param t σ ρ β
 @Unknown x(t) y(t) z(t)
-
 @Deriv D'~t # Default of first derivative, Derivative(t,1)
-@Param σ ρ β
 @Const c=0
 
 # Default values

test/components.jl

@@ -22,7 +22,7 @@ function Lorenz(t)
     Lorenz(x, y, z, σ, ρ, β, generate_lorenz_eqs(t, x, y, z, σ, ρ, β))
 end
 
-@IVar t
+@Param t
 lz1 = Lorenz(t)
 lz2 = Lorenz(t)
 lz1.x ~ lz2.x

test/derivatives.jl

@@ -2,9 +2,8 @@ using ModelingToolkit
 using Test
 
 # Derivatives
-@IVar t
+@Param t σ ρ β
 @Unknown x(t) y(t) z(t)
-@Param σ ρ β
 @Deriv D'~t
 dsin = D(sin(t))
 expand_derivatives(dsin)

test/internal.jl

@@ -2,7 +2,7 @@ using ModelingToolkit
 using Test
 
 # `Expr`, `Number` -> `Operation`
-@IVar a
+@Param a
 @Param b
 @Unknown x(t) y()
 @test convert(Expression, 2) == 2

test/simplify.jl

@@ -1,7 +1,7 @@
 using ModelingToolkit
 using Test
 
-@IVar t
+@Param t
 @Unknown x(t) y(t) z(t)
 
 null_op = 0*t