Merge pull request #81 from JuliaDiffEq/hg/rm/unused

Remove unused Variable information

Author: ChrisRackauckas

README.md

@@ -153,27 +153,12 @@ context-aware single variable of the IR. Its fields are described as follows:
 - `name`: the name of the `Variable`. Note that this is not necessarily
   the same as the name of the Julia variable. But this symbol itself is considered
   the core identifier of the `Variable` in the sense of equality.
-- `value_type`: the type that the values have to be. It's disconnected
-  from the `value` because in many cases the `value` may not be able to be
-  specified in advance even when we may already know the type. This can be used
-  to set units or denote a variable as being of higher precision.
 - `subtype`: the main denotation of context. Variables within systems
   are grouped according to their `subtype`.
 - `diff`: the `Differential` object representing the quantity the variable is differentiated with respect to, or `nothing`
 - `dependents`: the vector of variables on which the current variable
   is dependent. For example, `u(t,x)` has dependents `[t,x]`. Derivatives thus
   require this information in order to simplify down.
-- `flow`: a boolean that describes the connection behavior between systems,
-  whether it should connect to have summation to zero or equality.
-- `description`: a string description of the variable used for building
-  printouts and other descriptive outputs.
-- `domain`: a type which describes the domain in which the values of the variable
-  lives.
-- `size`: the size of the variable. By default it's `nothing`, denoting that the
-  variable is a scalar. Otherwise it's a tuple of numbers which describes the
-  size of the array for the variable.
-- `context`: this is an open field for DSLs to carry along more context
-  in the variables, but is not used in the systems themselves.
 
 ### Constants
 

src/ModelingToolkit.jl

@@ -10,9 +10,7 @@ abstract type Expression <: Number end
 abstract type AbstractOperation <: Expression end
 abstract type AbstractComponent <: Expression end
 abstract type AbstractSystem end
-abstract type AbstractDomain end
 
-include("domains.jl")
 include("variables.jl")
 
 Base.promote_rule(::Type{T},::Type{T2}) where {T<:Number,T2<:Expression} = Expression

src/differentials.jl

@@ -12,14 +12,13 @@ function Derivative end
 function (D::Differential)(x::Variable)
     D.x === x             && return Constant(1)
     has_dependent(x, D.x) || return Constant(0)
-    return Variable(x,D)
+
+    x′ = copy(x)
+    x′.diff = D
+    return x′
 end
 Base.:(==)(D1::Differential, D2::Differential) = D1.order == D2.order && D1.x == D2.x
 
-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)
-
 function expand_derivatives(O::Operation)
     @. O.args = expand_derivatives(O.args)
 

src/domains.jl

@@ -1,32 +1,13 @@
 mutable struct Variable <: Expression
     name::Symbol
-    value_type::DataType
     subtype::Symbol
     diff::Union{Function,Nothing}  # FIXME
     dependents::Vector{Variable}
-    description::String
-    flow::Bool
-    domain::AbstractDomain
-    size
-    context
 end
 
-Variable(name,
-         value_type = Any;
-         subtype::Symbol=:Variable,
-         dependents::Vector{Variable} = Variable[],
-         flow::Bool = false,
-         description::String = "",
-         domain = Reals(),
-         size = nothing,
-         context = 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_type,
-                x.subtype,D,x.dependents,x.description,x.flow,x.domain,
-                x.size,x.context)
+Variable(name; subtype::Symbol=:Variable, dependents::Vector{Variable} = Variable[]) =
+    Variable(name, subtype, nothing, dependents)
+Variable(name, args...; kwargs...) = Variable(name, args...; subtype=:Variable, kwargs...)
 
 Parameter(name,args...;kwargs...) = Variable(name,args...;subtype=:Parameter,kwargs...)
 IndependentVariable(name,args...;kwargs...) = Variable(name,args...;subtype=:IndependentVariable,kwargs...)
@@ -36,28 +17,11 @@ function DependentVariable(name,args...;dependents = [],kwargs...)
     Variable(name,args...;subtype=:DependentVariable,dependents=dependents,kwargs...)
 end
 
-function StateVariable(name,args...;dependents = [],kwargs...)
-    @assert !isempty(dependents)
-    Variable(name,args...;subtype=:StateVariable,dependents=dependents,kwargs...)
-end
+export Variable,Parameter,Constant,DependentVariable,IndependentVariable,
+       @Var, @Param, @Const, @DVar, @IVar
 
-function ControlVariable(name,args...;dependents = [],kwargs...)
-    @assert !isempty(dependents)
-    Variable(name,args...;subtype=:ControlVariable,dependents=dependents,kwargs...)
-end
 
-function JumpVariable(name,args...;dependents = [],kwargs...)
-    @assert !isempty(dependents)
-    Variable(name,args...;subtype=:JumpVariable,dependents=dependents,kwargs...)
-end
-
-function NoiseVariable(name,args...;dependents = [],kwargs...)
-    @assert !isempty(dependents)
-    Variable(name,args...;subtype=:NoiseVariable,dependents=dependents,kwargs...)
-end
-
-export Variable,Parameter,Constant,DependentVariable,IndependentVariable,JumpVariable,NoiseVariable,
-       @Var, @DVar, @IVar, @Param, @Const
+Base.copy(x::Variable) = Variable(x.name, x.subtype, x.diff, x.dependents)
 
 
 struct Constant <: Expression
@@ -71,10 +35,7 @@ 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_type == y.value_type && x.diff == y.diff
-end
+Base.:(==)(x::Variable, y::Variable) = (x.name, x.subtype, x.diff) == (y.name, y.subtype, y.diff)
 Base.:(==)(::Variable, ::Number) = false
 Base.:(==)(::Number, ::Variable) = false
 Base.:(==)(::Variable, ::Constant) = false

src/variables.jl

@@ -13,9 +13,6 @@ using Test
 p = Parameter(:p)
 u = DependentVariable(:u, dependents = [t])
 
-s = JumpVariable(:s, dependents=[t])
-n = NoiseVariable(:n, dependents=[t])
-
 σ*(y-x)
 D(x)
 D(x) ~ -σ*(y-x)

test/basic_variables_and_operations.jl

@@ -4,7 +4,6 @@ using ModelingToolkit, Test
 @testset "Basic Variables and Operations" begin include("basic_variables_and_operations.jl") end
 @testset "Differentiation Test" begin include("derivatives.jl") end
 @testset "Internal Test" begin include("internal.jl") end
-@testset "Domain Test" begin include("domains.jl") end
 @testset "Simplify Test" begin include("simplify.jl") end
 @testset "Ambiguity Test" begin include("ambiguity.jl") end
 @testset "Components Test" begin include("components.jl") end