Merge branch 'master' into manual-smallfixes

Author: TymonKilich

.github/workflows/Downstream.yml

@@ -0,0 +1,55 @@
+
+name: IntegrationTest
+on:
+  push:
+    branches: [master]
+    tags: [v*]
+  pull_request:
+
+jobs:
+  test:
+    name: ${{ matrix.package.repo }}/${{ matrix.package.group }}
+    runs-on: ${{ matrix.os }}
+    env:
+      GROUP: ${{ matrix.package.group }}
+    strategy:
+      fail-fast: false
+      matrix:
+        julia-version: [1]
+        os: [ubuntu-latest]
+        package:
+          - {user: SciML, repo: ModelingToolkit.jl, group: All}
+          - {user: SciML, repo: Catalyst.jl, group: All}
+          - {user: SciML, repo: NeuralPDE.jl, group: NNPDE}
+          - {user: SciML, repo: DataDrivenDiffEq.jl, group: Standard}
+          - {user: JuliaSymbolics, repo: Symbolics.jl, group: All}
+          
+    steps:
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@v1
+        with:
+          version: ${{ matrix.julia-version }}
+          arch: x64
+      - uses: julia-actions/julia-buildpkg@latest
+      - name: Clone Downstream
+        uses: actions/checkout@v2
+        with:
+          repository: ${{ matrix.package.user }}/${{ matrix.package.repo }}
+          path: downstream
+      - name: Load this and run the downstream tests
+        shell: julia --color=yes --project=downstream {0}
+        run: |
+          using Pkg
+          try
+            # force it to use this PR's version of the package
+            Pkg.develop(PackageSpec(path="."))  # resolver may fail with main deps
+            Pkg.update()
+            Pkg.test()  # resolver may fail with test time deps
+          catch err
+            err isa Pkg.Resolve.ResolverError || rethrow()
+            # If we can't resolve that means this is incompatible by SemVer and this is fine
+            # It means we marked this as a breaking change, so we don't need to worry about
+            # Mistakenly introducing a breaking change, as we have intentionally made one
+            @info "Not compatible with this release. No problem." exception=err
+            exit(0)  # Exit immediately, as a success
+          end

Project.toml

@@ -1,7 +1,7 @@
 name = "SymbolicUtils"
 uuid = "d1185830-fcd6-423d-90d6-eec64667417b"
 authors = ["Shashi Gowda"]
-version = "0.8.4"
+version = "0.9.3"
 
 [deps]
 AbstractAlgebra = "c3fe647b-3220-5bb0-a1ea-a7954cac585d"
@@ -19,7 +19,7 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
 
 [compat]
-AbstractAlgebra = "0.9, 0.10, 0.11, 0.12, 0.13"
+AbstractAlgebra = "0.9, 0.10, 0.11, 0.12, 0.13, 0.14, 0.15"
 AbstractTrees = "0.3"
 Combinatorics = "1.0"
 ConstructionBase = "1.1"

src/SymbolicUtils.jl

@@ -7,7 +7,7 @@ export @syms, term, showraw, hasmetadata, getmetadata, setmetadata
 using DataStructures
 using Setfield
 import Setfield: PropertyLens
-import Base: +, -, *, /, \, ^, ImmutableDict
+import Base: +, -, *, /, //, \, ^, ImmutableDict
 using ConstructionBase
 include("types.jl")
 

src/api.jl

