perhaps it would be nice to provide an example where injected parameters are inside a dictionary or object:

# parameters
import argparse
args = argparse.Namespace()
args_dict = {}

args.a = 1
args_dict['b'] = 2

papermill ... -p args.a 1.618 -p "args_dict['b']" 3.14159

This would of course be useful for making transition between *.py scripts (using e.g

@simonbyrne noticed that the Gallery/Tutorial is slow to load. we should think about breaking it up into sub-pages, or using SVG instead of SVGJS, or ...

Ankit Shah and I are trying to use Gen to support a project and would love the addition of a dirichlet distribution

Make tutorial compatible with julia 1.3, Knet 1.3. Start with a simpler programming style, push iterators and objects to later notebooks.

Add a print_bridge_graph functions that either

• throws an error in case there is no bridge layer used
• calls MOI.Bridges.print_graph on the bridge layer otherwise.

To implement this, inspiration can be taken from
https://github.com/JuliaOpt/JuMP.jl/blob/dd68f8107339b15b41be147d6454202530606a3f/src/JuMP.jl#L309-L345

This is a good first step for the "Visualization of bridge graph" GS

The documentation states that

Plots offers shorthands like png(fn), etc.

However, it appears that png() is the only convenience function that is exported, which is confusing for users trying to do pdf(fn).

I assume the intention is to export these functions? If not, having to

From the readme, section on Package status:

Currently, METADATA has a tag system but not all package authors use it, making it harder for lay users to know if the package maintenance is active or not.

I don't know how to do this, please add a link, or small tutorial. I'd like to do it.

After upgrading sympy to 1.5.1, I've noticed an error in sympy's Matrix constructor:

julia> using PyCall  #  [438e738f] PyCall v1.91.2
julia> sympy = PyCall.pyimport_conda("sympy", "sympy")
julia> sympy.__version__ # "1.5.1"
julia> sympy.Matrix([[1,1],[2,2]])
ERROR: PyError ($(Expr(:escape, :(ccall(#= /Users/verzani/.julia/packages/PyCall/ttONZ/src/pyfncall.jl:44 =# @pysym(:PyObject_

The selectors are only used in Store.get right now.

Solution:
Change store.getIn to use this.get for the first argument of the traversal array.

Hi,

Would be helpful to see shuffle, shuffle! functions in DataFrames. Used in randomizing machine learning mini batches.

What do you think?

Readme, re: eagermode is out of date

I found that function mod2pi is not implemented yet, but mod works. Is there any list of implemented functions? Minimal working example is:

using Zygote

# This is working
gradient(x -> mod(x, 2pi), 1.)

# This is not
gradient(x -> mod2pi(x), 1.)

@OvermindDL1 says "I think all the tests should be adjusted to take the integer on the program parameters or an environment variable or something. That would both prevent such optimizations and would allow for easily CI'd consistency checks."

In learning_curve! (but not only there) you can specify a measure which, by default, is set to rms; however if you leave it to default and try to do this on a classifier you'll get an error.

It would be easy to change so that it takes a reasonable default measure for the type of model something like

function learning_curve!(mach::Machine{<:Supervised};
                      

julia> (@cxx fabs(2.0);)
2.0

julia> (@cxx fabs(2.0);) == 2.0
true

julia> @cxx fabs(2.0) == 2.0;
ERROR: UndefVarError: fabs not defined
Stacktrace:
 [1] top-level scope at REPL[10]:1

julia> @cxx (fabs(2.0) == 2.0;)
ERROR: LoadError: Unrecognized CPP Expression begin
    fabs(2.0) == 2.0
end (block)
Stacktrace:
 [1] error(::String, ::Expr, ::String, ::Symbol, ::String) at ./e

the example at page https://julianlsolvers.github.io/Optim.jl/stable/#algo/complex/ fails.
the environment is:

• julia 1.1.1
• IJulia v1.20.2
• Optim v0.20.0

minimal (not) working example from the docs of the page linked above:

using Random, LinearAlgebra, Optim
Random.seed!(0) # Set the seed for reproducibility
# μ is the strength of the quartic. μ = 0 is just a quadratic problem

Plots.jl has a lot of small, easy-to-implement convenience functions and recipes that would be nice to have in AbstractPlotting, or StatsMakie.

• stephist:

    stephist(x)
    stephist(x)

Make a histogram step plot (bin counts are represented using horizontal lines
instead of bars). See `histogram`. 

• scatterhist:

    scatterhist(x)
    scatt

fit_mle(Beta, rand(10)) gives ERROR: suffstats is not implemented for (Beta, Array{Float64,1}).

I checked the source code and found there is a fit function implemented, but it doesn't take weights.

The docs explicitly say that fit_mle has been implemented for Beta.

I was trying to use the Julia: Execute Code Cell Command, but I didn't know what was the delimiter for a cell. Finally, I found it, but It would be nice to have a comment about it :).

Julia makes it really easy to run string macro code blocks for at least R and Matlab. But in vim they are highlighted in all green! It's an impediment to using other languages freely.

Vim markdown has code block highlighting (with g:markdown_fenced_languages etc), could something like that be possible for julia? It may be as easy as copying the markdown highlighting code and changing the regex

Hi there. It's my first day coding & I really appreciate this resource and I find it more or less easy to follow. However, I would recommend either providing a link to a glossary or simply having a glossary available for absolute beginners to explain terminology such as those referring to the various data types & examples given. Just to make the language a bit more accessible.

I'm enjoying

It would be handy for all edge operations to have both f(g, e) and f(g, src(e), dst(e)) defined by default on abstract graphs

The following snippets included in a test.jmd with the build command. Note I'm using """ to indicate code blocks as Github intercepts the markdown.

weave(papersdir("test.jmd"), 
  out_path=:doc,
  doctype = "md2pdf"
  )

demonstrate the various ways Figures are not working.

"""julia
using Plots

plot(1:10)
"""

This works, as expected. The plot takes up

Add a section to the README that discusses the tiers of support, re. the recent Julia update to the README by @ViralBShah.

It's been done in scikit-learn, and we should follow suit. It's not urgent because we're (almost) not relying on that Python code.