Package evaluation to test YAAD on Julia 1.14.0-DEV.2302 (b8ba835509*) started at 2026-06-06T09:51:07.025 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 16.36s ################################################################################ # Installation # Installing YAAD... Resolving package versions... Updating `~/.julia/environments/v1.14/Project.toml` [7f19f2dd] + YAAD v0.1.0 Updating `~/.julia/environments/v1.14/Manifest.toml` ⌅ [b552c78f] + DiffRules v0.0.10 [692b3bcd] + JLLWrappers v1.8.0 [1914dd2f] + MacroTools v0.5.16 ⌅ [77ba4419] + NaNMath v0.3.7 [21216c6a] + Preferences v1.5.2 ⌅ [276daf66] + SpecialFunctions v0.10.3 ⌅ [90137ffa] + StaticArrays v0.12.6 [10745b16] + Statistics v1.11.1 [7f19f2dd] + YAAD v0.1.0 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [b77e0a4c] + InteractiveUtils v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [9e88b42a] + Serialization v1.11.0 [f489334b] + StyledStrings v1.13.0 [fa267f1f] + TOML v1.0.3 [8dfed614] + Test v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.2+0 [4536629a] + OpenBLAS_jll v0.3.33+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Installation completed after 3.05s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompiling project... 0.7 s ✓ NaNMath 1.0 s ✓ DiffRules 2.8 s ✓ YAAD 3 dependencies successfully precompiled in 5 seconds. 19 already precompiled. Precompilation completed after 30.42s ################################################################################ # Testing # Testing YAAD Status `/tmp/jl_iKzdYK/Project.toml` ⌅ [b552c78f] DiffRules v0.0.10 [1914dd2f] MacroTools v0.5.16 ⌅ [77ba4419] NaNMath v0.3.7 ⌅ [276daf66] SpecialFunctions v0.10.3 ⌅ [90137ffa] StaticArrays v0.12.6 [7f19f2dd] YAAD v0.1.0 [37e2e46d] LinearAlgebra v1.14.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_iKzdYK/Manifest.toml` ⌅ [b552c78f] DiffRules v0.0.10 [692b3bcd] JLLWrappers v1.8.0 [1914dd2f] MacroTools v0.5.16 ⌅ [77ba4419] NaNMath v0.3.7 [21216c6a] Preferences v1.5.2 ⌅ [276daf66] SpecialFunctions v0.10.3 ⌅ [90137ffa] StaticArrays v0.12.6 [10745b16] Statistics v1.11.1 [7f19f2dd] YAAD v0.1.0 [efe28fd5] OpenSpecFun_jll v0.5.6+0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [f489334b] StyledStrings v1.13.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.2+0 [4536629a] OpenBLAS_jll v0.3.33+0 [8e850b90] libblastrampoline_jll v5.15.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp10)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erf)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erf)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erf)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erf)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(secd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(secd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(secd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(secd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(gamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(gamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(gamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(gamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcx)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcx)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcx)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcx)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(invdigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(invdigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(invdigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(invdigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(dawson)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(dawson)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(dawson)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(dawson)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asinh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(tanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(+)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(+)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(+)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(+)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(transpose)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(transpose)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(transpose)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(transpose)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(rad2deg)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(rad2deg)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(rad2deg)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(rad2deg)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(besselj0)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinpi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinpi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinpi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sinpi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: `lgamma(x::Real)` is deprecated, use `(logabsgamma(x))[1]` instead. │ caller = _broadcast_getindex_evalf(f::typeof(lgamma), args::Float64) at broadcast.jl:702 [inlined] └ @ Base.Broadcast broadcast.jl:702 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: `lgamma(x::Real)` is deprecated, use `(logabsgamma(x))[1]` instead. │ caller = _broadcast_getindex_evalf(f::typeof(lgamma), args::Float64) at broadcast.jl:702 [inlined] └ @ Base.Broadcast broadcast.jl:702 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: `lgamma(x::Real)` is deprecated, use `(logabsgamma(x))[1]` instead. │ caller = _broadcast_getindex_evalf(f::typeof(lgamma), args::Float64) at broadcast.jl:702 [inlined] └ @ Base.Broadcast broadcast.jl:702 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log1p)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airybiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.lgamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atand)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atanh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(trigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(trigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(trigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(trigamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.tan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyaiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyaiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyaiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyaiprime)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyai)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyai)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyai)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(airyai)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(bessely1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(abs)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acotd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cbrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cbrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cbrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cbrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sin)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(-)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(-)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(-)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(-)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sqrt)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cospi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cospi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cospi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cospi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(NaNMath.log2)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(expm1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(expm1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(expm1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(expm1)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(digamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(digamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(digamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(digamma)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(atan)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(sech)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(exp)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asind)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(cos)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acot)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(coth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(coth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(coth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(coth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfi)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(deg2rad)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(deg2rad)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(deg2rad)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(deg2rad)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(inv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(inv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(inv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(inv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(log)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(erfcinv)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asec)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acosh)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acsc)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acoth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acoth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acoth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acoth)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asecd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asecd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asecd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(asecd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(acscd)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 Test Summary: | Pass Total Time broadcast math.jl | 88 88 5m10.5s ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::YAAD.Trait.Broadcasted{typeof(csch)}, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::Function, args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(*), ::Variable{Matrix{Float64}}, ::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::typeof(transpose), args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::typeof(transpose), args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::typeof(transpose), args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(f::typeof(transpose), args::Variable{Matrix{Float64}}; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 Test Summary: | Pass Total Time linalg.jl | 3 3 11.4s ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(cat), ::Variable{Matrix{Float64}}, ::Variable{Vector{Float64}}; kwargs::Base.Pairs{Symbol, Val{2}, Nothing, @NamedTuple{dims::Val{2}}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(cat), ::Variable{Matrix{Float64}}, ::Variable{Vector{Float64}}; kwargs::Base.Pairs{Symbol, Int64, Nothing, @NamedTuple{dims::Int64}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 Test Summary: | Pass Total Time cat | 2 2 9.4s ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(getindex), ::Variable{Array{Float64, 4}}, ::Colon, ::Int64, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(getindex), ::Variable{Array{Float64, 4}}, ::Colon, ::Int64, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(getindex), ::Variable{Array{Float64, 4}}, ::Colon, ::Int64, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(getindex), ::Variable{Array{Float64, 4}}, ::Colon, ::Int64, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(view), ::Variable{Array{Float64, 4}}, ::Colon, ::Colon, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(view), ::Variable{Array{Float64, 4}}, ::Colon, ::Colon, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(view), ::Variable{Array{Float64, 4}}, ::Colon, ::Colon, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(view), ::Variable{Array{Float64, 4}}, ::Colon, ::Colon, ::Colon, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(selectdim), ::Variable{Array{Float64, 4}}, ::Int64, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(selectdim), ::Variable{Array{Float64, 4}}, ::Int64, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(selectdim), ::Variable{Array{Float64, 4}}, ::Int64, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 ┌ Warning: use values(kwargs) instead of kwargs.data │ caller = CachedNode(::typeof(selectdim), ::Variable{Array{Float64, 4}}, ::Int64, ::Int64; kwargs::Base.Pairs{Symbol, Union{}, Nothing, @NamedTuple{}}) at comput_graph.jl:100 [inlined] └ @ YAAD ~/.julia/packages/YAAD/GQSCn/src/comput_graph.jl:100 Test Summary: | Pass Total Time index and slice | 3 3 9.0s Testing YAAD tests passed Testing completed after 350.54s PkgEval succeeded after 413.3s