Package evaluation to test AutoGrad on Julia 1.14.0-DEV.2802 (918269a29b*) started at 2026-07-29T05:30:28.005 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 12.83s ################################################################################ # Installation # Installing AutoGrad... Resolving package versions... Installed OpenSpecFun_jll ───── v0.5.6+0 Installed IrrationalConstants ─ v0.2.6 Installed JLLWrappers ───────── v1.8.0 Installed LogExpFunctions ───── v1.0.1 Installed SpecialFunctions ──── v2.8.0 Installed Statistics ────────── v1.11.1 Installed TimerOutputs ──────── v0.5.29 Installed Preferences ───────── v1.5.2 Installed ExprTools ─────────── v0.1.11 Installed DocStringExtensions ─ v0.9.5 Installed AutoGrad ──────────── v1.2.5 Installing 1 artifacts Installed artifact OpenSpecFun 105.4 KiB Updating `~/.julia/environments/v1.14/Project.toml` [6710c13c] + AutoGrad v1.2.5 Updating `~/.julia/environments/v1.14/Manifest.toml` [6710c13c] + AutoGrad v1.2.5 [ffbed154] + DocStringExtensions v0.9.5 [e2ba6199] + ExprTools v0.1.11 [92d709cd] + IrrationalConstants v0.2.6 [692b3bcd] + JLLWrappers v1.8.0 [2ab3a3ac] + LogExpFunctions v1.0.1 [21216c6a] + Preferences v1.5.2 [276daf66] + SpecialFunctions v2.8.0 [10745b16] + Statistics v1.11.1 ⌅ [a759f4b9] + TimerOutputs v0.5.29 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [56f22d72] + Artifacts v1.11.0 [ade2ca70] + Dates v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [de0858da] + Printf v1.11.0 [fa267f1f] + TOML v1.0.3 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.7+0 [4536629a] + OpenBLAS_jll v0.3.34+0 [05823500] + OpenLibm_jll v0.8.7+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 4.47s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 4.1 s ✓ TestEnv 1 dependency successfully precompiled in 4 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... 0.9 s ✓ DocStringExtensions 0.6 s ✓ ExprTools 0.8 s ✓ Statistics 2.0 s ✓ IrrationalConstants 1.2 s ✓ Preferences 2.8 s ✓ TimerOutputs 1.3 s ✓ LogExpFunctions 2.2 s ✓ JLLWrappers 1.7 s ✓ OpenSpecFun_jll 6.1 s ✓ SpecialFunctions 14.5 s ✓ AutoGrad 11 dependencies successfully precompiled in 34 seconds. 13 already precompiled. Precompilation completed after 59.56s ################################################################################ # Testing # Testing AutoGrad Status `/tmp/jl_qSMsJt/Project.toml` [6710c13c] AutoGrad v1.2.5 [276daf66] SpecialFunctions v2.8.0 [10745b16] Statistics v1.11.1 ⌅ [a759f4b9] TimerOutputs v0.5.29 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [9a3f8284] Random v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_qSMsJt/Manifest.toml` [6710c13c] AutoGrad v1.2.5 [ffbed154] DocStringExtensions v0.9.5 [e2ba6199] ExprTools v0.1.11 [92d709cd] IrrationalConstants v0.2.6 [692b3bcd] JLLWrappers v1.8.0 [2ab3a3ac] LogExpFunctions v1.0.1 [21216c6a] Preferences v1.5.2 [276daf66] SpecialFunctions v2.8.0 [10745b16] Statistics v1.11.1 ⌅ [a759f4b9] TimerOutputs v0.5.29 [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.7+0 [4536629a] OpenBLAS_jll v0.3.34+0 [05823500] OpenLibm_jll v0.8.7+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... 187.574459 seconds (64.56 M allocations: 4.233 GiB, 1.38% gc time, 99.52% compilation time: 1% of which was recompilation) 65.254077 seconds (33.47 M allocations: 2.165 GiB, 1.97% gc time, 99.81% compilation time: 67% of which was recompilation) core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:15 Test threw exception Expression: ∇(m, x, y) isa Dict MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::AutoGrad.Result{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:15 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:12 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:17. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:20 Test threw exception Expression: ∇(m, x, y) isa Dict MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::AutoGrad.Result{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Dict{Symbol, Vector{Array{Float64}}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Dict{Symbol, Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:20 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition pred(Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:11 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:25. WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:17 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:26. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:28 Test threw exception Expression: ∇(m, x, y) isa Array MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Vector{Array{Float64}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:28 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:26 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:29. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:31 Test threw exception Expression: ∇(m, x, y) isa Array MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Array{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#loss#loss##0", ::Param{Vector{Array{Float64}}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Array{Float64}}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#loss#loss##0", Int64, Bool}})(::Vector{Array{Float64}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:31 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] WARNING: Method definition f(Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:47 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:62. ┌ Warning: Output independent of params └ @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:159 WARNING: Method definition f(Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:62 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:67. WARNING: Method definition loss(Any, Any, Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:29 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:86. core: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/core.jl:4 Got exception outside of a @test MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Vector{Float64}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Vector{Float64}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Vector{Float64}}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Vector{Float64}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#86#87"{Param{Vector{Vector{Float64}}}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:7 [12] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [13] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:88 [inlined] 51.538907 seconds (18.04 M allocations: 1.115 GiB, 0.70% gc time, 98.21% compilation time: 2% of which was recompilation) Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 Test threw exception Expression: gradcheck(s1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#s0#s0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:71 [14] gcsum(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float32, Float32, Nothing}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Tuple{Float32, Float32, Float32}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float32, Float32, Float32}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 Test threw exception Expression: gradcheck(f1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#97#98", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:83 [14] gcsum(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float32, Float32, Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Tuple{Float32, Float32, Float32}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float32, Float32, Float32}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 Test threw exception Expression: gradcheck(r1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float32, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float32, xi::AutoGrad.Result{Float32}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#r0#r0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:94 [14] gcsum(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float32, Float32, Float32}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float32, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float32, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float32}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Tuple{Float32, Float32, Float32}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float32, Float32, Float32}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] Tuple: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 Test threw exception Expression: g(t, i) == g(a, i) == nothing || g(t, i) == tuple(g(a, i)...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::var"#f#f##2", ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#f#f##2", Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:29 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [17] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] [18] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [19] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:36 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 Test threw exception Expression: gradcheck(s1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#s0#s0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:71 [14] gcsum(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Nothing}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#s1sum#s1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#s0#s0##0", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:78 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 Test threw exception Expression: gradcheck(f1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#97#98", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:83 [14] gcsum(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#f1sum#f1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#97#98", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:89 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] indexing: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 Test threw exception Expression: gradcheck(r1sum, t1) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#r0#r0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:94 [14] gcsum(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#r1sum#r1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#r0#r0##0", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [28] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [29] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:65 [inlined] [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [31] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:100 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] getindex: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:124 Test threw exception Expression: g1(a) == g2(a) MethodError: Cannot `convert` an object of type Tuple{Int64, Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64, Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64, Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64, Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32}}})(::Nothing, d::Tuple{Int64, Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Matrix{Array{Float32}}, dxi::Vector{Float32}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Matrix{Array{Float32}}}, dxi::Vector{Float32}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float32}, xi::AutoGrad.Result{Vector{Float32}}, x::Param{Matrix{Array{Float32}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#109#110", x::Param{Matrix{Array{Float32}}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(f::Function, x::Param{Matrix{Array{Float32}}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#109#110", Int64, Bool}})(args::Matrix{Array{Float32}}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#109#110", Int64, Bool}})(args::Matrix{Array{Float32}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:5 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/getindex.jl:124 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] 140.061738 seconds (45.09 M allocations: 2.763 GiB, 0.76% gc time, 98.66% compilation time) 25.390905 seconds (7.71 M allocations: 489.186 MiB, 0.52% gc time, 99.34% compilation time) iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 Test threw exception Expression: gradcheck(itr1, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float32, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float32, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float32, 3}}, x::Param{Vector{Array{Float32, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr1#itr1##0", x::Vector{Array{Float32, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 Test threw exception Expression: gradcheck(itr2, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float32, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float32, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float32, 3}}, x::Param{Vector{Array{Float32, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr2#itr2##0", x::Vector{Array{Float32, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 Test threw exception Expression: gradcheck(itr4, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float32, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float32, 3}}, dxi::Array{Float32, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float32, 3}}}, dxi::Array{Float32, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float32, 3}, xi::AutoGrad.Result{Array{Float32, 3}}, x::Param{Vector{Array{Float32, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr4#itr4##0", x::Vector{Array{Float32, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 Test threw exception Expression: gradcheck(itr1, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float64, 3}}, x::Param{Vector{Array{Float64, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr1#itr1##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr1#itr1##0", x::Vector{Array{Float64, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:34 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 Test threw exception Expression: gradcheck(itr2, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float64, 3}}, x::Param{Vector{Array{Float64, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr2#itr2##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr2#itr2##0", x::Vector{Array{Float64, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:35 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] iterate: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 Test threw exception Expression: gradcheck(itr4, warray; o...) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Union{Nothing, Array{Float64, 3}}})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Array{Float64, 3}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Array{Float64, 3}}}, dxi::Array{Float64, 3}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Array{Float64, 3}, xi::AutoGrad.Result{Array{Float64, 3}}, x::Param{Vector{Array{Float64, 3}}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, var"#itr4#itr4##0", Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(f::var"#itr4#itr4##0", x::Vector{Array{Float64, 3}}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [13] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:4 [14] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [15] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/iterate.jl:39 [inlined] [16] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] 14.328014 seconds (5.15 M allocations: 323.483 MiB, 0.78% gc time, 97.35% compilation time) 41.474558 seconds (13.19 M allocations: 852.029 MiB, 0.60% gc time, 99.59% compilation time) 212.383052 seconds (72.88 M allocations: 4.492 GiB, 0.84% gc time, 99.45% compilation time) neuralnet: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 Test threw exception Expression: gradcheck(n0, wa, rand(3, 10), rand(2, 10)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n0), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n0), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [11] gradcheck(::typeof(n0), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [12] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [13] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [14] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [15] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [16] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [inlined] [17] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:91 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::AutoGrad.Result{Vector{Float64}}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::typeof(n0), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] n1sum(w::Param{Vector{Any}}, x::Param{Matrix{Float64}}, y::Param{Matrix{Float64}}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:6 [14] gcsum(::typeof(n1sum), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] (::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}})() @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:205 [inlined] [17] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:144 [18] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [19] gradcheck(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [20] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [21] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [22] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [23] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [24] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 [inlined] [25] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [26] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:330 [27] macro expansion @ ./timing.jl:741 [inlined] [28] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:14 [inlined] [29] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:3 [31] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:330 [32] top-level scope @ none:6 [33] eval(m::Module, e::Any) @ Core boot.jl:545 [34] __script_entry_eval(mod::Module, ex::Any) @ Base client.jl:106 [inlined] [35] exec_options(opts::Base.JLOptions) @ Base client.jl:344 [36] _start() @ Base client.jl:619 neuralnet: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 Test threw exception Expression: gradcheck(n1sum, wa, rand(3, 10), rand(2, 10)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:148 [2] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [3] gradcheck(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [4] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [5] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [6] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [7] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [8] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 [inlined] [9] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] caused by: MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::AutoGrad.Result{Vector{Float64}}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:91 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::AutoGrad.Result{Vector{Float64}}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::typeof(n0), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] n1sum(w::Param{Vector{Any}}, x::Param{Matrix{Float64}}, y::Param{Matrix{Float64}}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:6 [14] gcsum(::typeof(n1sum), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] (::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}})() @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:205 [inlined] [17] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:144 [18] differentiate(::AutoGrad.var"#207#208"{Tuple{}, typeof(n1sum), Vector{Any}}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [inlined] [19] gradcheck(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:39 [20] gradcheck(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [21] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [22] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [23] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [24] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:16 [inlined] [25] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] neuralnet: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:17 Test threw exception Expression: gradcheck(n1sum, wt, rand(3, 10), rand(2, 10)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::Param{Vector{Any}}, dxi::Vector{Float64}, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Vector{Float64}, xi::AutoGrad.Result{Vector{Float64}}, x::Param{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(::typeof(n0), ::Param{Vector{Any}}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Vector{Any}, ::Vararg{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{typeof(n0), Int64, Bool}})(::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [13] n1sum(w::Vector{Any}, x::Matrix{Float64}, y::Matrix{Float64}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:6 [14] gcsum(::typeof(n1sum), ::Vector{Any}, ::Vararg{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Matrix{Float64}, gptr::Matrix{Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [22] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, typeof(n1sum), Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [25] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, typeof(n1sum), Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [26] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, typeof(n1sum), Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [27] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [28] gradcheck(::typeof(n1sum), ::Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, ::Vararg{Any}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [29] gradcheck(::Function, ::Tuple{Matrix{Float64}, Vector{Float64}, Matrix{Float64}, Vector{Float64}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [30] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [31] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:13 [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [33] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/neuralnet.jl:17 [inlined] [34] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] 37.423500 seconds (8.47 M allocations: 552.642 MiB, 0.56% gc time, 98.71% compilation time: <1% of which was recompilation) rosenbrock: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:13 Test threw exception Expression: gradcheck(b1sum, (randn(2)...,)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#b0#b0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:7 [14] gcsum(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Tuple{Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [28] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:13 [inlined] [29] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:5 rosenbrock: Error During Test at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:15 Test threw exception Expression: gradcheck(b1sum, (randn(3)...,)) MethodError: Cannot `convert` an object of type Tuple{Int64} to an object of type Int64 The function `convert` exists, but no method is defined for this combination of argument types. Closest candidates are: convert(::Type{T}, !Matched::T) where T<:Number @ Base number.jl:6 convert(::Type{T}, !Matched::Number) where T<:Number @ Base number.jl:7 convert(::Type{T}, !Matched::T) where T @ Base Base_compiler.jl:137 ... Stacktrace: [1] (::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}})(n::Int64) @ Base essentials.jl:664 [inlined] [2] macro expansion @ ntuple.jl:68 [inlined] [3] ntuple(f::Base.var"#cvt1#convert##0"{Tuple{Vararg{Int64}}, Tuple{Tuple{Int64}}}, ::Val{1}) @ Base ntuple.jl:65 [inlined] [4] convert(::Core.TypeEgal{Tuple{Vararg{Int64}}}, x::Tuple{Tuple{Int64}}) @ Base essentials.jl:666 [5] (Array{Any})(::Nothing, d::Tuple{Int64}) @ Base baseext.jl:42 [6] ungetindex(x::Vector{Any}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:77 [7] ungetindex(x::AutoGrad.Result{Vector{Any}}, dxi::Float64, i::Tuple{Int64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/getindex.jl:92 [8] back(::typeof(getindex), ::Type{AutoGrad.Arg{1}}, dxi::Float64, xi::AutoGrad.Result{Float64}, x::AutoGrad.Result{Vector{Any}}, i::Int64) @ AutoGrad none:-1 [9] differentiate(f::var"#b0#b0##0", x::Param{Vector{Any}}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:165 [10] differentiate(::Function, ::Param{Vector{Any}}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:134 [11] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}; kwargs::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:225 [12] (::AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}})(args::Vector{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/src/core.jl:220 [inlined] [13] (::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}})(x::Vector{Any}) @ Main ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:7 [14] gcsum(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Vector{Any}; o::@Kwargs{}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:50 [15] gcsum(::Function, ::Vector{Any}, ::Vararg{Any}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:49 [16] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Tuple{Float64, Float64, Float64}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:74 [17] (::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64})(j::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:99 [18] _all(f::AutoGrad.var"#gcwalk##0#gcwalk##1"{Int64, Vector{Any}, Vector{Any}, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Tuple{}, Int64, Int64, Float64, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [19] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [20] gcwalk(i::Int64, xptr::Vector{Any}, gptr::Vector{Any}, f0::Float64, f::Function, x::Vector{Any}, kw::Tuple{}, nsample::Int64, verbose::Int64, delta::Float64, rtol::Float64, atol::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:98 [21] (::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64})(i::Int64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:45 [inlined] [22] _all(f::AutoGrad.var"#209#210"{Tuple{}, Int64, Int64, Float64, Float64, Float64, var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, Vector{Any}, Vector{Any}, Float64}, itr::UnitRange{Int64}, ::Colon) @ Base anyall.jl:211 [23] all(f::Function, a::UnitRange{Int64}; dims::Colon) @ Base reducedim.jl:994 [24] gradcheck(f::var"#b1sum#b1sum##0"{AutoGrad.var"#gradfun#grad##0"{AutoGrad.var"#gradfun#4#grad##1"{var"#b0#b0##0", Int64, Bool}}}, x::Tuple{Float64, Float64, Float64}; kw::Tuple{}, args::Function, nsample::Int64, verbose::Int64, rtol::Float64, atol::Float64, delta::Float64) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:44 [25] gradcheck(f::Function, x::Tuple{Float64, Float64, Float64}) @ AutoGrad ~/.julia/packages/AutoGrad/1QZxP/test/gradcheck.jl:35 [26] eval_test_function(func::Any, args::Any, kwargs::Any, quoted_func::Union{Expr, Symbol}, source::LineNumberNode, negate::Bool) @ Test /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:407 [27] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:781 [inlined] [28] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:15 [inlined] [29] macro expansion @ /opt/julia/share/julia/stdlib/v1.14/Test/src/Test.jl:2246 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:5 5.683788 seconds (3.65 M allocations: 119.567 MiB) 18.468206 seconds (6.83 M allocations: 316.560 MiB, 0.39% gc time, 67.67% compilation time) WARNING: Method definition foo(Any) in module Main at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/sparse.jl:20 overwritten at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/sparse.jl:26. 12.564625 seconds (3.53 M allocations: 224.267 MiB, 0.47% gc time, 99.25% compilation time) 105.906810 seconds (29.53 M allocations: 1.800 GiB, 1.05% gc time, 99.44% compilation time) 46.873456 seconds (11.17 M allocations: 724.942 MiB, 0.65% gc time, 99.53% compilation time: <1% of which was recompilation) Test Summary: | Pass Error Broken Total Time AutoGrad | 538 35 15 588 15m59.8s base | 111 111 3m03.9s cat | 20 20 21.8s core | 13 5 18 51.2s getindex | 206 19 225 2m19.7s Array | 73 73 39.8s Tuple | 8 6 14 8.6s Dict | 2 2 1.7s size | 3 3 1.8s indexing | 15 3 18 20.7s view | 2 2 9.5s Array | 73 73 30.3s Tuple | 8 6 14 4.7s Dict | 2 2 1.7s size | 3 3 0.0s indexing | 15 3 18 12.9s view | 2 2 5.5s highorder | 17 1 18 25.3s iterate | 8 6 14 14.3s LinearAlgebra | 34 14 48 41.4s math | 62 62 3m32.1s neuralnet | 3 3 6 37.4s rosenbrock | 6 2 8 17.3s sparse | 8 8 12.5s specialfunctions | 28 28 1m45.8s statistics | 22 22 45.9s RNG of the outermost testset: Xoshiro(0x8f83250e36f31812, 0x528cc1257ac9b6aa, 0x5246096217672bcb, 0x72dca3ee5300bf03, 0x469012ed6159501c) ERROR: LoadError: Some tests did not pass: 538 passed, 0 failed, 35 errored, 15 broken. in expression starting at /home/pkgeval/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:2 Testing failed after 961.25s ERROR: LoadError: Package AutoGrad errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3247 [3] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [4] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [5] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [6] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [7] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 1093.55s: package tests unexpectedly errored