@@ -2,10 +2,10 @@
 
 """
 ```julia
-simplify(x; rewriter=default_simplifier(),
+simplify(x; polynorm=false,
             threaded=false,
-            polynorm=true,
-            thread_subtree_cutoff=100)
+            thread_subtree_cutoff=100,
+            rewriter=nothing)
 ```
 
 Simplify an expression (`x`) by applying `rewriter` until there are no changes.
@@ -60,3 +60,24 @@ function substitute(expr, dict; fold=true)
         expr
     end
 end
+
+"""
+    occursin(needle::Symbolic, haystack::Symbolic)
+
+Determine whether the second argument contains the first argument. Note that
+this function doesn't handle associativity, commutativity, or distributivity.
+"""
+Base.occursin(needle::Symbolic, haystack::Symbolic) = _occursin(needle, haystack)
+Base.occursin(needle, haystack::Symbolic) = _occursin(needle, haystack)
+Base.occursin(needle::Symbolic, haystack) = _occursin(needle, haystack)
+function _occursin(needle, haystack)
+    isequal(needle, haystack) && return true
+
+    if istree(haystack)
+        args = arguments(haystack)
+        for arg in args
+            occursin(needle, arg) && return true
+        end
+    end
+    return false
+end

src/code.jl

@@ -96,23 +96,39 @@ Base.convert(::Type{Assignment}, p::Pair) = Assignment(pair[1], pair[2])
 
 toexpr(a::Assignment, st) = :($(toexpr(a.lhs, st)) = $(toexpr(a.rhs, st)))
 
-function toexpr(O, st)
-    !istree(O) && return O
-    op = operation(O)
+function_to_expr(op, args, st) = nothing
+
+function function_to_expr(::typeof(^), O, st)
     args = arguments(O)
-    if op === (^) && length(args) == 2 && args[2] isa Number && args[2] < 0
+    if length(args) == 2 && args[2] isa Number && args[2] < 0
         ex = args[1]
         if args[2] == -1
             return toexpr(Term{Any}(inv, [ex]), st)
         else
             return toexpr(Term{Any}(^, [Term{Any}(inv, [ex]), -args[2]]), st)
         end
-    elseif op === (SymbolicUtils.ifelse)
-        return :($(toexpr(args[1], st)) ? $(toexpr(args[2], st)) : $(toexpr(args[3], st)))
-    elseif op isa Sym && haskey(st.symbolify, O)
-        return st.symbolify[O]
     end
-    return Expr(:call, toexpr(op, st), map(x->toexpr(x, st), args)...)
+    return nothing
+end
+
+function function_to_expr(::typeof(SymbolicUtils.ifelse), O, st)
+    args = arguments(O)
+    :($(toexpr(args[1], st)) ? $(toexpr(args[2], st)) : $(toexpr(args[3], st)))
+end
+
+function_to_expr(::Sym, O, st) = get(st.symbolify, O, nothing)
+
+function toexpr(O, st)
+    !istree(O) && return O
+    op = operation(O)
+    expr′ = function_to_expr(op, O, st)
+    if expr′ !== nothing
+        return expr′
+    else
+        haskey(st.symbolify, O) && return st.symbolify[O]
+        args = arguments(O)
+        return Expr(:call, toexpr(op, st), map(x->toexpr(x, st), args)...)
+    end
 end
 
 # Call elements of vector arguments by their name.
@@ -464,23 +480,33 @@ end
 
 struct Multithreaded end
 """
-    SpawnFetch{ParallelType}(exprs, reduce)
+    SpawnFetch{ParallelType}(funcs [, args], reduce)
 
