Package evaluation to test AutoGrad on Julia 1.14.0-DEV.3071 (c76331c927*) started at 2026-09-01T20:13:49.345 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 12.92s ################################################################################ # Installation # Installing AutoGrad... Resolving package versions... Installed LogExpFunctions ───── v1.0.1 Installed OpenSpecFun_jll ───── v0.5.6+0 Installed IrrationalConstants ─ v0.2.6 Installed JLLWrappers ───────── v1.8.0 Installed Statistics ────────── v1.11.4 Installed TimerOutputs ──────── v0.5.29 Installed SpecialFunctions ──── v2.9.0 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.9.0 [10745b16] + Statistics v1.11.4 ⌅ [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 3.96s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 4.5 s ✓ TestEnv 1 dependency successfully precompiled in 5 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... 0.8 s ✓ DocStringExtensions 0.6 s ✓ ExprTools 1.0 s ✓ Statistics 2.2 s ✓ IrrationalConstants 1.3 s ✓ Preferences 2.8 s ✓ TimerOutputs 1.1 s ✓ LogExpFunctions 1.4 s ✓ JLLWrappers 1.5 s ✓ OpenSpecFun_jll 4.9 s ✓ SpecialFunctions 15.5 s ✓ AutoGrad 11 dependencies successfully precompiled in 33 seconds. 13 already precompiled. Precompilation completed after 54.56s ################################################################################ # Testing # Testing AutoGrad Status `/tmp/jl_4BiOJF/Project.toml` [6710c13c] AutoGrad v1.2.5 [276daf66] SpecialFunctions v2.9.0 [10745b16] Statistics v1.11.4 ⌅ [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_4BiOJF/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.9.0 [10745b16] Statistics v1.11.4 ⌅ [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... 174.560883 seconds (65.66 M allocations: 4.282 GiB, 1.62% gc time, 99.44% compilation time: 2% of which was recompilation) 27.668598 seconds (21.40 M allocations: 1.330 GiB, 2.94% gc time, 99.56% compilation time: 33% 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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [inlined] [13] macro expansion @ ~/.julia/packages/AutoGrad/1QZxP/test/core.jl:88 [inlined] 41.112471 seconds (17.34 M allocations: 1.065 GiB, 0.83% gc time, 97.64% 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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:1001 [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:1001 [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:2247 [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:2247 [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:1001 [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:1001 [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:2247 [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:2247 [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:1001 [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:1001 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:1001 [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:1001 [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:2247 [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:2247 [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:1001 [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:1001 [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:2247 [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:2247 [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:1001 [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:1001 [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:2247 [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:2247 [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:2247 [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] 96.417669 seconds (45.53 M allocations: 2.778 GiB, 0.89% gc time, 98.32% compilation time) 17.898553 seconds (7.59 M allocations: 479.117 MiB, 0.98% gc time, 99.17% 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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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:2247 [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] 10.015023 seconds (5.20 M allocations: 324.471 MiB, 0.50% gc time, 97.02% compilation time) 31.906265 seconds (12.87 M allocations: 827.238 MiB, 0.74% gc time, 99.49% compilation time) 196.884552 seconds (74.51 M allocations: 4.565 GiB, 0.97% gc time, 99.40% 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:2247 [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:2247 [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:335 [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:2247 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/runtests.jl:3 [31] include(mapexpr::Function, mod::Module, _path::String) @ Base Base.jl:335 [32] top-level scope @ none:6 [33] eval(m::Module, e::Any) @ Core boot.jl:618 [34] __script_entry_eval(mod::Module, ex::Any) @ Base client.jl:106 [inlined] [35] exec_options(opts::Base.JLOptions) @ Base client.jl:350 [36] _start() @ Base client.jl:695 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:2247 [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:2247 [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:1001 [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:1001 [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:1001 [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:2247 [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] 28.957881 seconds (8.18 M allocations: 533.758 MiB, 0.82% gc time, 98.09% compilation time) 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:1001 [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:1001 [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:2247 [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:1001 [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:1001 [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:2247 [inlined] [30] top-level scope @ ~/.julia/packages/AutoGrad/1QZxP/test/rosenbrock.jl:5 4.598118 seconds (3.65 M allocations: 119.567 MiB, 3.35% gc time) 14.483780 seconds (6.92 M allocations: 320.299 MiB, 1.50% gc time, 66.11% 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. 8.616185 seconds (3.15 M allocations: 197.762 MiB, 98.96% compilation time) 76.132319 seconds (30.23 M allocations: 1.830 GiB, 1.31% gc time, 99.18% compilation time) 34.110821 seconds (11.32 M allocations: 730.510 MiB, 0.73% gc time, 99.41% compilation time) Test Summary: | Pass Error Broken Total Time AutoGrad | 538 35 15 588 12m40.1s base | 111 111 2m50.8s cat | 20 20 18.7s core | 13 5 18 40.7s getindex | 206 19 225 1m36.1s Array | 73 73 26.1s Tuple | 8 6 14 5.7s Dict | 2 2 1.4s size | 3 3 1.2s indexing | 15 3 18 15.1s view | 2 2 6.8s Array | 73 73 19.9s Tuple | 8 6 14 3.6s Dict | 2 2 1.3s size | 3 3 0.0s indexing | 15 3 18 9.8s view | 2 2 3.7s highorder | 17 1 18 17.8s iterate | 8 6 14 10.0s LinearAlgebra | 34 14 48 31.8s math | 62 62 3m16.6s neuralnet | 3 3 6 28.8s rosenbrock | 6 2 8 13.5s sparse | 8 8 8.6s specialfunctions | 28 28 1m15.9s statistics | 22 22 33.3s RNG of the outermost testset: Xoshiro(0xf047b74c75ccd60e, 0x5a56e96130199fdf, 0x0a702ca3ad204713, 0x454cf0dbf6ebef03, 0x1897e8a6282ea21f) 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 726.39s 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:3283 [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 896.0s: package tests unexpectedly errored