Remove value field from Variable

src/differentials.jl

@@ -16,7 +16,7 @@ function (D::Differential)(x::Variable)
 end
 Base.:(==)(D1::Differential, D2::Differential) = D1.order == D2.order && D1.x == D2.x
 
-Variable(x::Variable, D::Differential) = Variable(x.name,x.value,x.value_type,
+Variable(x::Variable, D::Differential) = Variable(x.name,x.value_type,
                 x.subtype,D,x.dependents,x.description,x.flow,x.domain,
                 x.size,x.context)
 

src/systems/diffeqs/first_order_transform.jl

@@ -5,7 +5,7 @@ function lower_varname(var::Variable, naming_scheme; lower=false)
     lower_varname(var.name, D.x, order, var.subtype, naming_scheme)
 end
 function lower_varname(sym::Symbol, idv, order::Int, subtype::Symbol, naming_scheme)
-    order == 0 && return Variable(sym, subtype)
+    order == 0 && return Variable(sym, subtype=subtype)
     name = Symbol(String(sym)*naming_scheme*String(idv.name)^order)
     Variable(name, subtype=subtype)
 end

src/variables.jl

@@ -1,6 +1,5 @@
 mutable struct Variable <: Expression
     name::Symbol
-    value
     value_type::DataType
     subtype::Symbol
     diff::Union{Function,Nothing}  # FIXME
@@ -13,20 +12,19 @@ mutable struct Variable <: Expression
 end
 
 Variable(name,
-         value = nothing,
-         value_type = typeof(value);
+         value_type = Any;
          subtype::Symbol=:Variable,
          dependents::Vector{Variable} = Variable[],
          flow::Bool = false,
          description::String = "",
          domain = Reals(),
          size = nothing,
          context = nothing) =
-         Variable(name,value,value_type,subtype,nothing,
+         Variable(name,value_type,subtype,nothing,
                   dependents,description,flow,domain,size,context)
 Variable(name,args...;kwargs...) = Variable(name,args...;subtype=:Variable,kwargs...)
 
-Variable(name,x::Variable) = Variable(name,x.value,x.value_type,
+Variable(name,x::Variable) = Variable(name,x.value_type,
                 x.subtype,D,x.dependents,x.description,x.flow,x.domain,
                 x.size,x.context)
 
@@ -73,8 +71,8 @@ Base.isone(ex::Expression)  = isa(ex, Constant) && isone(ex.value)
 
 
 # Variables use isequal for equality since == is an Operation
-function Base.:(==)(x::Variable,y::Variable)
-    x.name == y.name && x.subtype == y.subtype && x.value == y.value &&
+function Base.:(==)(x::Variable, y::Variable)
+    x.name == y.name && x.subtype == y.subtype &&
     x.value_type == y.value_type && x.diff == y.diff
 end
 Base.:(==)(::Variable, ::Number) = false
@@ -142,45 +140,29 @@ function _parse_vars(macroname, fun, x)
     # begin
     #     x
     #     y
-    #     z = exp(2)
+    #     z
     # end
     x = flatten_expr!(x)
     for _var in x
         iscall = typeof(_var) <: Expr && _var.head == :call
         issym    = _var isa Symbol
-        isassign = issym ? false : _var.head == :(=)
-        @assert iscall || issym || isassign "@$macroname expects a tuple of expressions!\nE.g. `@$macroname x y z=1`"
-        if iscall || issym
-            if iscall
-                dependents = :([$(_var.args[2:end]...)])
-                var = _var.args[1]
-            else
-                dependents = Variable[]
-                var = _var
-            end
-            lhs = var
-            push!(lhss, lhs)
-            expr = :( $lhs = $fun( Symbol($(String(lhs))) ,
-                      dependents = $dependents))
-        end
-        if isassign
-            iscall = typeof(_var.args[1]) <: Expr && _var.args[1].head == :call
-            if iscall
-                dependents = :([$(_var.args[1].args[2:end]...)])
-                lhs = _var.args[1].args[1]
-            else
-                dependents = Variable[]
-                lhs = _var.args[1]
-            end
-            rhs = _var.args[2]
-            push!(lhss, lhs)
-            expr = :( $lhs = $fun( Symbol($(String(lhs))) , $rhs,
-                      dependents = $dependents))
+        @assert iscall || issym "@$macroname expects a tuple of expressions!\nE.g. `@$macroname x y z`"
+
+        if iscall
+            dependents = :([$(_var.args[2:end]...)])
+            lhs = _var.args[1]
+        else
+            dependents = Variable[]
+            lhs = _var
         end
+
+        push!(lhss, lhs)
+        expr = :( $lhs = $fun( Symbol($(String(lhs))) ,
+                  dependents = $dependents))
         push!(ex.args, expr)
     end
-    push!(ex.args, Expr(:tuple, lhss...))
-    ex
+    push!(ex.args, build_expr(:tuple, lhss))
+    return ex
 end
 
 for funs in ((:DVar, :DependentVariable), (:IVar, :IndependentVariable),

test/basic_variables_and_operations.jl

@@ -10,11 +10,11 @@ using Test
 @Const c=0
 
 # Default values
-p = Parameter(:p, 1)
-u = DependentVariable(:u, [1], dependents = [t])
+p = Parameter(:p)
+u = DependentVariable(:u, dependents = [t])
 
-s = JumpVariable(:s,3,dependents=[t])
-n = NoiseVariable(:n,dependents=[t])
+s = JumpVariable(:s, dependents=[t])
+n = NoiseVariable(:n, dependents=[t])
 
 σ*(y-x)
 D(x)

test/derivatives.jl

@@ -11,7 +11,7 @@ expand_derivatives(dsin)
 
 @test expand_derivatives(dsin) == cos(t)
 dcsch = D(csch(t))
-@test expand_derivatives(dcsch) == simplify_constants(Operation(coth(t)*csch(t)*-1))
+@test expand_derivatives(dcsch) == simplify_constants(coth(t) * csch(t) * -1)
 
 # Chain rule
 dsinsin = D(sin(sin(t)))

test/system_construction.jl

@@ -50,14 +50,15 @@ function test_eqs(eqs1, eqs2)
     eq = true
     for i in eachindex(eqs1)
         lhs1, lhs2 = eqs1[i].args[1], eqs2[i].args[1]
+        typeof(lhs1) === typeof(lhs2) || return false
         for f in fieldnames(typeof(lhs1))
             eq = eq && isequal(getfield(lhs1, f), getfield(lhs2, f))
         end
         eq = eq && isequal(eqs1[i].args[2], eqs2[i].args[2])
     end
-    @test_broken eq
+    eq
 end
-test_eqs(de1.eqs, lowered_eqs)
+@test_broken test_eqs(de1.eqs, lowered_eqs)
 
 # Internal calculations
 eqs = [a ~ y-x,

test/variable_parsing.jl

@@ -1,23 +1,23 @@
 using ModelingToolkit
 using Test
 
-@Var a=1.0 b
-a1 = Variable(:a,1.0)
+@Var a b
+a1 = Variable(:a)
 @test a1 == a
 @test convert(Expr, a) == :a
 
 @Var begin
-    a = 1.0
+    a
     b
 end
 
 @IVar t
 @DVar x(t)
-@DVar y(t)=sin(1)+exp(1)
+@DVar y(t)
 @DVar z(t)
-x1 = DependentVariable(:x,dependents = [t])
-y1 = DependentVariable(:y, sin(1) + exp(1),dependents = [t])
-z1 = DependentVariable(:z,dependents = [t])
+x1 = DependentVariable(:x ,dependents = [t])
+y1 = DependentVariable(:y ,dependents = [t])
+z1 = DependentVariable(:z ,dependents = [t])
 @test x1 == x
 @test y1 == y
 @test z1 == z
@@ -27,10 +27,10 @@ z1 = DependentVariable(:z,dependents = [t])
 
 @IVar begin
     t
-    s = cos(2.5)
+    s
 end
 t1 = IndependentVariable(:t)
-s1 = IndependentVariable(:s, cos(2.5))
+s1 = IndependentVariable(:s)
 @test t1 == t
 @test s1 == s
 @test convert(Expr, t) == :t