-Run every expr in `exprs` in its own task, and use the `reduce`
-function to combine the results of executing `exprs`.
+Run every expression in `funcs` in its own task, the expression
+should be a `Func` object and is passed to `Threads.Task(f)`.
+If `Func` takes arguments, then the arguments must be passed in as `args`--a vector of vector of arguments to each function in `funcs`. We don't use `@spawn` in order to support RuntimeGeneratedFunctions which disallow closures, instead we interpolate these functions or closures as smaller RuntimeGeneratedFunctions.
+
+`reduce` function is used to combine the results of executing `exprs`. A SpawnFetch expression returns the reduced result.
+
+
+Use `Symbolics.MultithreadedForm` ParallelType from the Symbolics.jl package to get the RuntimeGeneratedFunction version SpawnFetch.
 
 `ParallelType` can be used to define more parallelism types
 SymbolicUtils supports `Multithreaded` type. Which spawns
 threaded tasks.
 """
 struct SpawnFetch{Typ}
     exprs::Vector
+    args::Union{Nothing, Vector}
     combine
 end
 
+(::Type{SpawnFetch{T}})(exprs, combine) where {T} = SpawnFetch{T}(exprs, nothing, combine)
+
 function toexpr(p::SpawnFetch{Multithreaded}, st)
-    spawns = map(p.exprs) do thunk
-        :(Base.Threads.@spawn $(toexpr(thunk, st)))
+    args = isnothing(p.args) ? Iterators.repeated((), length(p.exprs)) : p.args
+    spawns = map(p.exprs, args) do thunk, xs
+        :(Base.Threads.@spawn $(toexpr(thunk, st))($(toexpr.(xs, (st,))...)))
     end
     quote
         $(toexpr(p.combine, st))(map(fetch, ($(spawns...),))...)

src/types.jl

@@ -69,7 +69,7 @@ function getmetadata(s::Symbolic, ctx)
 end
 
 function getmetadata(s::Symbolic, ctx, default)
-    s.metadata isa Ref ? get(s.metadata[], ctx, default) : default
+    s.metadata isa AbstractDict ? get(s.metadata, ctx, default) : default
 end
 
 # pirated for Setfield purposes:
@@ -173,9 +173,9 @@ end
 
 Base.nameof(s::Sym) = s.name
 
-ConstructionBase.constructorof(s::Type{<:Sym{T}}) where {T} = Sym{T}
+ConstructionBase.constructorof(s::Type{<:Sym{T}}) where {T} = (n,m) -> Sym{T}(n, metadata=m)
 
-function (::Type{Sym{T}})(name, metadata=NO_METADATA) where {T}
+function (::Type{Sym{T}})(name; metadata=NO_METADATA) where {T}
     Sym{T, typeof(metadata)}(name, metadata)
 end
 
@@ -327,14 +327,14 @@ function ConstructionBase.constructorof(s::Type{<:Term{T}}) where {T}
     end
 end
 
-function (::Type{Term{T}})(f, args, metadata=NO_METADATA) where {T}
+function (::Type{Term{T}})(f, args; metadata=NO_METADATA) where {T}
     Term{T, typeof(metadata)}(f, args, metadata, Ref{UInt}(0))
 end
 
 istree(t::Term) = true
 
-function Term(f, args, metadata=NO_METADATA)
-    Term{_promote_symtype(f, args)}(f, args, metadata)
+function Term(f, args; metadata=NO_METADATA)
+    Term{_promote_symtype(f, args)}(f, args, metadata=metadata)
 end
 
 operation(x::Term) = getfield(x, :f)
@@ -422,13 +422,20 @@ end
 setargs(t, args) = Term{symtype(t)}(operation(t), args)
 cdrargs(args) = setargs(t, cdr(args))
 
-print_arg(io, x::Union{Complex, Rational}) = print(io, "(", x, ")")
-print_arg(io, x) = print(io, x)
-print_arg(io, f::typeof(^), x) = print_arg(IOContext(io, :paren=>true), x)
+print_arg(io, x::Union{Complex, Rational}; paren=true) = print(io, "(", x, ")")
+isbinop(f) = istree(f) && Base.isbinaryoperator(nameof(operation(f)))
+function print_arg(io, x; paren=false)
+    if paren && isbinop(x)
+        print(io, "(", x, ")")
+    else
+        print(io, x)
+    end
+end
+print_arg(io, s::String; paren=true) = show(io, s)
 function print_arg(io, f, x)
     f !== (*) && return print_arg(io, x)
-    if istree(x) && Base.isbinaryoperator(nameof(operation(x)))
-        print_arg(IOContext(io, :paren=>true), x)
+    if Base.isbinaryoperator(nameof(f))
+        print_arg(io, x, paren=true)
     else
         print_arg(io, x)
     end
@@ -447,11 +454,19 @@ function show_add(io, args)
             print_arg(io, -, t)
         else
             print(io, " - ")
-            print_arg(IOContext(io, :paren=>true), +, -t)
+            print_arg(io, -t, paren=true)
         end
     end
 end
 
+function show_pow(io, args)
+    base, ex = args
+
+    print_arg(io, base, paren=true)
+    print(io, "^")
+    print_arg(io, ex, paren=true)
+end
+
 function show_mul(io, args)
     length(args) == 1 && return print_arg(io, *, args[1])
 
@@ -480,8 +495,8 @@ function show_call(io, f, args)
     binary = Base.isbinaryoperator(fname)
     if binary
         for (i, t) in enumerate(args)
-            i != 1 && print(io, fname == :^ ? fname : " $fname ")
-            print_arg(io, (^), t)
+            i != 1 && print(io, " $fname ")
+            print_arg(io, t)
         end
     else
         if f isa Sym
@@ -506,15 +521,15 @@ function show_term(io::IO, t)
     f = operation(t)
     args = arguments(t)
 
-    get(io, :paren, false) && print(io, "(")
     if f === (+)
         show_add(io, args)
     elseif f === (*)
         show_mul(io, args)
+    elseif f === (^)
+        show_pow(io, args)
     else
         show_call(io, f, args)
     end
-    get(io, :paren, false) && print(io, ")")
 
     return nothing
 end
@@ -714,7 +729,7 @@ operation(a::Mul) = *
 
 function arguments(a::Mul)
     a.sorted_args_cache[] !== nothing && return a.sorted_args_cache[]
-    args = sort!([k^v for (k,v) in a.dict], lt=<ₑ)
+    args = sort!([Pow(k, v) for (k,v) in a.dict], lt=<ₑ)
     a.sorted_args_cache[] = isone(a.coeff) ? args : vcat(a.coeff, args)
 end
 
@@ -766,6 +781,10 @@ mul_t(a) = promote_symtype(*, symtype(a))
 
 /(a::SN, b::Number) = inv(b) * a
 
+//(a::Union{SN, Number}, b::SN) = a / b
+
+//(a::SN, b::T) where {T <: Number} = (one(T) // b) * a
+
 """
     Pow(base, exp)
 
