use iscall

Author: TorkelE

Project.toml

@@ -23,6 +23,7 @@ Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SymbolicUtils = "d1185830-fcd6-423d-90d6-eec64667417b"
 Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"
+TermInterface = "8ea1fca8-c5ef-4a55-8b96-4e9afe9c9a3c"
 Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 [weakdeps]

ext/CatalystHomotopyContinuationExtension.jl

@@ -6,7 +6,8 @@ import DynamicPolynomials
 import ModelingToolkit as MT
 import HomotopyContinuation as HC
 import Setfield: @set
-import Symbolics: unwrap, wrap, Rewriters, symtype, issym, istree
+import Symbolics: unwrap, wrap, Rewriters, symtype, issym
+using TermInterface: iscall
 
 # Creates and exports hc_steady_states function.
 include("CatalystHomotopyContinuationExtension/homotopy_continuation_extension.jl")

ext/CatalystHomotopyContinuationExtension/homotopy_continuation_extension.jl

@@ -63,7 +63,7 @@ end
 # Parses and expression and return a version where any exponents that are Float64 (but an int, like 2.0) are turned into Int64s.
 make_int_exps(expr) = wrap(Rewriters.Postwalk(Rewriters.PassThrough(___make_int_exps))(unwrap(expr))).val
 function ___make_int_exps(expr)
-    !istree(expr) && return expr
+    !iscall(expr) && return expr
     if (operation(expr) == ^) 
         if isinteger(arguments(expr)[2])
             return arguments(expr)[1] ^ Int64(arguments(expr)[2])
@@ -76,7 +76,7 @@ end
 # If the input is a fraction, removes the denominator.
 function remove_denominators(expr)
     s_expr = simplify_fractions(expr)
-    !istree(expr) && return expr
+    !iscall(expr) && return expr
     if operation(s_expr) == /
         return remove_denominators(arguments(s_expr)[1])
     end

src/Catalyst.jl

@@ -24,7 +24,8 @@ RuntimeGeneratedFunctions.init(@__MODULE__)
 
 import Symbolics: BasicSymbolic
 import SymbolicUtils
-using ModelingToolkit: Symbolic, value, istree, get_unknowns, get_ps, get_iv, get_systems,
+using TermInterface: iscall
+using ModelingToolkit: Symbolic, value, get_unknowns, get_ps, get_iv, get_systems,
                        get_eqs, get_defaults, toparam, get_var_to_name, get_observed,
                        getvar
 

src/latexify_recipes.jl

@@ -194,7 +194,7 @@ function make_stoich_str(spec, stoich, subber; mathrm = true, kwargs...)
     if isequal(stoich, one(stoich))
         prestr * latexraw(subber(spec); kwargs...) * poststr
     else
-        if (stoich isa Symbolic) && istree(stoich)
+        if (stoich isa Symbolic) && iscall(stoich)
             LaTeXString("(") *
             latexraw(subber(stoich); kwargs...) *
             LaTeXString(")") *

src/reaction.jl

@@ -255,7 +255,7 @@ function print_rxside(io::IO, specs, stoich)
                      spec : MT.operation(spec)
             if isequal(stoich[i], one(stoich[i]))
                 print(io, prspec)
-            elseif istree(stoich[i])
+            elseif iscall(stoich[i])
                 print(io, "(", stoich[i], ")*", prspec)
             else
                 print(io, stoich[i], "*", prspec)

src/reactionsystem.jl

@@ -1443,7 +1443,7 @@ function validate(rs::ReactionSystem, info::String = "")
         # Needs additional checks because for cases: (1.0^n) and (1.0^n1)*(1.0^n2).
         # These are not considered (be default) considered equal to `1.0` for unitless reactions.
         isequal(rxunits, rateunits) && continue
-        if istree(rxunits)
+        if iscall(rxunits)
             unitless_exp(rxunits) && continue
             (operation(rxunits) == *) && all(unitless_exp(arg) for arg in arguments(rxunits)) && continue
         end
@@ -1456,4 +1456,4 @@ function validate(rs::ReactionSystem, info::String = "")
 end
 
 # Checks if a unit consist of exponents with base 1 (and is this unitless).
-unitless_exp(u) = istree(u) && (operation(u) == ^) && (arguments(u)[1] == 1)
+unitless_exp(u) = iscall(u) && (operation(u) == ^) && (arguments(u)[1] == 1)

src/reactionsystem_conversions.jl

@@ -560,7 +560,7 @@ function nonlinear_convert_differentials_check(rs::ReactionSystem)
         # If the contenct of the differential is not a variable (and nothing more).
         # If either of this is a case, throws the warning.
         if Symbolics._occursin(Symbolics.is_derivative, eq.rhs) ||
-                !Symbolics.istree(eq.lhs) ||
+                !Symbolics.iscall(eq.lhs) ||
                 !isequal(Symbolics.operation(eq.lhs), Differential(get_iv(rs))) || 
                 (length(arguments(eq.lhs)) != 1) ||
                 !any(isequal(arguments(eq.lhs)[1]), nonspecies(rs))
@@ -895,7 +895,7 @@ function to_multivariate_poly(polyeqs::AbstractVector{Symbolics.BasicSymbolic{Re
 
     pvar2sym, sym2term = SymbolicUtils.get_pvar2sym(), SymbolicUtils.get_sym2term()
     ps = map(polyeqs) do x
-        if istree(x) && operation(x) == (/)
+        if iscall(x) && operation(x) == (/)
             error("We should not be able to get here, please contact the package authors.")
         else
             PolyForm(x, pvar2sym, sym2term).p

src/registered_functions.jl

@@ -118,7 +118,7 @@ expand_registered_functions(expr)
 Takes an expression, and expands registered function expressions. E.g. `mm(X,v,K)` is replaced with v*X/(X+K). Currently supported functions: `mm`, `mmr`, `hill`, `hillr`, and `hill`.
 """
 function expand_registered_functions(expr)
-    istree(expr) || return expr
+    iscall(expr) || return expr
     args = arguments(expr)
     if operation(expr) == Catalyst.mm
         return args[2]*args[1]/(args[1] + args[3])

test/dsl/dsl_basic_model_construction.jl

@@ -2,8 +2,9 @@
 
 # Fetch packages.
 using DiffEqBase, Catalyst, Random, Test
-using ModelingToolkit: operation, istree, get_unknowns, get_ps, get_eqs, get_systems,
+using ModelingToolkit: operation, get_unknowns, get_ps, get_eqs, get_systems,
                        get_iv, nameof
+using TermInterface: iscall
 
 # Sets stable rng number.
 using StableRNGs
@@ -22,7 +23,7 @@ function unpacksys(sys)
     get_eqs(sys), get_iv(sys), get_unknowns(sys), get_ps(sys), nameof(sys), get_systems(sys)
 end
 
-opname(x) = istree(x) ? nameof(operation(x)) : nameof(x)
+opname(x) = iscall(x) ? nameof(operation(x)) : nameof(x)
 alleq(xs, ys) = all(isequal(x, y) for (x, y) in zip(xs, ys))
 
 # Gets all the reactants in a set of equations.