Update ModelingToolkitUnitfulExt.jl

Author: ChrisRackauckas

ext/ModelingToolkitUnitfulExt.jl

@@ -96,28 +96,9 @@ function screen_unit(result)
     result
 end
 
-"""
-Test unit equivalence.
-"""
-equivalent(x, y) = isequal(1 * x, 1 * y)
 const unitless = Unitful.unit(1)
 
-"""
-Find the unit of a symbolic item.
-"""
-get_unit(x::Real) = unitless
 get_unit(x::Unitful.Quantity) = screen_unit(Unitful.unit(x))
-get_unit(x::AbstractArray) = map(get_unit, x)
-get_unit(x::MT.Num) = get_unit(value(x))
-function get_unit(x::Union{Symbolics.ArrayOp, Symbolics.Arr, Symbolics.CallWithMetadata})
-    get_literal_unit(x)
-end
-get_unit(op::Differential, args) = get_unit(args[1]) / get_unit(op.x)
-get_unit(op::typeof(getindex), args) = get_unit(args[1])
-get_unit(x::SciMLBase.NullParameters) = unitless
-get_unit(op::typeof(instream), args) = get_unit(args[1])
-
-get_literal_unit(x) = screen_unit(getmetadata(x, VariableUnit, unitless))
 
 function get_unit(op, args) # Fallback
     result = op(1 .* get_unit.(args)...)
@@ -128,76 +109,4 @@ function get_unit(op, args) # Fallback
     end
 end
 
-function get_unit(op::Integral, args)
-    unit = 1
-    if op.domain.variables isa Vector
-        for u in op.domain.variables
-            unit *= get_unit(u)
-        end
-    else
-        unit *= get_unit(op.domain.variables)
-    end
-    return get_unit(args[1]) * unit
-end
-
-function get_unit(op::Conditional, args)
-    terms = get_unit.(args)
-    terms[1] == unitless ||
-        throw(ValidationError(", in $op, [$(terms[1])] is not dimensionless."))
-    equivalent(terms[2], terms[3]) ||
-        throw(ValidationError(", in $op, units [$(terms[2])] and [$(terms[3])] do not match."))
-    return terms[2]
-end
-
-function get_unit(op::typeof(Symbolics._mapreduce), args)
-    if args[2] == +
-        get_unit(args[3])
-    else
-        throw(ValidationError("Unsupported array operation $op"))
-    end
-end
-
-function get_unit(op::Comparison, args)
-    terms = get_unit.(args)
-    equivalent(terms[1], terms[2]) ||
-        throw(ValidationError(", in comparison $op, units [$(terms[1])] and [$(terms[2])] do not match."))
-    return unitless
-end
-
-function get_unit(x::Symbolic)
-    if issym(x)
-        get_literal_unit(x)
-    elseif isadd(x)
-        terms = get_unit.(arguments(x))
-        firstunit = terms[1]
-        for other in terms[2:end]
-            termlist = join(map(repr, terms), ", ")
-            equivalent(other, firstunit) ||
-                throw(ValidationError(", in sum $x, units [$termlist] do not match."))
-        end
-        return firstunit
-    elseif ispow(x)
-        pargs = arguments(x)
-        base, expon = get_unit.(pargs)
-        @assert expon isa Unitful.DimensionlessUnits
-        if base == unitless
-            unitless
-        else
-            pargs[2] isa Number ? base^pargs[2] : (1 * base)^pargs[2]
-        end
-    elseif iscall(x)
-        op = operation(x)
-        if issym(op) || (iscall(op) && iscall(operation(op))) # Dependent variables, not function calls
-            return screen_unit(getmetadata(x, VariableUnit, unitless)) # Like x(t) or x[i]
-        elseif iscall(op) && !iscall(operation(op))
-            gp = getmetadata(x, Symbolics.GetindexParent, nothing) # Like x[1](t)
-            return screen_unit(getmetadata(gp, VariableUnit, unitless))
-        end  # Actual function calls:
-        args = arguments(x)
-        return get_unit(op, args)
-    else # This function should only be reached by Terms, for which `iscall` is true
-        throw(ArgumentError("Unsupported value $x."))
-    end
-end
-
 end # module UnitfulUnitCheck