@@ -887,7 +906,17 @@ struct TreePrint
     x
 end
 AbstractTrees.children(x::Term) = arguments(x)
-AbstractTrees.children(x::Union{Add, Mul}) = map(y->TreePrint(x isa Add ? (:*) : (:^), y), collect(pairs(x.dict)))
+function AbstractTrees.children(x::Union{Add, Mul})
+    children = Any[x.coeff]
+    for (key, coeff) in pairs(x.dict)
+        if coeff == 1
+            push!(children, key)
+        else
+            push!(children, TreePrint(x isa Add ? (:*) : (:^), (key, coeff)))
+        end
+    end
+    return children
+end
 AbstractTrees.children(x::Union{Pow}) = [x.base, x.exp]
 AbstractTrees.children(x::TreePrint) = [x.x[1], x.x[2]]
 

test/basics.jl

@@ -112,6 +112,11 @@ end
     @test SymbolicUtils.promote_symtype(ifelse, Bool, Int, Bool) == Union{Int, Bool}
     @test_throws MethodError w < 0
     @test isequal(w == 0, Term{Bool}(==, [w, 0]))
+
+    @eqtest x // 5 == (1 // 5) * x
+    @eqtest x // Int16(5) == Rational{Int16}(1, 5) * x
+    @eqtest 5 // x == 5 / x
+    @eqtest x // a == x / a
 end
 
 @testset "err test" begin
@@ -127,6 +132,13 @@ end
     @test substitute(exp(a), Dict(a=>2)) ≈ exp(2)
 end
 
+@testset "occursin" begin
+    @syms a b c
+    @test occursin(a, a + b)
+    @test !occursin(sin(a), a + b + c)
+    @test occursin(sin(a),  a * b + c + sin(a^2 * sin(a)))
+end
+
 @testset "printing" begin
     @syms a b c
     @test repr(a+b) == "a + b"